Class containing the algorithm to perform the simple circle fit. More...

#include <QualityEstimatorCircleFit.h>

Inheritance diagram for QualityEstimatorCircleFit:

Collaboration diagram for QualityEstimatorCircleFit:

Public Member Functions
virtual double	estimateQuality (std::vector< SpacePoint const * > const &measurements) final
	Minimal implementation of the quality estimation Calculates quality indicator in range [0,1]. More...

void	setMagneticFieldStrength (double magneticFieldZ=1.5)
	Setter for z component of magnetic field. More...

virtual QualityEstimationResults	estimateQualityAndProperties (std::vector< SpacePoint const * > const &measurements)
	Quality estimation providing additional quantities Calculates quality indicator in range [0,1] Optionally returns chi2 and additional informations. More...

Protected Member Functions
double	calcPt (double const radius) const
	Returns a value for the transverse momentum in GeV calculated from a provided radius. More...

Protected Attributes
double	m_magneticFieldZ = 1.5
	Member storing the z component of the magnetic field.

QualityEstimationResults	m_results
	Result of the quality estimation This is stored as a member variable, because some values may be calculated by 'estimateQuality' anyways. More...

Detailed Description

Class containing the algorithm to perform the simple circle fit.

Definition at line 29 of file QualityEstimatorCircleFit.h.

Member Function Documentation

◆ calcPt()

double calcPt ( double const radius ) const

inlineprotectedinherited

Returns a value for the transverse momentum in GeV calculated from a provided radius.

Utilizing m_magneticFieldZ and hard coded speed of light

Definition at line 91 of file QualityEstimatorBase.h.

◆ estimateQuality()

double estimateQuality ( std::vector< SpacePoint const * > const & measurements )

finalvirtual

Minimal implementation of the quality estimation Calculates quality indicator in range [0,1].

measurements - std::vector<SpacePoint const*> ordered from innermost to outermost measurement

WARNING hardcoded values!

Implements QualityEstimatorBase.

Definition at line 21 of file QualityEstimatorCircleFit.cc.

 {
   if (measurements.size() < 4) {
     if (measurements.size() == 3) return 0.2; // Arbitrary value to prevent excluding measurements with 3 hits later on.
     else return 0;
   }
   // Calculates Curvature: True means clockwise, False means counterclockwise.
   // TODO this is not an optimized approach; just to get things to work.
   // CalcCurvature could be integrated into the looping over the hits which CircleFit does anyhow.
   m_results.curvatureSign = calcCurvatureSignum(measurements);
   bool clockwise = *(m_results.curvatureSign) >= 0;
  
   double stopper = 0.000000001; 
   double meanX = 0, meanY = 0, meanX2 = 0, meanY2 = 0, meanR2 = 0, meanR4 = 0, meanXR2 = 0, meanYR2 = 0, meanXY = 0; //mean values
   double sumWeights = 0, divisor/*, weightNormalizer = 0*/; // sumWeights is sum of weights, divisor is 1/sumWeights;
   double tuningParameter = 1.; //0.02; // this parameter is for internal tuning of the weights, 1 means no influence of parameter.
  
   // looping over all hits and do the division afterwards
   for (const SpacePoint* hit : measurements) {
     double weight = 1. / (sqrt(hit->getPositionError().X() * hit->getPositionError().X() + hit->getPositionError().Y() *
                                hit->getPositionError().Y()) * tuningParameter);
     sumWeights += weight;
     if (std::isnan(weight) or std::isinf(weight)) {
       B2ERROR("QualityEstimators::circleFit, chosen sigma is 'nan': " << weight << ", setting arbitrary error: "
               << stopper << ")"); weight = stopper;
     }
     double x = hit->getPosition().X();
     double y = hit->getPosition().Y();
     double x2 = x * x;
     double y2 = y * y;
     double r2 = x2 + y2;
     meanX += x * weight;
     meanY += y * weight;
     meanXY += x * y * weight;
     meanX2 += x2 * weight;
     meanY2 += y2 * weight;
     meanXR2 += x * r2 * weight;
     meanYR2 += y * r2 * weight;
     meanR2 += r2 * weight;
     meanR4 += r2 * r2 * weight;
   }
   divisor = 1. / sumWeights;
   meanX *= divisor;
   meanY *= divisor;
   meanXY *= divisor;
   meanY2 *= divisor;
   meanX2 *= divisor;
   meanXR2 *= divisor;
   meanYR2 *= divisor;
   meanR2 *= divisor;
   meanR4 *= divisor;
  
   // covariances:
   double covXX = meanX2 - meanX * meanX;
   double covXY = meanXY - meanX * meanY;
   double covYY = meanY2 - meanY * meanY;
   double covXR2 = meanXR2 - meanX * meanR2;
   double covYR2 = meanYR2 - meanY * meanR2;
   double covR2R2 = meanR4 - meanR2 * meanR2;
  
   if (covR2R2 == 0) {
     return 0; // TODO could be problematic if it is pretty near to 0
   }
  
   // q1, q2: helping variables, to make the code more readable
   double q1 = covR2R2 * covXY - covXR2 * covYR2;
   double q2 = covR2R2 * (covXX - covYY) - covXR2 * covXR2 + covYR2 * covYR2;
  
   // physical meaning: phi value of the point of closest approach of the fitted circle to the origin
   double pocaPhi = 0.5 * atan2(2. * q1, q2);
  
   double sinPhi = sin(pocaPhi);
   double cosPhi = cos(pocaPhi);
   double kappa = (sinPhi * covXR2 - cosPhi * covYR2) / covR2R2;
   double delta = -kappa * meanR2 + sinPhi * meanX - cosPhi * meanY;
   double rootTerm = sqrt(1. - 4.*delta * kappa);
   // rho = curvature in X-Y-plane = 1/radius of fitting circle, used for pT-calculation
   double curvature = 2.*kappa / (rootTerm);
   double pocaD = 2.*delta / (1. + rootTerm);
  
   // Checks if the random Curvature of CircleFit corresponds to CalcCurvature and adjust the results accordingly.
   if ((curvature < 0 && clockwise) || (curvature > 0 && !clockwise)) {
     // this is according to eq. 23 in the paper of Karimäki
     curvature = -curvature;
     pocaD = -pocaD;
     //TODO ..and swap correlation Terms V_rho_phi and V_rho_d (which are not implemented anyway)
   }
   double radius = 1. / curvature;
   double absRadius = fabs(radius);
  
   m_results.pt = calcPt(absRadius);
  
   double chi2 = sumWeights * (1. + curvature * pocaD) * (1. + curvature * pocaD)
                 * (sinPhi * sinPhi * covXX - 2.*sinPhi * cosPhi * covXY + cosPhi * cosPhi * covYY - kappa * kappa * covR2R2);
  
   m_results.chiSquared = chi2;
  
   return TMath::Prob(chi2, measurements.size() - 3);
 }

◆ estimateQualityAndProperties()

virtual QualityEstimationResults estimateQualityAndProperties ( std::vector< SpacePoint const * > const & measurements )

inlinevirtualinherited

Quality estimation providing additional quantities Calculates quality indicator in range [0,1] Optionally returns chi2 and additional informations.

Eg. momentum estimation.

measurements - std::vector<SpacePoint const*> ordered from innermost to outermost measurement

Reimplemented in QualityEstimatorMC, and QualityEstimatorTripletFit.

Definition at line 79 of file QualityEstimatorBase.h.

◆ setMagneticFieldStrength()

void setMagneticFieldStrength ( double magneticFieldZ = 1.5 )

inlineinherited

Setter for z component of magnetic field.

Parameters

magneticFieldZ : value to set it to

Definition at line 64 of file QualityEstimatorBase.h.

Member Data Documentation

◆ m_results

QualityEstimationResults m_results

protectedinherited

Result of the quality estimation This is stored as a member variable, because some values may be calculated by 'estimateQuality' anyways.

Therefore they don't need to be calculated explicitly in 'estimateQualityAndProperties'.

Definition at line 101 of file QualityEstimatorBase.h.

The documentation for this class was generated from the following files:

tracking/trackFindingVXD/trackQualityEstimators/include/QualityEstimatorCircleFit.h
tracking/trackFindingVXD/trackQualityEstimators/src/QualityEstimatorCircleFit.cc

Public Member Functions

Protected Member Functions

Protected Attributes