Linear fit of bright point (position and time) between hits (objects with position and time). More...

#include <JPoint4DEstimator.hh>

Inheritance diagram for JFIT::JEstimator< JPoint4D >:

Public Types
typedef double JPoint4D::*	parameter_type

Public Member Functions
	JEstimator ()
	Fit constructor.

template<class T >
	JEstimator (T __begin, T __end)
	Fit constructor.

template<class T >
void	operator() (T __begin, T __end)
	Fit function.

Static Public Member Functions
static parameter_type	pX ()

static parameter_type	pY ()

static parameter_type	pZ ()

static parameter_type	pT ()

Public Attributes
JMATH::JMatrix4S	V
	co-variance matrix of fit parameters

Static Public Attributes
static const int	NUMBER_OF_PARAMETERS = 4
	number of parameters of fit

Detailed Description

Linear fit of bright point (position and time) between hits (objects with position and time).

$\begin{center}\setlength{\unitlength}{0.6cm}\begin{picture}(12,7) \put( 6.0, 1.0){\circle*{0.3}} \put( 6.0, 0.0){\makebox(0,0)[b]{$(x_{0},y_{0},z_{0})$}} \multiput(6.0, 1.0)(-0.5, 0.5){10}{\qbezier(0.0,0.0)(+0.1,0.35)(-0.25,0.25)\qbezier(-0.25,0.25)(-0.6,0.15)(-0.5,0.5)} \put( 1.0, 6.0){\circle*{0.2}} \put( 1.0, 6.5){\makebox(0,0)[b]{$(x_i,y_i,z_i,t_i)$}} \multiput(6.0, 1.0)( 0.5, 0.5){10}{\qbezier(0.0,0.0)(0.35,-0.1)( 0.25,0.25)\qbezier( 0.25,0.25)(0.15, 0.6)( 0.5,0.5)} \put(11.0, 6.0){\circle*{0.2}} \put(11.0, 6.5){\makebox(0,0)[b]{$(x_j,y_j,z_j,t_j)$}} \end{picture} \end{center}$

$t_j = t_0 + \frac{c}{n} \times \sqrt((x_j - x_0)^2 + (y_j - y_0)^2 + (z_j - z_0)^2)$

where:

$\begin{eqnarray*} x_0 & = & \textrm{x position of vertex (fit parameter)} \\ y_0 & = & \textrm{y position of vertex (fit parameter)} \\ z_0 & = & \textrm{z position of vertex (fit parameter)} \\ t_0 & = & \textrm{time at vertex (fit parameter)} \\ \\ c & = & \textrm{speed of light (in vacuum)} \\ n & = & \textrm{index of refraction corresponding to the group velocity of light} \\ \end{eqnarray*}$

Defining:

$\begin{eqnarray*} t_j' & \equiv & nct_j \\ t_0' & \equiv & nct_0 \\ \end{eqnarray*}$

$\Rightarrow (t_j' - t_0')^2 = (x_j - x_0)^2 + (y_j - y_0)^2 + (z_j - z_0)^2$

The parameters $\{x_0, y_0, z_0, t_0\}$ are estimated in the constructor of this class based on consecutive pairs of equations by which the quadratic terms in , , and are eliminated.

Definition at line 69 of file JPoint4DEstimator.hh.

Member Typedef Documentation

◆ parameter_type

typedef double JPoint4D::* JFIT::JPoint4D::parameter_type

inherited

Definition at line 56 of file JPoint4D.hh.

Constructor & Destructor Documentation

◆ JEstimator() [1/2]

JFIT::JEstimator< JPoint4D >::JEstimator ( )

inline

Fit constructor.

Definition at line 77 of file JPoint4DEstimator.hh.

                 :
      JPoint4D()
    {}

◆ JEstimator() [2/2]

template<class T >

JFIT::JEstimator< JPoint4D >::JEstimator	(	T	__begin,
		T	__end )

inline

Fit constructor.

The template argument T refers to an iterator of a data structure which should have the following member methods:

double getX(); // [m]
double getY(); // [m]
double getZ(); // [m]
double getT(); // [ns]

Parameters

__begin	begin of data
__end	end of data

Definition at line 95 of file JPoint4DEstimator.hh.

                                   :
      JPoint4D()
    {
      (*this)(__begin, __end);
    }

Member Function Documentation

◆ operator()()

template<class T >

void JFIT::JEstimator< JPoint4D >::operator()	(	T	__begin,
		T	__end )

inline

Fit function.

This method is used to find the vertex of a given set of hits

Parameters

__begin	begin of data
__end	end of data

Definition at line 110 of file JPoint4DEstimator.hh.

    {
      using namespace std;
      using namespace JPP;
      
      const int N = distance(__begin, __end);
      
      if (N >= NUMBER_OF_PARAMETERS) {
        
        double t0 = 0.0;
        
        __x = 0.0;
        __y = 0.0;
        __z = 0.0;
        
        for (T i = __begin; i != __end; ++i) {
          __x += i->getX();
          __y += i->getY();
          __z += i->getZ();
          t0  += i->getT();
        }
        
        div(N);
        t0 /= N;
 
        V.reset();
 
        t0 *= getSpeedOfLight();
 
        double y0 = 0.0;
        double y1 = 0.0;
        double y2 = 0.0;
        double y3 = 0.0;
 
        T j = __begin;
 
        double xi =  j->getX() - getX();
        double yi =  j->getY() - getY();
        double zi =  j->getZ() - getZ();
        double ti = (j->getT() * getSpeedOfLight()  -  t0) / getIndexOfRefraction();
 
        for (bool done = false; !done; ) {
 
          if ((done = (++j == __end))) {
            j = __begin;
          }
 
          double xj =  j->getX() - getX();
          double yj =  j->getY() - getY();
          double zj =  j->getZ() - getZ();
          double tj = (j->getT() * getSpeedOfLight()  -  t0) / getIndexOfRefraction();
            
          double dx = xj - xi;
          double dy = yj - yi;
          double dz = zj - zi;
          double dt = ti - tj;    // opposite sign!
            
          const double y  = ((xj + xi) * dx +
                             (yj + yi) * dy +
                             (zj + zi) * dz +
                             (tj + ti) * dt);
 
          dx *= 2;
          dy *= 2;
          dz *= 2;
          dt *= 2;
            
          V.a00 += dx * dx;
          V.a01 += dx * dy;
          V.a02 += dx * dz;
          V.a03 += dx * dt;
          V.a11 += dy * dy;
          V.a12 += dy * dz;
          V.a13 += dy * dt;
          V.a22 += dz * dz;
          V.a23 += dz * dt;
          V.a33 += dt * dt;
 
          y0 += dx * y;
          y1 += dy * y;
          y2 += dz * y;
          y3 += dt * y;
 
          xi = xj;
          yi = yj;
          zi = zj;
          ti = tj;
        }
 
        t0 *= getInverseSpeedOfLight();
 
        V.a10 = V.a01;
        V.a20 = V.a02;
        V.a30 = V.a03;
        V.a21 = V.a12;
        V.a31 = V.a13;
        V.a32 = V.a23;
 
        V.invert();
 
        __x += V.a00 * y0  +  V.a01 * y1  +  V.a02 * y2  +  V.a03 * y3;
        __y += V.a10 * y0  +  V.a11 * y1  +  V.a12 * y2  +  V.a13 * y3;
        __z += V.a20 * y0  +  V.a21 * y1  +  V.a22 * y2  +  V.a23 * y3;
        __t  = V.a30 * y0  +  V.a31 * y1  +  V.a32 * y2  +  V.a33 * y3;
        
        __t *= getInverseSpeedOfLight() * getIndexOfRefraction();
        __t += t0;
 
      } else {
        throw JValueOutOfRange("JEstimator<JPoint4D>::operator(): Not enough data points.");
      }
    }

◆ pX()

static parameter_type JFIT::JPoint4D::pX ( )

inlinestaticinherited

Definition at line 58 of file JPoint4D.hh.

58{ return &JPoint4D::__x; }

◆ pY()

static parameter_type JFIT::JPoint4D::pY ( )

inlinestaticinherited

Definition at line 59 of file JPoint4D.hh.

59{ return &JPoint4D::__y; }

◆ pZ()

static parameter_type JFIT::JPoint4D::pZ ( )

inlinestaticinherited

Definition at line 60 of file JPoint4D.hh.

60{ return &JPoint4D::__z; }

◆ pT()

static parameter_type JFIT::JPoint4D::pT ( )

inlinestaticinherited

Definition at line 61 of file JPoint4D.hh.

61{ return &JPoint4D::__t; }

Member Data Documentation

◆ NUMBER_OF_PARAMETERS

const int JFIT::JEstimator< JPoint4D >::NUMBER_OF_PARAMETERS = 4

static

number of parameters of fit

Definition at line 223 of file JPoint4DEstimator.hh.

◆ V

JMATH::JMatrix4S JFIT::JEstimator< JPoint4D >::V

co-variance matrix of fit parameters

Definition at line 224 of file JPoint4DEstimator.hh.

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

JPoint4DEstimator.hh

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Detailed Description

Member Typedef Documentation

◆ parameter_type

Constructor & Destructor Documentation

◆ JEstimator() [1/2]

◆ JEstimator() [2/2]

Member Function Documentation

◆ operator()()

◆ pX()

◆ pY()

◆ pZ()

◆ pT()

Member Data Documentation

◆ NUMBER_OF_PARAMETERS

◆ V