#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	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 () dso_hidden
Private Attributes
double	theC
GlobalPoint	theInnerPoint
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::FastCircle	(	const GlobalPoint &	outerHit,
		const GlobalPoint &	middleHit,
		const GlobalPoint &	aVertex
	)

Definition at line 4 of file FastCircle.cc.

References createCircleParameters().

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

  createCircleParameters();
  
}

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

Definition at line 23 of file FastCircle.cc.

References createCircleParameters().

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

  createCircleParameters();
  
}

FastCircle::~FastCircle ( ) [inline]

Definition at line 46 of file FastCircle.h.

{}

Member Function Documentation

double FastCircle::c ( ) const [inline]

Definition at line 64 of file FastCircle.h.

References theC.

Referenced by createCircleParameters().

{return theC;}

void FastCircle::createCircleParameters ( ) [private]

Definition at line 62 of file FastCircle.cc.

References c(), alignCSCRings::e, mag2(), n, rho(), mathSSE::sqrt(), theC, theInnerPoint, theN1, theN2, theNorm, theOuterPoint, theRho, theValid, theVertexPoint, theX0, theY0, create_public_pileup_plots::transform, x, x0(), detailsBasic3DVector::y, y0(), and z.

Referenced by FastCircle().

                                        {
  
  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;
    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;

}