KFitBase Class Reference

KFitBase is a base class for kinematical fitters. More...

#include <KFitBase.h>

Inheritance diagram for KFitBase:

Public Member Functions
	KFitBase (void)
	Construct an object with no argument.
virtual	~KFitBase (void)
	Destruct the object.
enum KFitError::ECode	addTrack (const KFitTrack &kp)
	Add a track to the fitter object.
enum KFitError::ECode	addTrack (const CLHEP::HepLorentzVector &p, const HepPoint3D &x, const CLHEP::HepSymMatrix &e, const double q)
	Add a track to the fitter object with specifying its momentum, position, error matrix, and charge.
enum KFitError::ECode	addParticle (const Particle *particle)
	Add a particle to the fitter.
virtual enum KFitError::ECode	setCorrelation (const CLHEP::HepMatrix &c)
	Set a correlation matrix.
virtual enum KFitError::ECode	setZeroCorrelation (void)
	Indicate no correlation between tracks.
enum KFitError::ECode	setMagneticField (const double mf)
	Change a magnetic field from the default value KFitConst::kDefaultMagneticField.
enum KFitError::ECode	getErrorCode (void) const
	Get a code of the last error.
int	getTrackCount (void) const
	Get the number of added tracks.
virtual int	getNDF (void) const
	Get an NDF of the fit.
virtual double	getCHIsq (void) const
	Get a chi-square of the fit.
double	getMagneticField (void) const
	Get a magnetic field.
virtual double	getTrackCHIsq (const int id) const
	Get a chi-square of the track.
const CLHEP::HepLorentzVector	getTrackMomentum (const int id) const
	Get a Lorentz vector of the track.
const HepPoint3D	getTrackPosition (const int id) const
	Get a position of the track.
const CLHEP::HepSymMatrix	getTrackError (const int id) const
	Get an error matrix of the track.
const KFitTrack	getTrack (const int id) const
	Get a specified track object.
virtual const CLHEP::HepMatrix	getCorrelation (const int id1, const int id2, const int flag=KFitConst::kAfterFit) const
	Get a correlation matrix between two tracks.
bool	isFitted (void) const
	Return false if fit is not performed yet or performed fit is failed; otherwise true.

Protected Member Functions
const CLHEP::HepSymMatrix	makeError1 (const CLHEP::HepLorentzVector &p, const CLHEP::HepMatrix &e) const
	Rebuild an error matrix from a Lorentz vector and an error matrix.
const CLHEP::HepMatrix	makeError1 (const CLHEP::HepLorentzVector &p1, const CLHEP::HepLorentzVector &p2, const CLHEP::HepMatrix &e) const
	Rebuild an error matrix from a pair of Lorentz vectors and an error matrix.
const CLHEP::HepMatrix	makeError2 (const CLHEP::HepLorentzVector &p, const CLHEP::HepMatrix &e) const
	Rebuild an error matrix from a Lorentz vector and an error matrix.
const CLHEP::HepSymMatrix	makeError3 (const CLHEP::HepLorentzVector &p, const CLHEP::HepMatrix &e, const bool is_fix_mass) const
	Rebuild an error matrix from a Lorentz vector and an error matrix.
const CLHEP::HepMatrix	makeError3 (const CLHEP::HepLorentzVector &p1, const CLHEP::HepLorentzVector &p2, const CLHEP::HepMatrix &e, const bool is_fix_mass1, const bool is_fix_mass2) const
	Rebuild an error matrix from a pair of Lorentz vectors and an error matrix.
const CLHEP::HepMatrix	makeError4 (const CLHEP::HepLorentzVector &p, const CLHEP::HepMatrix &e) const
	Rebuild an error matrix from a Lorentz vector and an error matrix.
virtual enum KFitError::ECode	prepareInputMatrix (void)=0
	Build grand matrices for minimum search from input-track properties.
virtual enum KFitError::ECode	prepareInputSubMatrix (void)=0
	Build sub-matrices for minimum search from input-track properties.
virtual enum KFitError::ECode	prepareCorrelation (void)
	Build a grand correlation matrix from input-track properties.
virtual enum KFitError::ECode	prepareOutputMatrix (void)=0
	Build an output error matrix.
virtual enum KFitError::ECode	makeCoreMatrix (void)=0
	Build matrices using the kinematical constraint.
virtual enum KFitError::ECode	calculateNDF (void)=0
	Calculate an NDF of the fit.
enum KFitError::ECode	doFit1 (void)
	Perform a fit (used in MassFitKFit::doFit()).
enum KFitError::ECode	doFit2 (void)
	Perform a fit (used in VertexFitKFit::doFit() and MassVertexFitKFit::doFit()).
bool	isTrackIDInRange (const int id) const
	Check if the id is in the range.
bool	isNonZeroEnergy (const CLHEP::HepLorentzVector &p) const
	Check if the energy is non-zero.

Protected Attributes
enum KFitError::ECode	m_ErrorCode
	Error code.
bool	m_FlagFitted
	Flag to indicate if the fit is performed and succeeded.
std::vector< KFitTrack >	m_Tracks
	Container of input tracks.
std::vector< CLHEP::HepMatrix >	m_BeforeCorrelation
	Container of input correlation matrices.
CLHEP::HepSymMatrix	m_V_al_0
	See J.Tanaka Ph.D (2001) p137 for definition.
CLHEP::HepMatrix	m_al_0
	See J.Tanaka Ph.D (2001) p136 for definition.
CLHEP::HepMatrix	m_al_1
	See J.Tanaka Ph.D (2001) p136 for definition.
CLHEP::HepMatrix	m_al_a
	See J.Tanaka Ph.D (2001) p137 for definition.
CLHEP::HepMatrix	m_property
	Container of charges and masses.
CLHEP::HepMatrix	m_D
	See J.Tanaka Ph.D (2001) p137 for definition.
CLHEP::HepMatrix	m_d
	See J.Tanaka Ph.D (2001) p137 for definition.
CLHEP::HepMatrix	m_V_D
	See J.Tanaka Ph.D (2001) p138 for definition.
CLHEP::HepMatrix	m_V_al_1
	See J.Tanaka Ph.D (2001) p138 for definition.
CLHEP::HepMatrix	m_lam
	See J.Tanaka Ph.D (2001) p137 for definition.
CLHEP::HepMatrix	m_E
	See J.Tanaka Ph.D (2001) p137 for definition.
CLHEP::HepMatrix	m_V_E
	See J.Tanaka Ph.D (2001) p138 for definition.
CLHEP::HepMatrix	m_lam0
	See J.Tanaka Ph.D (2001) p138 for definition.
CLHEP::HepMatrix	m_v
	See J.Tanaka Ph.D (2001) p137 for definition.
CLHEP::HepMatrix	m_v_a
	See J.Tanaka Ph.D (2001) p137 for definition.
CLHEP::HepMatrix	m_V_Dt
	See J.Tanaka Ph.D (2001) p138 for definition.
CLHEP::HepMatrix	m_Cov_v_al_1
	See J.Tanaka Ph.D (2001) p137 for definition.
int	m_NDF
	NDF of the fit.
double	m_CHIsq
	chi-square of the fit.
int	m_TrackCount
	Number of tracks.
int	m_NecessaryTrackCount
	Number needed tracks to perform fit.
bool	m_FlagCorrelation
	Flag whether a correlation among tracks exists.
bool	m_FlagOverIteration
	Flag whether the iteration count exceeds the limit.
double	m_MagneticField
	Magnetic field.

Detailed Description

KFitBase is a base class for kinematical fitters.

Definition at line 37 of file KFitBase.h.

Constructor & Destructor Documentation

KFitBase()

KFitBase

(

void

)

Construct an object with no argument.

Definition at line 20 of file KFitBase.cc.

{
  m_ErrorCode = KFitError::kNoError;
  m_FlagFitted = false;
  m_FlagCorrelation = false;
  m_FlagOverIteration = false;
  m_MagneticField = KFitConst::kDefaultMagneticField;
  m_NDF = 0;
  m_CHIsq = -1;
  m_NecessaryTrackCount = -1;
  m_TrackCount = 0;
}

Member Function Documentation

addParticle()

enum KFitError::ECode addParticle

(

const Particle *

particle

)

Add a particle to the fitter.

The function gets track parameters from the Particle dataobject and calls addTrack().

Parameters

[in]

particle

Particle.

Returns

error code (zero if success)

Definition at line 59 of file KFitBase.cc.

{
  return addTrack(
           ROOTToCLHEP::getHepLorentzVector(particle->get4Vector()),
           ROOTToCLHEP::getPoint3D(particle->getVertex()),
           ROOTToCLHEP::getHepSymMatrix(particle->getMomentumVertexErrorMatrix()),
           particle->getCharge());
}

addTrack() [1/2]

enum KFitError::ECode addTrack	(	const CLHEP::HepLorentzVector &	p,
		const HepPoint3D &	x,
		const CLHEP::HepSymMatrix &	e,
		const double	q
	)

Add a track to the fitter object with specifying its momentum, position, error matrix, and charge.

This function internally calls addTrack(const KFitTrack &kp).

Parameters

p	Lorentz vector of the track
x	position of the track
e	(7x7) error matrix of the track
q	charge of the track

Returns

error code (zero if success)

Definition at line 47 of file KFitBase.cc.

                                                                                                                  {
  if (e.num_row() != KFitConst::kNumber7)
  {
    m_ErrorCode = KFitError::kBadMatrixSize;
    KFitError::displayError(__FILE__, __LINE__, __func__, m_ErrorCode);
    return m_ErrorCode;
  }
 
  return this->addTrack(KFitTrack(p, x, e, q));
}

addTrack() [2/2]

enum KFitError::ECode addTrack

(

const KFitTrack &

kp

)

Add a track to the fitter object.

Parameters

kp	object of the track

Returns

error code (zero if success)

Definition at line 38 of file KFitBase.cc.

                                     {
  m_Tracks.push_back(p);
  m_TrackCount = m_Tracks.size();
 
  return m_ErrorCode = KFitError::kNoError;
}

calculateNDF()

virtual enum KFitError::ECode calculateNDF ( void  )

protectedpure virtual

Calculate an NDF of the fit.

Returns

error code (zero if success)

Implemented in FourCFitKFit, MassFitKFit, MassFourCFitKFit, MassPointingVertexFitKFit, MassVertexFitKFit, RecoilMassKFit, and VertexFitKFit.

doFit1()

enum KFitError::ECode doFit1 ( void  )

protected

Perform a fit (used in MassFitKFit::doFit()).

Returns

error code (zero if success)

Definition at line 502 of file KFitBase.cc.

                 {
  if (m_ErrorCode != KFitError::kNoError) return m_ErrorCode;
 
  if (m_TrackCount < m_NecessaryTrackCount)
  {
    m_ErrorCode = KFitError::kBadTrackSize;
    KFitError::displayError(__FILE__, __LINE__, __func__, m_ErrorCode);
    return m_ErrorCode;
  }
 
  if (prepareInputMatrix() != KFitError::kNoError) return m_ErrorCode;
  if (calculateNDF() != KFitError::kNoError)       return m_ErrorCode;
 
 
  double chisq = 0;
  double tmp_chisq = KFitConst::kInitialCHIsq;
  int err_inverse = 0;
 
  HepMatrix tmp_al_1(m_al_1);
  HepMatrix tmp_V_al_1(m_V_al_1);
 
  m_al_a = m_al_0;
  HepMatrix tmp_al_a(m_al_a);
 
 
  for (int i = 0; i < KFitConst::kMaxIterationCount; i++)
  {
    if (makeCoreMatrix() != KFitError::kNoError) return m_ErrorCode;
 
    m_V_D = (m_V_al_0.similarity(m_D)).inverse(err_inverse);
    if (err_inverse != 0) {
      m_ErrorCode = KFitError::kCannotGetMatrixInverse;
      return m_ErrorCode;
    }
 
    m_lam    = m_V_D * (m_D * (m_al_0 - m_al_1) + m_d);
    chisq    = ((m_lam.T()) * (m_D * (m_al_0 - m_al_1) + m_d))(1, 1);
    m_al_1   = m_al_0 - m_V_al_0 * (m_D.T()) * m_lam;
    m_V_al_1 = m_V_al_0 - m_V_al_0 * (m_D.T()) * m_V_D * m_D * m_V_al_0;
 
    if (tmp_chisq <= chisq) {
      if (i == 0) {
        m_ErrorCode = KFitError::kBadInitialCHIsq;
        return m_ErrorCode;
      } else {
        chisq    = tmp_chisq;
        m_al_1   = tmp_al_1;
        m_al_a   = tmp_al_a;
        m_V_al_1 = tmp_V_al_1;
        break;
      }
    } else {
      tmp_chisq  = chisq;
      tmp_al_a   = tmp_al_1;
      tmp_al_1   = m_al_1;
      tmp_V_al_1 = m_V_al_1;
      if (i == KFitConst::kMaxIterationCount - 1) {
        m_al_a = tmp_al_1;
        m_FlagOverIteration = true;
      }
    }
  }
 
  if (m_ErrorCode != KFitError::kNoError) return m_ErrorCode;
 
  if (prepareOutputMatrix() != KFitError::kNoError) return m_ErrorCode;
 
  m_CHIsq = chisq;
 
  m_FlagFitted = true;
 
  return m_ErrorCode = KFitError::kNoError;
}

doFit2()

enum KFitError::ECode doFit2 ( void  )

protected

Perform a fit (used in VertexFitKFit::doFit() and MassVertexFitKFit::doFit()).

Returns

error code (zero if success)

Definition at line 578 of file KFitBase.cc.

                 {
  if (m_ErrorCode != KFitError::kNoError) return m_ErrorCode;
 
  if (m_TrackCount < m_NecessaryTrackCount)
  {
    m_ErrorCode = KFitError::kBadTrackSize;
    KFitError::displayError(__FILE__, __LINE__, __func__, m_ErrorCode);
    return m_ErrorCode;
  }
 
  if (prepareInputMatrix() != KFitError::kNoError) return m_ErrorCode;
  if (calculateNDF() != KFitError::kNoError)       return m_ErrorCode;
 
 
  double chisq = 0;
  double tmp2_chisq = KFitConst::kInitialCHIsq;
  int err_inverse = 0;
 
  m_al_a = m_al_0;
  HepMatrix tmp_al_a(m_al_a);
 
  HepMatrix tmp_D(m_D), tmp_E(m_E);
  HepMatrix tmp_V_D(m_V_D), tmp_V_E(m_V_E);
  HepMatrix tmp_lam0(m_lam0), tmp_v_a(m_v_a);
 
  HepMatrix tmp2_D(m_D), tmp2_E(m_E);
  HepMatrix tmp2_V_D(m_V_D), tmp2_V_E(m_V_E);
  HepMatrix tmp2_lam0(m_lam0), tmp2_v_a(m_v_a), tmp2_v(m_v_a);
 
 
  for (int j = 0; j < KFitConst::kMaxIterationCount; j++)   // j'th loop start
  {
 
    double tmp_chisq = KFitConst::kInitialCHIsq;
 
    for (int i = 0; i < KFitConst::kMaxIterationCount; i++) { // i'th loop start
 
      if (prepareInputSubMatrix() != KFitError::kNoError) return m_ErrorCode;
      if (makeCoreMatrix() != KFitError::kNoError)        return m_ErrorCode;
 
      m_V_D = (m_V_al_0.similarity(m_D)).inverse(err_inverse);
      if (err_inverse) {
        m_ErrorCode = KFitError::kCannotGetMatrixInverse;
        return m_ErrorCode;
      }
 
      m_V_E = ((m_E.T()) * m_V_D * m_E).inverse(err_inverse);
      if (err_inverse) {
        m_ErrorCode = KFitError::kCannotGetMatrixInverse;
        return m_ErrorCode;
      }
      m_lam0 = m_V_D * (m_D * (m_al_0 - m_al_1) + m_d);
      chisq  = ((m_lam0.T()) * (m_D * (m_al_0 - m_al_1) + m_E * (m_v - m_v_a) + m_d))(1, 1);
      m_v_a  = m_v_a - m_V_E * (m_E.T()) * m_lam0;
 
      if (tmp_chisq <= chisq) {
        if (i == 0) {
          m_ErrorCode = KFitError::kBadInitialCHIsq;
          return m_ErrorCode;
        } else {
          chisq   = tmp_chisq;
          m_v_a   = tmp_v_a;
          m_V_E   = tmp_V_E;
          m_V_D   = tmp_V_D;
          m_lam0  = tmp_lam0;
          m_E     = tmp_E;
          m_D     = tmp_D;
          break;
        }
      } else {
        tmp_chisq = chisq;
        tmp_v_a   = m_v_a;
        tmp_V_E   = m_V_E;
        tmp_V_D   = m_V_D;
        tmp_lam0  = m_lam0;
        tmp_E     = m_E;
        tmp_D     = m_D;
        if (i == KFitConst::kMaxIterationCount - 1) {
          m_FlagOverIteration = true;
        }
      }
    } // i'th loop over
 
 
    m_al_a   = m_al_1;
    m_lam    = m_lam0 - m_V_D * m_E * m_V_E * (m_E.T()) * m_lam0;
    m_al_1   = m_al_0 - m_V_al_0 * (m_D.T()) * m_lam;
 
    if (j == 0) {
 
      tmp2_chisq = chisq;
      tmp2_v_a   = m_v_a;
      tmp2_v     = m_v;
      tmp2_V_E   = m_V_E;
      tmp2_V_D   = m_V_D;
      tmp2_lam0  = m_lam0;
      tmp2_E     = m_E;
      tmp2_D     = m_D;
      tmp_al_a   = m_al_a;
 
    } else {
 
      if (tmp2_chisq <= chisq) {
        chisq   = tmp2_chisq;
        m_v_a   = tmp2_v_a;
        m_v     = tmp2_v;
        m_V_E   = tmp2_V_E;
        m_V_D   = tmp2_V_D;
        m_lam0  = tmp2_lam0;
        m_E     = tmp2_E;
        m_D     = tmp2_D;
        m_al_a  = tmp_al_a;
        break;
      } else {
        tmp2_chisq = chisq;
        tmp2_v_a   = m_v_a;
        tmp2_v     = m_v;
        tmp2_V_E   = m_V_E;
        tmp2_V_D   = m_V_D;
        tmp2_lam0  = m_lam0;
        tmp2_E     = m_E;
        tmp2_D     = m_D;
        tmp_al_a   = m_al_a;
        if (j == KFitConst::kMaxIterationCount - 1) {
          m_FlagOverIteration = true;
        }
      }
    }
  } // j'th loop over
 
 
  if (m_ErrorCode != KFitError::kNoError) return m_ErrorCode;
 
  m_lam    = m_lam0 - m_V_D * m_E * m_V_E * (m_E.T()) * m_lam0;
  m_al_1   = m_al_0 - m_V_al_0 * (m_D.T()) * m_lam;
  m_V_Dt   = m_V_D  - m_V_D * m_E * m_V_E * (m_E.T()) * m_V_D;
  m_V_al_1 = m_V_al_0 - m_V_al_0 * (m_D.T()) * m_V_Dt * m_D * m_V_al_0;
  m_Cov_v_al_1 = -m_V_E * (m_E.T()) * m_V_D * m_D * m_V_al_0;
 
  if (prepareOutputMatrix() != KFitError::kNoError) return m_ErrorCode;
 
  m_CHIsq = chisq;
 
  m_FlagFitted = true;
 
  return m_ErrorCode = KFitError::kNoError;
}

getCHIsq()

double getCHIsq ( void  ) const

virtual

Get a chi-square of the fit.

Returns

chi-square of the fit

Reimplemented in FourCFitKFit, MassFitKFit, MassFourCFitKFit, MassPointingVertexFitKFit, MassVertexFitKFit, RecoilMassKFit, and VertexFitKFit.

Definition at line 121 of file KFitBase.cc.

{
  return m_CHIsq;
}

getCorrelation()

const HepMatrix getCorrelation ( const int  id1, const int  id2, const int  flag = KFitConst::kAfterFit  ) const

virtual

Get a correlation matrix between two tracks.

Parameters

id1	first track id
id2	second track id
flag	KFitConst::kBeforeFit or KFitConst::kAfterFit

Returns

(7x7) correlation matrix

Reimplemented in FourCFitKFit, MassFitKFit, MassFourCFitKFit, MassPointingVertexFitKFit, MassVertexFitKFit, and RecoilMassKFit.

Definition at line 183 of file KFitBase.cc.

{
  if (flag == KFitConst::kAfterFit && !isFitted()) return HepMatrix(KFitConst::kNumber7, KFitConst::kNumber7, 0);
  if (!isTrackIDInRange(id1)) return HepMatrix(KFitConst::kNumber7, KFitConst::kNumber7, 0);
  if (!isTrackIDInRange(id2)) return HepMatrix(KFitConst::kNumber7, KFitConst::kNumber7, 0);
 
  switch (flag) {
    case KFitConst::kAfterFit:
      return makeError1(
               getTrackMomentum(id1),
               getTrackMomentum(id2),
               m_V_al_1.sub(KFitConst::kNumber6 * id1 + 1, KFitConst::kNumber6 * (id1 + 1), KFitConst::kNumber6 * id2 + 1,
                            KFitConst::kNumber6 * (id2 + 1))
             );
 
    default:
      if (id1 == id2) {
 
        return static_cast<HepMatrix>(m_Tracks[id1].getError(KFitConst::kBeforeFit));
 
      } else {
        const int idx1 = id1 < id2 ? id1 : id2, idx2 = id1 < id2 ? id2 : id1;
 
        int index = 0;
 
        for (int i = 0; i < idx1; i++) index += m_TrackCount - 1 - i;
        index -= idx1 + 1;
        index += idx2;
        if (id1 == idx1)
          return m_BeforeCorrelation[index + idx2];
        else
          return m_BeforeCorrelation[index + idx2].T();
      }
  }
}

getErrorCode()

enum KFitError::ECode getErrorCode

(

void

)

const

Get a code of the last error.

Returns

the last error code

Definition at line 101 of file KFitBase.cc.

                             {
  return m_ErrorCode;
}

getMagneticField()

double getMagneticField

(

void

)

const

Get a magnetic field.

Returns

magnetic field

Definition at line 128 of file KFitBase.cc.

{
  return m_MagneticField;
}

getNDF()

int getNDF ( void  ) const

virtual

Get an NDF of the fit.

Returns

NDF of the fit

Definition at line 114 of file KFitBase.cc.

{
  return m_NDF;
}

getTrack()

const KFitTrack getTrack

(

const int

id

)

const

Get a specified track object.

Parameters

id

track id

Returns

specified track object

Definition at line 175 of file KFitBase.cc.

{
  if (!isTrackIDInRange(id)) return KFitTrack();
  return m_Tracks[id];
}

getTrackCHIsq()

double getTrackCHIsq ( const int  id ) const

virtual

Get a chi-square of the track.

Parameters

id

track id

Returns

chi-square of the track

Reimplemented in FourCFitKFit, MassFitKFit, MassFourCFitKFit, MassPointingVertexFitKFit, MassVertexFitKFit, RecoilMassKFit, and VertexFitKFit.

Definition at line 135 of file KFitBase.cc.

{
  if (!isFitted()) return -1.;
  if (!isTrackIDInRange(id)) return -1.;
 
  HepMatrix da(m_Tracks[id].getFitParameter(KFitConst::kBeforeFit) - m_Tracks[id].getFitParameter(KFitConst::kAfterFit));
  int err_inverse = 0;
  const double chisq = (da.T() * (m_Tracks[id].getFitError(KFitConst::kBeforeFit).inverse(err_inverse)) * da)[0][0];
 
  if (err_inverse) {
    KFitError::displayError(__FILE__, __LINE__, __func__, KFitError::kCannotGetMatrixInverse);
    return -1.;
  }
 
  return chisq;
}

getTrackCount()

int getTrackCount

(

void

)

const

Get the number of added tracks.

Returns

the number of added tracks

Definition at line 107 of file KFitBase.cc.

{
  return m_TrackCount;
}

getTrackError()

const HepSymMatrix getTrackError

(

const int

id

)

const

Get an error matrix of the track.

Parameters

id

track id

Returns

error matrix of the track

Definition at line 168 of file KFitBase.cc.

{
  if (!isTrackIDInRange(id)) return HepSymMatrix(KFitConst::kNumber7, 0);
  return m_Tracks[id].getError();
}

getTrackMomentum()

const HepLorentzVector getTrackMomentum

(

const int

id

)

const

Get a Lorentz vector of the track.

Parameters

id

track id

Returns

Lorentz vector of the track

Definition at line 154 of file KFitBase.cc.

{
  if (!isTrackIDInRange(id)) return HepLorentzVector();
  return m_Tracks[id].getMomentum();
}

getTrackPosition()

const HepPoint3D getTrackPosition

(

const int

id

)

const

Get a position of the track.

Parameters

id

track id

Returns

position of the track

Definition at line 161 of file KFitBase.cc.

{
  if (!isTrackIDInRange(id)) return HepPoint3D();
  return m_Tracks[id].getPosition();
}

isFitted()

bool isFitted

(

void

)

const

Return false if fit is not performed yet or performed fit is failed; otherwise true.

Returns

see description

Definition at line 728 of file KFitBase.cc.

{
  if (m_FlagFitted) return true;
 
  KFitError::displayError(__FILE__, __LINE__, __func__, KFitError::kNotFittedYet);
 
  return false;
}

isNonZeroEnergy()

bool isNonZeroEnergy ( const CLHEP::HepLorentzVector &  p ) const

protected

Check if the energy is non-zero.

Parameters

p	Lorentz vector

Returns

true for non-zero energy, false for otherwise

Definition at line 750 of file KFitBase.cc.

{
  if (p.t() != 0) return true;
 
  KFitError::displayError(__FILE__, __LINE__, __func__, KFitError::kDivisionByZero);
 
  return false;
}

isTrackIDInRange()

bool isTrackIDInRange ( const int  id ) const

protected

Check if the id is in the range.

Parameters

id

track id

Returns

true if the id is in the range, false otherwise

Definition at line 739 of file KFitBase.cc.

{
  if (0 <= id && id < m_TrackCount) return true;
 
  KFitError::displayError(__FILE__, __LINE__, __func__, KFitError::kOutOfRange);
 
  return false;
}

makeCoreMatrix()

virtual enum KFitError::ECode makeCoreMatrix ( void  )

protectedpure virtual

Build matrices using the kinematical constraint.

Returns

error code (zero if success)

Implemented in FourCFitKFit, MassFitKFit, MassFourCFitKFit, MassPointingVertexFitKFit, MassVertexFitKFit, RecoilMassKFit, and VertexFitKFit.

makeError1() [1/2]

const HepSymMatrix makeError1 ( const CLHEP::HepLorentzVector &  p, const CLHEP::HepMatrix &  e  ) const

protected

Rebuild an error matrix from a Lorentz vector and an error matrix.

Parameters

p	Lorentz vector
e	(6x6) error matrix

Returns

(7x7) error matrix

Definition at line 221 of file KFitBase.cc.

{
  // self track
  // Error(6x6,e) ==> Error(7x7,output(hsm)) using Momentum(p).
 
  if (!isNonZeroEnergy(p)) return HepSymMatrix(KFitConst::kNumber7, 0);
 
  HepSymMatrix hsm(KFitConst::kNumber7, 0);
 
  for (int i = 0; i < 3; i++) for (int j = i; j < 3; j++) {
      hsm[i][j]     = e[i][j];
      hsm[4 + i][4 + j] = e[3 + i][3 + j];
    }
  for (int i = 0; i < 3; i++) for (int j = 0; j < 3; j++) {
      hsm[i][4 + j] = e[i][3 + j];
    }
 
  const double invE = 1 / p.t();
  hsm[0][3] = (p.x() * hsm[0][0] + p.y() * hsm[0][1] + p.z() * hsm[0][2]) * invE;
  hsm[1][3] = (p.x() * hsm[0][1] + p.y() * hsm[1][1] + p.z() * hsm[1][2]) * invE;
  hsm[2][3] = (p.x() * hsm[0][2] + p.y() * hsm[1][2] + p.z() * hsm[2][2]) * invE;
  hsm[3][3] = (p.x() * p.x() * hsm[0][0] + p.y() * p.y() * hsm[1][1] + p.z() * p.z() * hsm[2][2]
               + 2.0 * p.x() * p.y() * hsm[0][1]
               + 2.0 * p.x() * p.z() * hsm[0][2]
               + 2.0 * p.y() * p.z() * hsm[1][2]) * invE * invE;
  hsm[3][4] = (p.x() * hsm[0][4] + p.y() * hsm[1][4] + p.z() * hsm[2][4]) * invE;
  hsm[3][5] = (p.x() * hsm[0][5] + p.y() * hsm[1][5] + p.z() * hsm[2][5]) * invE;
  hsm[3][6] = (p.x() * hsm[0][6] + p.y() * hsm[1][6] + p.z() * hsm[2][6]) * invE;
 
  return hsm;
}

makeError1() [2/2]

const HepMatrix makeError1 ( const CLHEP::HepLorentzVector &  p1, const CLHEP::HepLorentzVector &  p2, const CLHEP::HepMatrix &  e  ) const

protected

Rebuild an error matrix from a pair of Lorentz vectors and an error matrix.

Parameters

p1	first Lorentz vector
p2	second Lorentz vector
e	(6x6) error matrix

Returns

(7x7) error matrix

Definition at line 255 of file KFitBase.cc.

{
  // track and track
  // Error(6x6,e) ==> Error(7x7,output(hm)) using Momentum(p1&p2).
 
  if (!isNonZeroEnergy(p1)) return HepSymMatrix(KFitConst::kNumber7, 0);
  if (!isNonZeroEnergy(p2)) return HepSymMatrix(KFitConst::kNumber7, 0);
 
  HepMatrix hm(KFitConst::kNumber7, KFitConst::kNumber7, 0);
 
  for (int i = 0; i < 3; i++) for (int j = 0; j < 3; j++) {
      hm[i][j]     = e[i][j];
      hm[4 + i][4 + j] = e[3 + i][3 + j];
      hm[4 + i][j]   = e[3 + i][j];
      hm[i][4 + j]   = e[i][3 + j];
    }
 
  const double invE1 = 1 / p1.t();
  const double invE2 = 1 / p2.t();
  hm[0][3] = (p2.x() * hm[0][0] + p2.y() * hm[0][1] + p2.z() * hm[0][2]) * invE2;
  hm[1][3] = (p2.x() * hm[1][0] + p2.y() * hm[1][1] + p2.z() * hm[1][2]) * invE2;
  hm[2][3] = (p2.x() * hm[2][0] + p2.y() * hm[2][1] + p2.z() * hm[2][2]) * invE2;
  hm[4][3] = (p2.x() * hm[4][0] + p2.y() * hm[4][1] + p2.z() * hm[4][2]) * invE2;
  hm[5][3] = (p2.x() * hm[5][0] + p2.y() * hm[5][1] + p2.z() * hm[5][2]) * invE2;
  hm[6][3] = (p2.x() * hm[6][0] + p2.y() * hm[6][1] + p2.z() * hm[6][2]) * invE2;
  hm[3][3] = (p1.x() * p2.x() * hm[0][0] + p1.y() * p2.y() * hm[1][1] + p1.z() * p2.z() * hm[2][2] +
              p1.x() * p2.y() * hm[0][1] + p2.x() * p1.y() * hm[1][0] +
              p1.x() * p2.z() * hm[0][2] + p2.x() * p1.z() * hm[2][0] +
              p1.y() * p2.z() * hm[1][2] + p2.y() * p1.z() * hm[2][1]) * invE1 * invE2;
  hm[3][0] = (p1.x() * hm[0][0] + p1.y() * hm[1][0] + p1.z() * hm[2][0]) * invE1;
  hm[3][1] = (p1.x() * hm[0][1] + p1.y() * hm[1][1] + p1.z() * hm[2][1]) * invE1;
  hm[3][2] = (p1.x() * hm[0][2] + p1.y() * hm[1][2] + p1.z() * hm[2][2]) * invE1;
  hm[3][4] = (p1.x() * hm[0][4] + p1.y() * hm[1][4] + p1.z() * hm[2][4]) * invE1;
  hm[3][5] = (p1.x() * hm[0][5] + p1.y() * hm[1][5] + p1.z() * hm[2][5]) * invE1;
  hm[3][6] = (p1.x() * hm[0][6] + p1.y() * hm[1][6] + p1.z() * hm[2][6]) * invE1;
 
  return hm;
}

makeError2()

const HepMatrix makeError2 ( const CLHEP::HepLorentzVector &  p, const CLHEP::HepMatrix &  e  ) const

protected

Rebuild an error matrix from a Lorentz vector and an error matrix.

Parameters

p	Lorentz vector
e	(3x6) error matrix

Returns

(3x7) error matrix

Definition at line 296 of file KFitBase.cc.

{
  // vertex and track
  // Error(3x6,e) ==> Error(3x7,output(hm)) using Momentum(p).
 
  if (!isNonZeroEnergy(p)) return HepSymMatrix(KFitConst::kNumber7, 0);
 
  HepMatrix hm(3, KFitConst::kNumber7, 0);
 
  for (int i = 0; i < 3; i++) for (int j = 0; j < 3; j++) {
      hm[i][j]   = e[i][j];
      hm[i][4 + j] = e[i][3 + j];
    }
 
  const double invE = 1 / p.t();
  hm[0][3] = (p.x() * hm[0][0] + p.y() * hm[0][1] + p.z() * hm[0][2]) * invE;
  hm[1][3] = (p.x() * hm[1][0] + p.y() * hm[1][1] + p.z() * hm[1][2]) * invE;
  hm[2][3] = (p.x() * hm[2][0] + p.y() * hm[2][1] + p.z() * hm[2][2]) * invE;
 
  return hm;
}

makeError3() [1/2]

const HepSymMatrix makeError3 ( const CLHEP::HepLorentzVector &  p, const CLHEP::HepMatrix &  e, const bool  is_fix_mass  ) const

protected

Rebuild an error matrix from a Lorentz vector and an error matrix.

Parameters

p	Lorentz vector
e	(7x7) error matrix
is_fix_mass	true to recalculate energy term from other parameters, false to do nothing

Returns

(7x7) error matrix

Definition at line 320 of file KFitBase.cc.

{
  // self track
  // Error(7x7,e) ==> Error(7x7,output(hsm)) using Momentum(p).
  // is_fix_mass = 1 : Energy term is recalculated from the other parameters.
  // is_fix_mass = 0 : hsm = e.
 
  if (!isNonZeroEnergy(p)) return HepSymMatrix(KFitConst::kNumber7, 0);
 
  if (!is_fix_mass) {
    HepSymMatrix hsm(KFitConst::kNumber7, 0);
    for (int i = 0; i < 7; i++) for (int j = i; j < 7; j++) {
        hsm[i][j] = e[i][j];
      }
    return hsm;
  }
 
  HepSymMatrix hsm(KFitConst::kNumber7, 0);
 
  for (int i = 0; i < 7; i++) {
    if (i != 3)
      for (int j = i; j < 7; j++) hsm[i][j] = e[i][j];
  }
 
  double invE = 1 / p.t();
  hsm[0][3] = (p.x() * hsm[0][0] + p.y() * hsm[0][1] + p.z() * hsm[0][2]) * invE;
  hsm[1][3] = (p.x() * hsm[0][1] + p.y() * hsm[1][1] + p.z() * hsm[1][2]) * invE;
  hsm[2][3] = (p.x() * hsm[0][2] + p.y() * hsm[1][2] + p.z() * hsm[2][2]) * invE;
  hsm[3][3] = (p.x() * p.x() * hsm[0][0] + p.y() * p.y() * hsm[1][1] + p.z() * p.z() * hsm[2][2]
               + 2.0 * p.x() * p.y() * hsm[0][1]
               + 2.0 * p.x() * p.z() * hsm[0][2]
               + 2.0 * p.y() * p.z() * hsm[1][2]) * invE * invE;
  hsm[3][4] = (p.x() * hsm[0][4] + p.y() * hsm[1][4] + p.z() * hsm[2][4]) * invE;
  hsm[3][5] = (p.x() * hsm[0][5] + p.y() * hsm[1][5] + p.z() * hsm[2][5]) * invE;
  hsm[3][6] = (p.x() * hsm[0][6] + p.y() * hsm[1][6] + p.z() * hsm[2][6]) * invE;
 
  return hsm;
}

makeError3() [2/2]

const HepMatrix makeError3 ( const CLHEP::HepLorentzVector &  p1, const CLHEP::HepLorentzVector &  p2, const CLHEP::HepMatrix &  e, const bool  is_fix_mass1, const bool  is_fix_mass2  ) const

protected

Rebuild an error matrix from a pair of Lorentz vectors and an error matrix.

Parameters

p1	first Lorentz vector
p2	second Lorentz vector
e	(7x7) error matrix
is_fix_mass1	true to recalculate energy term from other parameters, false to do nothing
is_fix_mass2	true to recalculate energy term from other parameters, false to do nothing

Returns

(7x7) error matrix

Definition at line 361 of file KFitBase.cc.

{
  // track and track
  // Error(7x7,e) ==> Error(7x7,output(hm)) using Momentum(p1&p2).
  // is_fix_mass = 1 : Energy term is recalculated from the other parameters.
  // is_fix_mass = 0 : not.
 
  if (is_fix_mass1 && is_fix_mass2) {
    if (!isNonZeroEnergy(p1)) return HepSymMatrix(KFitConst::kNumber7, 0);
    if (!isNonZeroEnergy(p2)) return HepSymMatrix(KFitConst::kNumber7, 0);
 
    HepMatrix hm(e);
 
    const double invE1 = 1 / p1.t();
    const double invE2 = 1 / p2.t();
    hm[0][3] = (p2.x() * hm[0][0] + p2.y() * hm[0][1] + p2.z() * hm[0][2]) * invE2;
    hm[1][3] = (p2.x() * hm[1][0] + p2.y() * hm[1][1] + p2.z() * hm[1][2]) * invE2;
    hm[2][3] = (p2.x() * hm[2][0] + p2.y() * hm[2][1] + p2.z() * hm[2][2]) * invE2;
    hm[4][3] = (p2.x() * hm[4][0] + p2.y() * hm[4][1] + p2.z() * hm[4][2]) * invE2;
    hm[5][3] = (p2.x() * hm[5][0] + p2.y() * hm[5][1] + p2.z() * hm[5][2]) * invE2;
    hm[6][3] = (p2.x() * hm[6][0] + p2.y() * hm[6][1] + p2.z() * hm[6][2]) * invE2;
    hm[3][0] = (p1.x() * hm[0][0] + p1.y() * hm[1][0] + p1.z() * hm[2][0]) * invE1;
    hm[3][1] = (p1.x() * hm[0][1] + p1.y() * hm[1][1] + p1.z() * hm[2][1]) * invE1;
    hm[3][2] = (p1.x() * hm[0][2] + p1.y() * hm[1][2] + p1.z() * hm[2][2]) * invE1;
    hm[3][3] = (p1.x() * p2.x() * hm[0][0] + p1.y() * p2.y() * hm[1][1] + p1.z() * p2.z() * hm[2][2] +
                p1.x() * p2.y() * hm[0][1] + p2.x() * p1.y() * hm[1][0] +
                p1.x() * p2.z() * hm[0][2] + p2.x() * p1.z() * hm[2][0] +
                p1.y() * p2.z() * hm[1][2] + p2.y() * p1.z() * hm[2][1]) * invE1 * invE2;
    hm[3][4] = (p1.x() * hm[0][4] + p1.y() * hm[1][4] + p1.z() * hm[2][4]) * invE1;
    hm[3][5] = (p1.x() * hm[0][5] + p1.y() * hm[1][5] + p1.z() * hm[2][5]) * invE1;
    hm[3][6] = (p1.x() * hm[0][6] + p1.y() * hm[1][6] + p1.z() * hm[2][6]) * invE1;
 
    return hm;
  }
 
 
  if (is_fix_mass1 && !is_fix_mass2) {
    if (!isNonZeroEnergy(p1)) return HepSymMatrix(KFitConst::kNumber7, 0);
 
    HepMatrix hm(e);
 
    const double invE1 = 1 / p1.t();
    hm[3][0] = (p1.x() * hm[0][0] + p1.y() * hm[1][0] + p1.z() * hm[2][0]) * invE1;
    hm[3][1] = (p1.x() * hm[0][1] + p1.y() * hm[1][1] + p1.z() * hm[2][1]) * invE1;
    hm[3][2] = (p1.x() * hm[0][2] + p1.y() * hm[1][2] + p1.z() * hm[2][2]) * invE1;
    hm[3][3] = (p1.x() * hm[0][3] + p1.y() * hm[1][3] + p1.z() * hm[2][3]) * invE1;
    hm[3][4] = (p1.x() * hm[0][4] + p1.y() * hm[1][4] + p1.z() * hm[2][4]) * invE1;
    hm[3][5] = (p1.x() * hm[0][5] + p1.y() * hm[1][5] + p1.z() * hm[2][5]) * invE1;
    hm[3][6] = (p1.x() * hm[0][6] + p1.y() * hm[1][6] + p1.z() * hm[2][6]) * invE1;
 
    return hm;
  }
 
 
  if (!is_fix_mass1 &&  is_fix_mass2) {
    if (!isNonZeroEnergy(p2)) return HepSymMatrix(KFitConst::kNumber7, 0);
 
    HepMatrix hm(e);
 
    const double invE2 = 1 / p2.t();
    hm[0][3] = (p2.x() * hm[0][0] + p2.y() * hm[0][1] + p2.z() * hm[0][2]) * invE2;
    hm[1][3] = (p2.x() * hm[1][0] + p2.y() * hm[1][1] + p2.z() * hm[1][2]) * invE2;
    hm[2][3] = (p2.x() * hm[2][0] + p2.y() * hm[2][1] + p2.z() * hm[2][2]) * invE2;
    hm[3][3] = (p2.x() * hm[3][0] + p2.y() * hm[3][1] + p2.z() * hm[3][2]) * invE2;
    hm[4][3] = (p2.x() * hm[4][0] + p2.y() * hm[4][1] + p2.z() * hm[4][2]) * invE2;
    hm[5][3] = (p2.x() * hm[5][0] + p2.y() * hm[5][1] + p2.z() * hm[5][2]) * invE2;
    hm[6][3] = (p2.x() * hm[6][0] + p2.y() * hm[6][1] + p2.z() * hm[6][2]) * invE2;
 
    return hm;
  }
 
  return e;
}

makeError4()

const HepMatrix makeError4 ( const CLHEP::HepLorentzVector &  p, const CLHEP::HepMatrix &  e  ) const

protected

Rebuild an error matrix from a Lorentz vector and an error matrix.

Parameters

p	Lorentz vector
e	(3x7) error matrix

Returns

(7x7) error matrix

Definition at line 439 of file KFitBase.cc.

{
  // vertex and track
  // Error(3x7,e) ==> Error(3x7,output(hm)) using Momentum(p).
  // Energy term is recalculated from the other parameters.
 
  if (!isNonZeroEnergy(p)) return HepSymMatrix(KFitConst::kNumber7, 0);
 
  HepMatrix hm(e);
 
  const double invE = 1 / p.t();
  hm[0][3] = (p.x() * hm[0][0] + p.y() * hm[0][1] + p.z() * hm[0][2]) * invE;
  hm[1][3] = (p.x() * hm[1][0] + p.y() * hm[1][1] + p.z() * hm[1][2]) * invE;
  hm[2][3] = (p.x() * hm[2][0] + p.y() * hm[2][1] + p.z() * hm[2][2]) * invE;
 
  return hm;
}

prepareCorrelation()

enum KFitError::ECode prepareCorrelation ( void  )

protectedvirtual

Build a grand correlation matrix from input-track properties.

Returns

error code (zero if success)

Reimplemented in FourCFitKFit, MassFitKFit, MassFourCFitKFit, MassPointingVertexFitKFit, MassVertexFitKFit, and RecoilMassKFit.

Definition at line 459 of file KFitBase.cc.

                             {
  if (m_BeforeCorrelation.size() != (double)m_TrackCount * ((double)m_TrackCount - 1)*.5)
  {
    m_ErrorCode = KFitError::kBadCorrelationSize;
    KFitError::displayError(__FILE__, __LINE__, __func__, m_ErrorCode);
    return m_ErrorCode;
  }
 
  HepMatrix tmp_hm(KFitConst::kNumber6, KFitConst::kNumber6, 0);
  int row = 0, col = 0;
 
  for (auto& hm : m_BeforeCorrelation)
  {
    row++;
    if (row == m_TrackCount) {
      col++;
      row = col + 1;
    }
 
    // 7x7 --> 6x6
    for (int i = 0; i < 3; i++) for (int j = 0; j < 3; j++) {
        tmp_hm[i][j]     = hm[i][j];
        tmp_hm[3 + i][3 + j] = hm[4 + i][4 + j];
        tmp_hm[3 + i][j]   = hm[4 + i][j];
        tmp_hm[i][3 + j]   = hm[i][4 + j];
      }
 
    int ii = 0, jj = 0;
    for (int i = KFitConst::kNumber6 * row; i < KFitConst::kNumber6 * (row + 1); i++) {
      for (int j = KFitConst::kNumber6 * col; j < KFitConst::kNumber6 * (col + 1); j++) {
        m_V_al_0[i][j] = tmp_hm[ii][jj];
        jj++;
      }
      jj = 0;
      ii++;
    }
  }
 
  return m_ErrorCode = KFitError::kNoError;
}

prepareInputMatrix()

virtual enum KFitError::ECode prepareInputMatrix ( void  )

protectedpure virtual

Build grand matrices for minimum search from input-track properties.

Returns

error code (zero if success)

Implemented in FourCFitKFit, MassFitKFit, MassFourCFitKFit, MassPointingVertexFitKFit, MassVertexFitKFit, RecoilMassKFit, and VertexFitKFit.

prepareInputSubMatrix()

virtual enum KFitError::ECode prepareInputSubMatrix ( void  )

protectedpure virtual

Build sub-matrices for minimum search from input-track properties.

Returns

error code (zero if success)

Implemented in FourCFitKFit, MassFitKFit, MassFourCFitKFit, MassPointingVertexFitKFit, MassVertexFitKFit, RecoilMassKFit, and VertexFitKFit.

prepareOutputMatrix()

virtual enum KFitError::ECode prepareOutputMatrix ( void  )

protectedpure virtual

Build an output error matrix.

Returns

error code (zero if success)

Implemented in FourCFitKFit, MassFitKFit, MassFourCFitKFit, MassPointingVertexFitKFit, MassVertexFitKFit, RecoilMassKFit, and VertexFitKFit.

setCorrelation()

enum KFitError::ECode setCorrelation ( const CLHEP::HepMatrix &  c )

virtual

Set a correlation matrix.

Not intended for end user's use.

Parameters

c	(7x7) correlation matrix

Returns

error code (zero if success)

Reimplemented in FourCFitKFit, MassFitKFit, MassFourCFitKFit, MassPointingVertexFitKFit, MassVertexFitKFit, and RecoilMassKFit.

Definition at line 70 of file KFitBase.cc.

                                           {
  if (e.num_row() != KFitConst::kNumber7)
  {
    m_ErrorCode = KFitError::kBadMatrixSize;
    KFitError::displayError(__FILE__, __LINE__, __func__, m_ErrorCode);
    return m_ErrorCode;
  }
  m_BeforeCorrelation.push_back(e);
  m_FlagCorrelation = true;
 
  return m_ErrorCode = KFitError::kNoError;
}

setMagneticField()

enum KFitError::ECode setMagneticField

(

const double

mf

)

Change a magnetic field from the default value KFitConst::kDefaultMagneticField.

Parameters

mf	magnetic field to set

Returns

error code (zero if success)

Definition at line 93 of file KFitBase.cc.

                                          {
  m_MagneticField = mf;
 
  return m_ErrorCode = KFitError::kNoError;
}

setZeroCorrelation()

enum KFitError::ECode setZeroCorrelation ( void  )

virtual

Indicate no correlation between tracks.

Not intended for end user's use.

Returns

error code (zero if success)

Reimplemented in FourCFitKFit, MassFitKFit, MassFourCFitKFit, MassPointingVertexFitKFit, MassVertexFitKFit, and RecoilMassKFit.

Definition at line 85 of file KFitBase.cc.

                             {
  HepMatrix zero(KFitConst::kNumber7, KFitConst::kNumber7, 0);
 
  return this->setCorrelation(zero);
}

Member Data Documentation

m_al_0

CLHEP::HepMatrix m_al_0

protected

See J.Tanaka Ph.D (2001) p136 for definition.

Definition at line 257 of file KFitBase.h.

m_al_1

CLHEP::HepMatrix m_al_1

protected

See J.Tanaka Ph.D (2001) p136 for definition.

Definition at line 259 of file KFitBase.h.

m_al_a

CLHEP::HepMatrix m_al_a

protected

See J.Tanaka Ph.D (2001) p137 for definition.

Definition at line 261 of file KFitBase.h.

m_BeforeCorrelation

std::vector<CLHEP::HepMatrix> m_BeforeCorrelation

protected

Container of input correlation matrices.

Definition at line 251 of file KFitBase.h.

m_CHIsq

double m_CHIsq

protected

chi-square of the fit.

Definition at line 297 of file KFitBase.h.

m_Cov_v_al_1

CLHEP::HepMatrix m_Cov_v_al_1

protected

See J.Tanaka Ph.D (2001) p137 for definition.

Definition at line 291 of file KFitBase.h.

m_D

CLHEP::HepMatrix m_D

protected

See J.Tanaka Ph.D (2001) p137 for definition.

Definition at line 266 of file KFitBase.h.

m_d

CLHEP::HepMatrix m_d

protected

See J.Tanaka Ph.D (2001) p137 for definition.

Definition at line 268 of file KFitBase.h.

m_E

CLHEP::HepMatrix m_E

protected

See J.Tanaka Ph.D (2001) p137 for definition.

Definition at line 279 of file KFitBase.h.

m_ErrorCode

enum KFitError::ECode m_ErrorCode

protected

Error code.

Definition at line 243 of file KFitBase.h.

m_FlagCorrelation

bool m_FlagCorrelation

protected

Flag whether a correlation among tracks exists.

Definition at line 306 of file KFitBase.h.

m_FlagFitted

bool m_FlagFitted

protected

Flag to indicate if the fit is performed and succeeded.

Definition at line 245 of file KFitBase.h.

m_FlagOverIteration

bool m_FlagOverIteration

protected

Flag whether the iteration count exceeds the limit.

Definition at line 308 of file KFitBase.h.

m_lam

CLHEP::HepMatrix m_lam

protected

See J.Tanaka Ph.D (2001) p137 for definition.

Definition at line 276 of file KFitBase.h.

m_lam0

CLHEP::HepMatrix m_lam0

protected

See J.Tanaka Ph.D (2001) p138 for definition.

Definition at line 283 of file KFitBase.h.

m_MagneticField

double m_MagneticField

protected

Magnetic field.

Definition at line 311 of file KFitBase.h.

m_NDF

int m_NDF

protected

NDF of the fit.

Definition at line 295 of file KFitBase.h.

m_NecessaryTrackCount

int m_NecessaryTrackCount

protected

Number needed tracks to perform fit.

Definition at line 303 of file KFitBase.h.

m_property

CLHEP::HepMatrix m_property

protected

Container of charges and masses.

Definition at line 263 of file KFitBase.h.

m_TrackCount

int m_TrackCount

protected

Number of tracks.

Definition at line 301 of file KFitBase.h.

m_Tracks

std::vector<KFitTrack> m_Tracks

protected

Container of input tracks.

Definition at line 249 of file KFitBase.h.

m_v

CLHEP::HepMatrix m_v

protected

See J.Tanaka Ph.D (2001) p137 for definition.

Definition at line 285 of file KFitBase.h.

m_v_a

CLHEP::HepMatrix m_v_a

protected

See J.Tanaka Ph.D (2001) p137 for definition.

Definition at line 287 of file KFitBase.h.

m_V_al_0

CLHEP::HepSymMatrix m_V_al_0

protected

See J.Tanaka Ph.D (2001) p137 for definition.

Definition at line 255 of file KFitBase.h.

m_V_al_1

CLHEP::HepMatrix m_V_al_1

protected

See J.Tanaka Ph.D (2001) p138 for definition.

Definition at line 274 of file KFitBase.h.

m_V_D

CLHEP::HepMatrix m_V_D

protected

See J.Tanaka Ph.D (2001) p138 for definition.

Definition at line 271 of file KFitBase.h.

m_V_Dt

CLHEP::HepMatrix m_V_Dt

protected

See J.Tanaka Ph.D (2001) p138 for definition.

Definition at line 289 of file KFitBase.h.

m_V_E

CLHEP::HepMatrix m_V_E

protected

See J.Tanaka Ph.D (2001) p138 for definition.

Definition at line 281 of file KFitBase.h.

---

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

• analysis/VertexFitting/KFit/include/KFitBase.h
• analysis/VertexFitting/KFit/src/KFitBase.cc