#include <FastCircle.h>

Public Member Functions
double	c () const

	FastCircle (const GlobalPoint &outerHit, const GlobalPoint &middleHit, const GlobalPoint &aVertex)

	FastCircle (const GlobalPoint &outerHit, const GlobalPoint &middleHit, const GlobalPoint &aVertex, double norm)

GlobalPoint const &	innerPoint () const

bool	isLine () const

bool	isValid () const

double	n1 () const

double	n2 () const

GlobalPoint const &	outerPoint () const

double	rho () const

GlobalPoint const &	vertexPoint () const

double	x0 () const

double	y0 () const

	~FastCircle ()

Private Member Functions
void	createCircleParameters ()

Private Attributes
double	theC

GlobalPoint	theInnerPoint

bool	theIsLine

double	theN1

double	theN2

double	theNorm

GlobalPoint	theOuterPoint

double	theRho

bool	theValid

GlobalPoint	theVertexPoint

double	theX0

double	theY0

Detailed Description

Calculate circle parameters (x0, y0, rho) for a circle: (x-x0)^2 + (y-y0)^2 = rho^2 in Global Cartesian Coordinates in the (x,y) plane for a given set of GlobalPoints. It is done by mapping the points onto the Riemann Sphere and fit a plane to the transformed coordinates of the points. The method is described in:

A.Strandlie, J.Wroldsen, R.Fruehwirth, B.Lillekjendlie: Particle tracks fitted on the Riemann sphere Computer Physics Communications 131 (2000) 95-108, 18 January 2000

Implementation: Matthias Winkler, 14 February 2001

This implementation is a specialized version of the general Circle class for three points.

Update 14.02.2001: For 3 Points (2 RecHits + Vertex) the plain parameters n1*x + n2*y + n3*z + c = 0 are analytically calculable. Update 14.02.2001: In the case that a circle fit is not possible (points are along a straight line) the parameters of the straight line can be used: c + n1*x + n2*y = 0

Definition at line 33 of file FastCircle.h.

Constructor & Destructor Documentation

◆ FastCircle() [1/2]

FastCircle::FastCircle	(	const GlobalPoint &	outerHit,
		const GlobalPoint &	middleHit,
		const GlobalPoint &	aVertex
	)

Definition at line 4 of file FastCircle.cc.

     : theOuterPoint(outerHit),
       theInnerPoint(middleHit),
       theVertexPoint(aVertex),
       theNorm(128.),
       theX0(0.),
       theY0(0.),
       theRho(0.),
       theN1(0.),
       theN2(0.),
       theC(0.),
       theValid(true),
       theIsLine(false) {
   createCircleParameters();
 }

References createCircleParameters().

◆ FastCircle() [2/2]

FastCircle::FastCircle	(	const GlobalPoint &	outerHit,
		const GlobalPoint &	middleHit,
		const GlobalPoint &	aVertex,
		double	norm
	)

Definition at line 20 of file FastCircle.cc.

     : theOuterPoint(outerHit),
       theInnerPoint(middleHit),
       theVertexPoint(aVertex),
       theNorm(norm),
       theX0(0.),
       theY0(0.),
       theRho(0.),
       theN1(0.),
       theN2(0.),
       theC(0.),
       theValid(true),
       theIsLine(false) {
   createCircleParameters();
 }

References createCircleParameters().

◆ ~FastCircle()

FastCircle::~FastCircle ( )

inline

Definition at line 39 of file FastCircle.h.

39 {}

Member Function Documentation

◆ c()

double FastCircle::c ( ) const

inline

Definition at line 59 of file FastCircle.h.

59 { return theC; }

References theC.

Referenced by createCircleParameters().

◆ createCircleParameters()

void FastCircle::createCircleParameters ( )

private

Definition at line 55 of file FastCircle.cc.

                                         {
   AlgebraicVector3 x = transform(theOuterPoint, theNorm);
   AlgebraicVector3 y = transform(theInnerPoint, theNorm);
   AlgebraicVector3 z = transform(theVertexPoint, theNorm);
  
   AlgebraicVector3 n;
  
   n[0] = x[1] * (y[2] - z[2]) + y[1] * (z[2] - x[2]) + z[1] * (x[2] - y[2]);
   n[1] = -(x[0] * (y[2] - z[2]) + y[0] * (z[2] - x[2]) + z[0] * (x[2] - y[2]));
   n[2] = x[0] * (y[1] - z[1]) + y[0] * (z[1] - x[1]) + z[0] * (x[1] - y[1]);
  
   double mag2 = n[0] * n[0] + n[1] * n[1] + n[2] * n[2];
   if (mag2 < 1.e-20) {
     theValid = false;
     return;
   }
   n.Unit();  // reduce n to a unit vector
   double c = -(n[0] * x[0] + n[1] * x[1] + n[2] * x[2]);
   //  c = -(n[0]*y[0] + n[1]*y[1] + n[2]*y[2]);
   //  c = -(n[0]*z[0] + n[1]*z[1] + n[2]*z[2]);
  
   theN1 = n[0];
   theN2 = n[1];
   theC = c;
  
   if (fabs(c + n[2]) < 1.e-5) {
     // numeric limit
     // circle is more a straight line...
     theValid = false;
     theIsLine = true;
     return;
   }
  
   double x0 = -n[0] / (2. * (c + n[2]));
   double y0 = -n[1] / (2. * (c + n[2]));
   double rho = sqrt((n[0] * n[0] + n[1] * n[1] - 4. * c * (c + n[2]))) / fabs(2. * (c + n[2]));
  
   theX0 = theNorm * x0;
   theY0 = theNorm * y0;
   theRho = theNorm * rho;
 }