KLMTrackFitter Class Reference

track fitting procedure More...

#include <KLMTrackFitter.h>

Public Member Functions
	KLMTrackFitter ()
	Default constructor.
	~KLMTrackFitter ()
	Destructor.
double	fit (std::list< KLMHit2d * > &listTrackPoint)
	do fit and returns chi square of the fit.
double	globalDistanceToHit (KLMHit2d *hit, double &error, double &sigma)
	Distance from track to a hit in the global system.
double	fit1dTrack (std::list< KLMHit2d * > hitList, CLHEP::HepVector &eta, CLHEP::HepSymMatrix &error, int depDir, int indDir)
	do fit in the global system
CLHEP::HepVector	getTrackParam ()
	Get track parameters in the global system. y = p0 + p1 * x; z = p2 + p3 * x.
CLHEP::HepSymMatrix	getTrackParamErr ()
	Get invariance matrix of track parameters in the global system.
bool	isValid ()
	Is fit valid.
bool	isGood ()
	Is fit good.
float	getChi2 ()
	Chi square of the fit.
int	getNumHit ()
	number of the hits on this track
void	inValidate ()
	Invalidate track.

Private Attributes
bool	m_Valid
	Is fit valid.
bool	m_Good
	Is fit good.
float	m_Chi2
	Chi square of fit.
int	m_NumHit
	the number of hits on this track
CLHEP::HepVector	m_GlobalPar
	track params in global system
CLHEP::HepSymMatrix	m_GlobalErr
	track params errors in global system
Belle2::KLM::KLMGeometryPar *	m_GeoPar
	pointer to GeometryPar singleton

Detailed Description

track fitting procedure

Definition at line 30 of file KLMTrackFitter.h.

Constructor & Destructor Documentation

KLMTrackFitter()

KLMTrackFitter

(

)

Default constructor.

Constructor.

Definition at line 43 of file KLMTrackFitter.cc.

                              :
// Description: "For the use of standalone KLM tracking, this module is the fitter component.";
  m_Valid(false),
  m_Good(false),
  m_Chi2(0.0),
  m_NumHit(0),
  m_GlobalPar(4, 0),
  m_GlobalErr(4, 0),
  m_GeoPar(nullptr)
{
}

~KLMTrackFitter()

~KLMTrackFitter

(

)

Destructor.

Definition at line 56 of file KLMTrackFitter.cc.

{
}

Member Function Documentation

fit()

double fit

(

std::list< KLMHit2d * > &

listTrackPoint

)

do fit and returns chi square of the fit.

Definition at line 60 of file KLMTrackFitter.cc.

{
 
  // We can only do fit if there are at least two hits
  if (listHitSector.size() < 2) {
    m_Valid = false;
    m_Good  = false;
    return (false);
  }
 
  HepVector     eta(2, 0);             //  ( a, b ) in y = a + bx, used as inbetween
  HepSymMatrix  error(2, 0);
  HepVector     gloEta(2, 0);          //  ( a, b ) in y = a + bx in global system
  HepSymMatrix  gloError(2, 0);
  m_Chi2 = 0;
 
  // Create temporary vector and matrix... so size can be set.
  HepVector     globalPar(4, 0);
  HepSymMatrix  globalErr(4, 0);
 
  m_Chi2  = fit1dTrack(listHitSector, eta, error, VY, VX);
  globalPar.sub(1, eta);
  globalErr.sub(1, error);
 
  //m_Chi2  += fit1dTrack(listHitSector, eta, error, VY, VZ);
  m_Chi2  += fit1dTrack(listHitSector, eta, error, VZ, VX);
  globalPar.sub(3, eta);
  globalErr.sub(3, error);
 
 
  m_Chi2 /= 2.0;
 
  m_GlobalPar = globalPar;
  m_GlobalErr = globalErr;
 
  m_Valid = true;
  m_Good  = false;
  m_NumHit =  listHitSector.size();
  if (m_Chi2 <= 20.0) {
    m_Good = true;
  }
 
  return (m_Chi2);
 
}

fit1dTrack()

double fit1dTrack	(	std::list< KLMHit2d * >	hitList,
		CLHEP::HepVector &	eta,
		CLHEP::HepSymMatrix &	error,
		int	depDir,
		int	indDir )

do fit in the global system

do fit in global system, handle tracks that go thrugh multi-sectors

Definition at line 254 of file KLMTrackFitter.cc.

{
// Fit d = a + bi, where d is dependent direction and i is independent
// in global system we assume y = a + b*x and z = c + dx  different from local fit
// Check KLMTrackFitter::fit to see what modes are being used
  HepMatrix globalHitErr(3, 3, 0);
 
  double     indPos = 0;
  double     depPos = 0;
 
  // Matrix based solution
  int noPoints = hitList.size();
 
  // Derivative of y = a + bx, with respect to a and b evaluated at x.
  HepMatrix  A(noPoints, 2, 0);
 
  // Measured data points.
  HepVector  y(noPoints, 0);
 
  // Inverse of covariance (error) matrix, also known as the weight matrix.
  // In plain English: V_y_inverse_nn = 1 / (error of nth measurement)^2
  HepDiagMatrix V_y_inverse(noPoints, 0);
 
  // Error or correlation matrix for coefficients (2x2 matrices)
  HepSymMatrix  V_A, V_A_inverse;
 
 
  int n = 0;
  for (std::list< KLMHit2d* >::iterator iHit = hitList.begin(); iHit != hitList.end(); ++iHit) {
 
    KLMHit2d* hit = *iHit;
 
    CLHEP::Hep3Vector globalPos(hit->getPositionX(),  hit->getPositionY(),  hit->getPositionZ());
 
 
    if (hit->getSubdetector() == KLMElementNumbers::c_BKLM) {
      const bklm::GeometryPar* bklmGeo = m_GeoPar->BarrelInstance();
      const bklm::Module* corMod = bklmGeo->findModule(hit->getSection(), hit->getSector(), hit->getLayer());
 
      double hit_localPhiErr = corMod->getPhiStripWidth() / sqrt(12);
      double hit_localZErr = corMod->getZStripWidth() / sqrt(12);
 
      if (hit->inRPC()) {
        //+++ scale localErr based on measured-in-Belle resolution
        int nStrips = hit->getPhiStripMax() - hit->getPhiStripMin() + 1;
        double dn = nStrips - 1.5;
        double factor = std::pow((0.9 + 0.4 * dn * dn), 1.5) * 0.60;//measured-in-Belle resolution
        hit_localPhiErr = hit_localPhiErr * sqrt(factor);
 
        nStrips = hit->getZStripMax() - hit->getZStripMin() + 1;
        dn = nStrips - 1.5;
        factor = std::pow((0.9 + 0.4 * dn * dn), 1.5) * 0.55;//measured-in-Belle resolution
        hit_localZErr = hit_localZErr * sqrt(factor);
      }
 
      Hep3Vector globalOrigin = corMod->getGlobalOrigin();
      double sinphi = globalOrigin[1] / globalOrigin.mag();
      double cosphi = globalOrigin[0] / globalOrigin.mag();
 
      globalHitErr[0][0] = square(hit_localPhiErr * sinphi); // x
      globalHitErr[0][1] = (hit_localPhiErr * sinphi) * (hit_localPhiErr * cosphi);
      globalHitErr[0][2] = 0.;
      globalHitErr[1][1] = square(hit_localPhiErr * cosphi); // y
      globalHitErr[1][0] = (hit_localPhiErr * sinphi) * (hit_localPhiErr * cosphi);
      globalHitErr[1][2] = 0.;
      globalHitErr[2][2] = square(hit_localZErr); // z
      globalHitErr[2][0] = 0.;
      globalHitErr[2][1] = 0.;
 
      switch (indDir) {
 
        case VX:
          indPos = globalPos.x();
          break;
 
        case VY:
          indPos = globalPos.y();
          break;
 
        case VZ:
          indPos = globalPos.z();
          break;
 
        default:
          B2DEBUG(20, "error in bklm in-TrackFit: illegal direction");
 
      }
 
      switch (depDir) {
 
        case VX:
          depPos = globalPos.x();
          break;
 
        case VY:
          depPos = globalPos.y();
          break;
 
        case VZ:
          depPos = globalPos.z();
          break;
 
        default:
          B2DEBUG(20, "error in bklm dep-TrackFit: illegal direction");
 
      }
    } //end of BKLM section
 
    else if (hit->getSubdetector() == KLMElementNumbers::c_EKLM) {
      const EKLM::GeometryData* eklmGeo = m_GeoPar->EndcapInstance();
 
      //here get the resolustion of a hit, repeated several times, ugly. should we store this in KLMHit2d object ?
      double hit_xErr = (eklmGeo->getStripGeometry()->getWidth()) * (Unit::cm / CLHEP::cm) *
                        (hit->getXStripMax() - hit->getXStripMin() + 1) / sqrt(12);
      double hit_yErr = (eklmGeo->getStripGeometry()->getWidth()) * (Unit::cm / CLHEP::cm) *
                        (hit->getYStripMax() - hit->getYStripMin() + 1) / sqrt(12);
      double hit_zErr = 0; //KLMHit2d is always centred on the boundary between the x/y planes with ~0 uncertainty
 
      B2DEBUG(28, "KLMTrackFitter" << " Width: " << eklmGeo->getStripGeometry()->getWidth() << " Vec_x: " << hit_xErr * sqrt(
                12) << " Vec_y: " << hit_yErr * sqrt(12));
 
      globalHitErr[0][0] = square(hit_xErr); //x
      globalHitErr[0][1] = 0.;
      globalHitErr[0][2] = 0.;
      globalHitErr[1][1] = square(hit_yErr); //y
      globalHitErr[1][0] = 0.;
      globalHitErr[1][2] = 0.;
      globalHitErr[2][2] = square(hit_zErr); //z
      globalHitErr[2][0] = 0.;
      globalHitErr[2][1] = 0.;
 
 
 
      switch (indDir) {
 
        case VX:
          indPos = globalPos.x();
          break;
 
        case VY:
          indPos = globalPos.y();
          break;
 
        case VZ:
          indPos = globalPos.z();
          break;
 
        default:
          B2DEBUG(20, "error in EKLM in-TrackFit: illegal direction");
 
      }
 
      switch (depDir) {
 
        case VX:
          depPos = globalPos.x();
          break;
 
        case VY:
          depPos = globalPos.y();
          break;
 
        case VZ:
          depPos = globalPos.z();
          break;
 
        default:
          B2DEBUG(20, "error in EKLM dep-TrackFit: illegal direction");
 
      }
    } //end of EKLM section
 
    A[ n ][ 0 ] = 1;
    A[ n ][ 1 ] = indPos;
 
    y[ n ] = depPos;
 
    double error_raw = globalHitErr[indDir][indDir] + globalHitErr[depDir][depDir];
    double weight = error_raw;
    if (weight > 0) {
      V_y_inverse[ n ][ n ] = 1.0 / weight;
    } else {
      V_y_inverse[ n ][ n ] = DBL_MAX;
    }
    ++n;//n is the index of measured points/hits
  } // end of loop
 
 
  V_A_inverse = V_y_inverse.similarityT(A);
 
  int ierr = 0;
  V_A = V_A_inverse.inverse(ierr);
 
  eta   = V_A * A.T() * V_y_inverse * y;
  error = V_A;
 
// Calculate residuals:
  HepMatrix residual = y - A * eta;
  HepMatrix chisqr = residual.T() * V_y_inverse * residual;
 
  return (chisqr.trace());
 
}

getChi2()

float getChi2 ( )

inline

Chi square of the fit.

Definition at line 82 of file KLMTrackFitter.h.

    {
      return m_Chi2;
    }

getNumHit()

int getNumHit ( )

inline

number of the hits on this track

Definition at line 88 of file KLMTrackFitter.h.

    {
      return m_NumHit;
    }

getTrackParam()

CLHEP::HepVector getTrackParam ( )

inline

Get track parameters in the global system. y = p0 + p1 * x; z = p2 + p3 * x.

Definition at line 57 of file KLMTrackFitter.h.

    {
      return m_GlobalPar;
    }

getTrackParamErr()

CLHEP::HepSymMatrix getTrackParamErr ( )

inline

Get invariance matrix of track parameters in the global system.

Definition at line 63 of file KLMTrackFitter.h.

    {
      return m_GlobalErr;
    }

globalDistanceToHit()

double globalDistanceToHit	(	KLMHit2d *	hit,
		double &	error,
		double &	sigma )

Distance from track to a hit in the global system.

Distance from track to a hit calculated in the global system.

Definition at line 109 of file KLMTrackFitter.cc.

{
 
  if (!m_Valid) {
    error = DBL_MAX;
    sigma = DBL_MAX;
    return DBL_MAX;
  }
 
  //in global fit, we have two functions y = a + b*x and y = c + d*z
  double x_mea = hit->getPositionX();
  double y_mea = hit->getPositionY();
  double z_mea = hit->getPositionZ();
 
  //there is some subdetector dependence so let's define this first.
  double x_pre, y_pre, z_pre, dx, dy, dz;
 
  // Error is composed of four parts: error due to tracking;
  // and error in hit, y(x)  or z(x).
  HepMatrix  errors(2, 2, 0);    // Matrix for errors
  HepMatrix  A(2, 4, 0);         // Matrix for derivatives
 
 
  //defining quanitites for hit errors
  double hit_xErr; double hit_yErr; double hit_zErr;
  HepMatrix globalHitErr(3, 3, 0);
 
  // Derivatives of y (z) = a + bx with respect to a and b.
  A[ MY ][ AY ] = 1. ;
  A[ MY ][ BY ] = x_mea;
  A[ MZ ][ AZ ] = 1;
  A[ MZ ][ BZ ] = x_mea;
 
 
  //error from trackPar is inclueded, error from y_mea is not included
  errors = A * m_GlobalErr * A.T();
 
  if (hit->getSubdetector() == KLMElementNumbers::c_BKLM) {
 
    // defining terms relating to distance
    x_pre = x_mea; //by definition
    y_pre = m_GlobalPar[ AY ] + m_GlobalPar[ BY ] * x_mea;
    z_pre =  m_GlobalPar[ AZ ] + m_GlobalPar[ BZ ] * x_mea;
 
    const bklm::GeometryPar* bklmGeo = m_GeoPar->BarrelInstance();
    //here get the resolustion of a hit, repeated several times, ugly. should we store this in KLMHit2d object ?
    const bklm::Module* corMod = bklmGeo->findModule(hit->getSection(), hit->getSector(), hit->getLayer());
    double hit_localPhiErr = corMod->getPhiStripWidth() / sqrt(12);
    double hit_localZErr = corMod->getZStripWidth() / sqrt(12);
 
    if (hit->inRPC()) {
      //+++ scale localErr based on measured-in-Belle resolution
      int nStrips = hit->getPhiStripMax() - hit->getPhiStripMin() + 1;
      double dn = nStrips - 1.5;
      double factor = std::pow((0.9 + 0.4 * dn * dn), 1.5) * 0.60;//measured-in-Belle resolution
      hit_localPhiErr = hit_localPhiErr * sqrt(factor);
 
      nStrips = hit->getZStripMax() - hit->getZStripMin() + 1;
      dn = nStrips - 1.5;
      factor = std::pow((0.9 + 0.4 * dn * dn), 1.5) * 0.55;//measured-in-Belle resolution
      hit_localZErr = hit_localZErr * sqrt(factor);
    }
 
    Hep3Vector globalOrigin = corMod->getGlobalOrigin();
    double sinphi = globalOrigin[1] / globalOrigin.mag();
    double cosphi = globalOrigin[0] / globalOrigin.mag();
 
    hit_xErr = hit_localPhiErr * sinphi;
    hit_yErr = hit_localPhiErr * cosphi;
    hit_zErr = hit_localZErr;
 
 
    globalHitErr[0][0] = square(hit_xErr); //x
    globalHitErr[0][1] = (hit_xErr) * (hit_yErr);
    globalHitErr[0][2] = 0;
    globalHitErr[1][1] = square(hit_yErr);;
    globalHitErr[1][0] = (hit_xErr) * (hit_yErr);
    globalHitErr[1][2] = 0;
    globalHitErr[2][2] = square(hit_zErr);
    globalHitErr[2][0] = 0;
    globalHitErr[2][1] = 0;
 
 
  } // end of BKLM portion
 
  else if (hit->getSubdetector() == KLMElementNumbers::c_EKLM) {
    // distance related (choose z variable)
    // z coordinate should correspond to where track passes through EKLM-plane
    z_pre = z_mea; //by design, due to EKLM geometry
    x_pre = (z_mea - m_GlobalPar[ AZ ]) / m_GlobalPar[ BZ ];
    y_pre =  m_GlobalPar[ AY ] +  m_GlobalPar[ BY ] * x_pre;
 
    const EKLM::GeometryData* eklmGeo = m_GeoPar->EndcapInstance();
 
    //EKLM GeometryData is needed for strip widths
    //here get the resolustion of a hit, repeated several times, ugly. should we store this in KLMHit2d object ?
    hit_xErr = (eklmGeo->getStripGeometry()->getWidth()) * (Unit::cm / CLHEP::cm) *
               (hit->getXStripMax() - hit->getXStripMin() + 1) / sqrt(12);
    hit_yErr = (eklmGeo->getStripGeometry()->getWidth()) * (Unit::cm / CLHEP::cm) *
               (hit->getYStripMax() - hit->getYStripMin() + 1) / sqrt(12);
    hit_zErr = 0.; //KLMHit2d is always centred on the boundary between the x/y planes with ~0 uncertainty
 
    globalHitErr[0][0] = square(hit_xErr); //x
    globalHitErr[0][1] = 0.;
    globalHitErr[0][2] = 0.;
    globalHitErr[1][1] = square(hit_yErr); //y
    globalHitErr[1][0] = 0.;
    globalHitErr[1][2] = 0.;
    globalHitErr[2][2] = square(hit_zErr);; //z
    globalHitErr[2][0] = 0.;
    globalHitErr[2][1] = 0.;
 
 
  } // end of EKLM section
 
  else
    B2FATAL("In KLMTrackFitter globalDistanceToHit, hit is neither from E/B-KLM.");
 
  dx = x_pre - x_mea;
  dy = y_pre - y_mea;
  dz = z_pre - z_mea;
  double distance = sqrt(dx * dx + dy * dy +  dz * dz);
 
  // now that we have globalHitErr, compute error
  error = sqrt(errors[ MY ][ MY ] +
               errors[ MZ ][ MZ ] +
               //errors_b[0] + errors_b[1] + //error of prediced point due to error of inPos (y_mea)
               globalHitErr[0][0] +
               globalHitErr[1][1] + //y_mea error is correlated to the error of predicted point, but we didn't consider that part in errors
               globalHitErr[2][2]); //we ignore y_mea error?
 
 
  if (error != 0.0) {
    sigma = distance / error;
  } else {
    sigma = DBL_MAX;
  }
 
  return (distance);
}

inValidate()

void inValidate ( )

inline

Invalidate track.

Definition at line 94 of file KLMTrackFitter.h.

    {
      m_Valid = false;
    }

isGood()

bool isGood ( )

inline

Is fit good.

Definition at line 76 of file KLMTrackFitter.h.

    {
      return m_Good;
    }

isValid()

bool isValid ( )

inline

Is fit valid.

Definition at line 70 of file KLMTrackFitter.h.

    {
      return m_Valid;
    }

Member Data Documentation

m_Chi2

float m_Chi2

private

Chi square of fit.

Definition at line 109 of file KLMTrackFitter.h.

m_GeoPar

Belle2::KLM::KLMGeometryPar* m_GeoPar

private

pointer to GeometryPar singleton

Definition at line 121 of file KLMTrackFitter.h.

m_GlobalErr

CLHEP::HepSymMatrix m_GlobalErr

private

track params errors in global system

Definition at line 118 of file KLMTrackFitter.h.

m_GlobalPar

CLHEP::HepVector m_GlobalPar

private

track params in global system

Definition at line 115 of file KLMTrackFitter.h.

m_Good

bool m_Good

private

Is fit good.

Definition at line 106 of file KLMTrackFitter.h.

m_NumHit

int m_NumHit

private

the number of hits on this track

Definition at line 112 of file KLMTrackFitter.h.

m_Valid

bool m_Valid

private

Is fit valid.

Definition at line 103 of file KLMTrackFitter.h.

---

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

• klm/modules/KLMTracking/include/KLMTrackFitter.h
• klm/modules/KLMTracking/src/KLMTrackFitter.cc