VertexFitKFit Class Reference

VertexFitKFit is a derived class from KFitBase to perform vertex-constraint kinematical fit. More...

#include <VertexFitKFit.h>

Inheritance diagram for VertexFitKFit:

Public Member Functions
	VertexFitKFit (void)
	Construct an object with no argument.
	~VertexFitKFit (void) override
	Destruct the object.
enum KFitError::ECode	setInitialVertex (const HepPoint3D &v)
	Set an initial vertex point for the vertex-vertex constraint fit.
enum KFitError::ECode	setInitialVertex (const ROOT::Math::XYZVector &v)
	Set an initial vertex point for the mass-vertex constraint fit.
enum KFitError::ECode	setIpProfile (const HepPoint3D &ip, const CLHEP::HepSymMatrix &ipe)
	Set an IP-ellipsoid shape for the vertex constraint fit.
enum KFitError::ECode	setIpTubeProfile (const CLHEP::HepLorentzVector &p, const HepPoint3D &x, const CLHEP::HepSymMatrix &e, const double q)
	Set a virtual IP-tube track for the vertex constraint fit.
enum KFitError::ECode	setKnownVertex (const bool flag=true)
	Tell the object to perform a fit with vertex position fixed.
enum KFitError::ECode	setCorrelationMode (const bool m)
	Tell the object to perform a fit with track correlations.
const HepPoint3D	getVertex (const int flag=KFitConst::kAfterFit) const
	Get a vertex position.
const CLHEP::HepSymMatrix	getVertexError (void) const
	Get a fitted vertex error matrix.
double	getCHIsqVertex (void) const
	Get a chi-square of the fit excluding IP-constraint part.
const CLHEP::HepMatrix	getTrackVertexError (const int id) const
	Get a vertex error matrix of the track.
double	getTrackCHIsq (const int id) const override
	Get a chi-square of the track.
double	getTrackPartCHIsq (void) const
	Get a sum of the chi-square associated to the input tracks.
int	getTrackPartNDF (void) const
	Get an NDF relevant to the getTrackPartCHIsq().
enum KFitError::ECode	doFit (void)
	Perform a vertex-constraint fit.
enum KFitError::ECode	updateMother (Particle *mother)
	Update mother particle.
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.
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
virtual enum KFitError::ECode	prepareCorrelation (void)
	Build a grand correlation matrix from input-track properties.
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.

Static Protected Member Functions
static CLHEP::HepSymMatrix	makeError1 (const CLHEP::HepLorentzVector &p, const CLHEP::HepMatrix &e)
	Rebuild an error matrix from a Lorentz vector and an error matrix.
static CLHEP::HepMatrix	makeError1 (const CLHEP::HepLorentzVector &p1, const CLHEP::HepLorentzVector &p2, const CLHEP::HepMatrix &e)
	Rebuild an error matrix from a pair of Lorentz vectors and an error matrix.
static CLHEP::HepMatrix	makeError2 (const CLHEP::HepLorentzVector &p, const CLHEP::HepMatrix &e)
	Rebuild an error matrix from a Lorentz vector and an error matrix.
static CLHEP::HepSymMatrix	makeError3 (const CLHEP::HepLorentzVector &p, const CLHEP::HepMatrix &e, const bool is_fix_mass)
	Rebuild an error matrix from a Lorentz vector and an error matrix.
static 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)
	Rebuild an error matrix from a pair of Lorentz vectors and an error matrix.
static CLHEP::HepMatrix	makeError4 (const CLHEP::HepLorentzVector &p, const CLHEP::HepMatrix &e)
	Rebuild an error matrix from a Lorentz vector and an error matrix.
static bool	isNonZeroEnergy (const CLHEP::HepLorentzVector &p)
	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.

Private Member Functions
enum KFitError::ECode	doFit3 (void)
	Perform a standard vertex-constraint fit including IP-tube constraint.
enum KFitError::ECode	doFit4 (void)
	Perform a IP-ellipsoid and vertex-constraint fit.
enum KFitError::ECode	doFit5 (void)
	Perform a fixed-vertex-position fit mainly for slow pion.
enum KFitError::ECode	prepareInputMatrix (void) override
	Build grand matrices for minimum search from input-track properties.
enum KFitError::ECode	prepareInputSubMatrix (void) override
	Build sub-matrices for minimum search from input-track properties.
enum KFitError::ECode	prepareOutputMatrix (void) override
	Build an output error matrix.
enum KFitError::ECode	makeCoreMatrix (void) override
	Build matrices using the kinematical constraint.
enum KFitError::ECode	calculateNDF (void) override
	Calculate an NDF of the fit.
enum KFitError::ECode	appendTube (void)
	Add the virtual tube track to m_Tracks just before the internal minimization call.
enum KFitError::ECode	deleteTube (void)
	Delete the virtual tube track to m_Tracks just after the internal minimization call.

Private Attributes
bool	m_CorrelationMode
	Flag controlled by setCorrelationMode().
double	m_EachCHIsq [KFitConst::kMaxTrackCount2]
	Container of chi-square's of the input tracks.
double	m_CHIsqVertex
	chi-square of the fit excluding IP-constraint part.
HepPoint3D	m_BeforeVertex
	Vertex position before the fit.
HepPoint3D	m_AfterVertex
	Vertex position after the fit.
CLHEP::HepSymMatrix	m_AfterVertexError
	Vertex error matrix after the fit.
std::vector< CLHEP::HepMatrix >	m_AfterTrackVertexError
	Array of vertex error matrices after the fit.
bool	m_FlagBeam
	Flag if to perform IP-ellipsoid constraint fit.
CLHEP::HepSymMatrix	m_BeamError
	Error matrix modeling the IP ellipsoid.
bool	m_FlagKnownVertex
	Flag controlled by setKnownVertex().
bool	m_FlagTube
	Flag if to perform IP-tube constraint fit.
int	m_iTrackTube
	ID of the virtual tube track in the m_Tracks.
KFitTrack	m_TubeTrack
	Entity of the virtual IP-tube track.

Detailed Description

VertexFitKFit is a derived class from KFitBase to perform vertex-constraint kinematical fit.

Definition at line 34 of file VertexFitKFit.h.

Constructor & Destructor Documentation

VertexFitKFit()

VertexFitKFit

(

void

)

Construct an object with no argument.

Definition at line 28 of file VertexFitKFit.cc.

                            :
  m_BeforeVertex(HepPoint3D(0, 0, 0)),
  m_AfterVertexError(HepSymMatrix(3, 0)),
  m_BeamError(HepSymMatrix(3, 0))
{
  m_CorrelationMode = false;
  m_FlagFitted = false;
  m_FlagKnownVertex = false;
  m_FlagBeam = false;
  m_FlagTube = false;
  m_iTrackTube = -1;
  m_CHIsqVertex = 0;
  m_NecessaryTrackCount = 2;
  m_V_E = HepMatrix(3, 3, 0);
  m_v   = HepMatrix(3, 1, 0);
  m_v_a = HepMatrix(3, 1, 0);
 
  fill_n(m_EachCHIsq, KFitConst::kMaxTrackCount2, 0);
}

Member Function Documentation

addParticle()

enum KFitError::ECode addParticle ( const Particle * particle )

inherited

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 )

inherited

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 )

inherited

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

appendTube()

enum KFitError::ECode appendTube ( void )

private

Add the virtual tube track to m_Tracks just before the internal minimization call.

Returns

error code (zero if success)

Definition at line 861 of file VertexFitKFit.cc.

                          {
  if (!m_FlagTube) return m_ErrorCode = KFitError::kNoError;
 
  if (m_iTrackTube != -1)
  {
    char buf[1024];
    sprintf(buf, "%s:%s(): internal error; duplicated appendTube() call?", __FILE__, __func__);
    B2FATAL(buf);
  }
 
  m_Tracks.push_back(m_TubeTrack);
  m_TrackCount = m_Tracks.size();
  m_iTrackTube = m_TrackCount;
 
  return m_ErrorCode = KFitError::kNoError;
}

calculateNDF()

enum KFitError::ECode calculateNDF ( void )

overrideprivatevirtual

Calculate an NDF of the fit.

Returns

error code (zero if success)

Implements KFitBase.

Definition at line 850 of file VertexFitKFit.cc.

                            {
  if (m_FlagBeam) m_NDF = 2 * m_TrackCount;
  else if (m_FlagTube) m_NDF = 2 * (m_TrackCount - 1) - 1;
  else if (m_FlagKnownVertex) m_NDF = 2 * m_TrackCount;
  else m_NDF = 2 * m_TrackCount - 3;
 
  return m_ErrorCode = KFitError::kNoError;
}

deleteTube()

enum KFitError::ECode deleteTube ( void )

private

Delete the virtual tube track to m_Tracks just after the internal minimization call.

Returns

error code (zero if success)

Definition at line 880 of file VertexFitKFit.cc.

                          {
  if (!m_FlagTube) return m_ErrorCode = KFitError::kNoError;
 
  if (m_iTrackTube == -1)
  {
    char buf[1024];
    sprintf(buf, "%s:%s(): internal error; duplicated deleteTube() call?", __FILE__, __func__);
    B2FATAL(buf);
  }
 
  m_Tracks.pop_back();
  m_TrackCount = m_Tracks.size();
  m_iTrackTube = -1;
 
  return m_ErrorCode = KFitError::kNoError;
}

doFit()

enum KFitError::ECode doFit

(

void

)

Perform a vertex-constraint fit.

Returns

error code (zero if success)

Definition at line 209 of file VertexFitKFit.cc.

                     {
  if (m_FlagTube) this->appendTube();
 
  if (m_FlagBeam) m_ErrorCode = this->doFit4();
  else if (m_FlagKnownVertex) m_ErrorCode = this->doFit5();
  else if (m_CorrelationMode) m_ErrorCode = this->doFit2();
  else
    m_ErrorCode = this->doFit3();
 
  const enum KFitError::ECode tmp_ErrorCode = m_ErrorCode;
 
  if (m_FlagTube) this->deleteTube();
 
  if (tmp_ErrorCode == KFitError::kNoError) m_FlagFitted = true;
 
  return m_ErrorCode = tmp_ErrorCode;
}

doFit1()

enum KFitError::ECode doFit1 ( void )

protectedinherited

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 )

protectedinherited

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

doFit3()

enum KFitError::ECode doFit3 ( void )

private

Perform a standard vertex-constraint fit including IP-tube constraint.

Returns

error code (zero if success)

Definition at line 229 of file VertexFitKFit.cc.

                      {
  // use small Matrix --> No Correlation
  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);
 
  std::vector<double> tmp_each_chisq(m_TrackCount);
  std::vector<double> tmp2_each_chisq(m_TrackCount);
 
  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;
 
      HepMatrix tV_Ein(3, 3, 0);
      chisq = 0;
 
      for (int k = 0; k < m_TrackCount; k++) { // k'th loop start
 
        HepMatrix tD = m_D.sub(2 * k + 1, 2 * (k + 1), KFitConst::kNumber6 * k + 1, KFitConst::kNumber6 * (k + 1)); // 2x6
        HepMatrix tV_D = ((m_V_al_0.sub(KFitConst::kNumber6 * k + 1,
                                        (int)(KFitConst::kNumber6 * (k + 1)))).similarity(tD)).inverse(err_inverse); // 2x2
        if (err_inverse) {
          m_ErrorCode = KFitError::kCannotGetMatrixInverse;
          KFitError::displayError(__FILE__, __LINE__, __func__, m_ErrorCode);
          return m_ErrorCode;
        }
 
        m_V_D.sub(2 * k + 1, 2 * k + 1, tV_D);
        HepMatrix tE = m_E.sub(2 * k + 1, 2 * (k + 1), 1, 3); // 2x3
        tV_Ein += (tE.T()) * tV_D * tE; // 3x3
        HepMatrix tDeltaAl = (m_al_0 - m_al_1).sub(KFitConst::kNumber6 * k + 1, KFitConst::kNumber6 * (k + 1), 1, 1); // 6x1
        HepMatrix td = m_d.sub(2 * k + 1, 2 * (k + 1), 1, 1); // 2x1
        HepMatrix tlam0 = tV_D * (tD * tDeltaAl + td); // 2x2x(2x6x6x1+2x1) = 2x1
        m_lam0.sub(2 * k + 1, 1, tlam0);
        m_EachCHIsq[k] = ((tlam0.T()) * (tD * tDeltaAl + tE * (m_v - m_v_a) + td))(1, 1); // 1x2x(2x6x6x1+2x3x3x1+2x1)
        chisq += m_EachCHIsq[k];
      } // k'th loop over
 
      m_V_E = tV_Ein.inverse(err_inverse);
      if (err_inverse) {
        m_ErrorCode = KFitError::kCannotGetMatrixInverse;
        KFitError::displayError(__FILE__, __LINE__, __func__, m_ErrorCode);
        return m_ErrorCode;
      }
 
      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;
        } else {
          for (int k = 0; k < m_TrackCount; k++) m_EachCHIsq[k] = tmp_each_chisq[k];
          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 {
        for (int k = 0; k < m_TrackCount; k++) tmp_each_chisq[k] = m_EachCHIsq[k];
        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) {
 
      for (int k = 0; k < m_TrackCount; k++) tmp2_each_chisq[k] = m_EachCHIsq[k];
      tmp2_chisq = chisq;
      tmp2_v_a   = m_v_a;
      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) {
        for (int k = 0; k < m_TrackCount; k++) m_EachCHIsq[k] = tmp2_each_chisq[k];
        chisq   = tmp2_chisq;
        m_v_a   = tmp2_v_a;
        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 {
        for (int k = 0; k < m_TrackCount; k++) tmp2_each_chisq[k] = m_EachCHIsq[k];
        tmp2_chisq = chisq;
        tmp2_v_a   = m_v_a;
        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;
      }
    }
  } // 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;
 
  return m_ErrorCode = KFitError::kNoError;
}

doFit4()

enum KFitError::ECode doFit4 ( void )

private

Perform a IP-ellipsoid and vertex-constraint fit.

Returns

error code (zero if success)

Definition at line 396 of file VertexFitKFit.cc.

                      {
  // included beam position constraint (only no correlation)
  if (m_ErrorCode != KFitError::kNoError) return m_ErrorCode;
 
  if (m_TrackCount < m_NecessaryTrackCount - 1)
  {
    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;
 
  m_al_a = m_al_0;
  HepMatrix tmp_al_a(m_al_a);
 
  HepMatrix tmp_D(m_D), tmp_E(m_E);
  HepMatrix tmp_lam(m_lam);
 
  // vertex
  m_v[0][0] = m_BeforeVertex.x();
  m_v[1][0] = m_BeforeVertex.y();
  m_v[2][0] = m_BeforeVertex.z();
 
  std::vector<double> tmp_each_chisq(m_TrackCount);
  double tmp_vertex_chisq = 1.e+30; // An init-value is not needed but the C++ compiler requires the init-value.
 
  // to avoid overestimation of vertex-z error.
  bool it_flag = false;
 
  for (int i = 0; i < KFitConst::kMaxIterationCount ; i++)
  {
 
    if (makeCoreMatrix() != KFitError::kNoError) return m_ErrorCode;
 
    chisq = 0;
 
    HepMatrix tV_Dtin = m_V_al_0.similarity(m_D) + m_BeamError.similarity(m_E);
    HepMatrix tV_Dt = tV_Dtin.inverse(err_inverse);
    if (err_inverse) {
      m_ErrorCode = KFitError::kCannotGetMatrixInverse;
      KFitError::displayError(__FILE__, __LINE__, __func__, m_ErrorCode);
      return m_ErrorCode;
    }
    m_lam = tV_Dt * (m_D * (m_al_0 - m_al_1) + m_E * (m_v - m_v_a) + m_d); // (2*nTrk)x1
    for (int k = 0; k < m_TrackCount; k++) {
      HepMatrix tD = m_D.sub(2 * k + 1, 2 * (k + 1), KFitConst::kNumber6 * k + 1, KFitConst::kNumber6 * (k + 1)); // 2x6
      HepMatrix tDeltaAl = (m_al_0 - m_al_1).sub(KFitConst::kNumber6 * k + 1, KFitConst::kNumber6 * (k + 1), 1, 1); // 6x1
      HepMatrix td = m_d.sub(2 * k + 1, 2 * (k + 1), 1, 1); // 2x1
      HepMatrix tE = m_E.sub(2 * k + 1, 2 * (k + 1), 1, 3); // 2x3
      chisq += ((m_lam.sub(2 * k + 1, 2 * (k + 1), 1, 1).T()) * (tD * tDeltaAl + tE * (m_v - m_v_a) + td))(1,
               1); // 1x2x(2x6x6x1+2x3x3x1+2x1)
      m_EachCHIsq[k] = (m_lam.sub(2 * k + 1, 2 * (k + 1), 1, 1).T() * tD * m_V_al_0.sub(KFitConst::kNumber6 * k + 1,
                        KFitConst::kNumber6 * (k + 1)) * (tD.T()) * m_lam.sub(2 * k + 1, 2 * (k + 1), 1, 1))(1, 1);
    }
 
    m_CHIsqVertex = (m_lam.T() * m_E * m_BeamError * (m_E.T()) * m_lam)(1, 1);
    m_al_a = m_al_1;
    m_v_a  = m_v - m_BeamError * (m_E.T()) * m_lam;
    m_al_1 = m_al_0 - m_V_al_0 * (m_D.T()) * m_lam;
 
    if (tmp_chisq <= chisq && it_flag) {
      if (i == 0) {
        m_ErrorCode = KFitError::kBadInitialCHIsq;
      } else {
        for (int k = 0; k < m_TrackCount; k++) m_EachCHIsq[k] = tmp_each_chisq[k];
        m_CHIsqVertex = tmp_vertex_chisq;
        chisq  = tmp_chisq;
        m_lam  = tmp_lam;
        m_E    = tmp_E;
        m_D    = tmp_D;
        m_al_a = tmp_al_a;
      }
      break;
    } else {
      if (tmp_chisq <= chisq) it_flag = true;
      for (int k = 0; k < m_TrackCount; k++) tmp_each_chisq[k] = m_EachCHIsq[k];
      tmp_vertex_chisq = m_CHIsqVertex;
      tmp_chisq = chisq;
      tmp_lam   = m_lam;
      tmp_E     = m_E;
      tmp_D     = m_D;
      tmp_al_a  = m_al_a;
      if (i == KFitConst::kMaxIterationCount - 1) {
        m_FlagOverIteration = true;
      }
    }
  }
 
 
  if (m_ErrorCode != KFitError::kNoError) return m_ErrorCode;
 
  m_al_1 = m_al_0 - m_V_al_0 * (m_D.T()) * m_lam;
  m_v_a  = m_v - m_BeamError * (m_E.T()) * m_lam;
  HepMatrix tV_Dtin = m_V_al_0.similarity(m_D) + m_BeamError.similarity(m_E);
  m_V_Dt = tV_Dtin.inverse(err_inverse);
  if (err_inverse)
  {
    m_ErrorCode = KFitError::kCannotGetMatrixInverse;
    KFitError::displayError(__FILE__, __LINE__, __func__, m_ErrorCode);
    return m_ErrorCode;
  }
 
  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_BeamError * (m_E.T()) * m_V_Dt * m_D * m_V_al_0;
  // m_V_v is m_V_E
  // --> need to replace m_V_E for my implementation.
  m_V_E = m_BeamError - m_BeamError * (m_E.T()) * m_V_Dt * m_E * m_BeamError;
 
  if (prepareOutputMatrix() != KFitError::kNoError) return m_ErrorCode;
 
  m_CHIsq = chisq;
 
  return m_ErrorCode = KFitError::kNoError;
}

doFit5()

enum KFitError::ECode doFit5 ( void )

private

Perform a fixed-vertex-position fit mainly for slow pion.

Returns

error code (zero if success)

Definition at line 520 of file VertexFitKFit.cc.

                      {
  // known vertex --> do not find vertex. (only no correlation)
  if (m_ErrorCode != KFitError::kNoError) return m_ErrorCode;
 
  if (m_TrackCount < m_NecessaryTrackCount - 1)
  {
    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;
 
  m_al_a = m_al_0;
  HepMatrix tmp_al_a(m_al_a);
 
  HepMatrix tmp_al_0(m_al_1);
  HepMatrix tmp_V_al_0(m_V_al_1);
 
  std::vector<double> tmp_each_chisq(m_TrackCount);
 
  for (int i = 0; i < KFitConst::kMaxIterationCount; i++)
  {
 
    if (makeCoreMatrix() != KFitError::kNoError) return m_ErrorCode;
 
    chisq = 0;
 
    for (int k = 0; k < m_TrackCount; k++) {
      HepMatrix tD = m_D.sub(2 * k + 1, 2 * (k + 1), KFitConst::kNumber6 * k + 1, KFitConst::kNumber6 * (k + 1)); // 2x6
      HepMatrix tV_D = ((m_V_al_0.sub(KFitConst::kNumber6 * k + 1,
                                      (int)(KFitConst::kNumber6 * (k + 1)))).similarity(tD)).inverse(err_inverse); // 2x2
      if (err_inverse) {
        m_ErrorCode = KFitError::kCannotGetMatrixInverse;
        KFitError::displayError(__FILE__, __LINE__, __func__, m_ErrorCode);
        return m_ErrorCode;
      }
      m_V_D.sub(2 * k + 1, 2 * k + 1, tV_D);
 
      HepMatrix tDeltaAl = (m_al_0 - m_al_1).sub(KFitConst::kNumber6 * k + 1, KFitConst::kNumber6 * (k + 1), 1, 1); // 6x1
      HepMatrix td = m_d.sub(2 * k + 1, 2 * (k + 1), 1, 1); // 2x1
      HepMatrix tlam = tV_D * (tD * tDeltaAl + td); // 2x2x(2x6x6x1+2x1) = 2x1
      m_lam.sub(2 * k + 1, 1, tlam);
      m_EachCHIsq[k] = ((tlam.T()) * (tD * tDeltaAl + td))(1, 1); // 1x2x(2x6x6x1+2x1)
      chisq += m_EachCHIsq[k];
    }
 
    m_al_a   = m_al_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;
      } else {
        for (int k = 0; k < m_TrackCount; k++) m_EachCHIsq[k] = tmp_each_chisq[k];
        chisq    = tmp_chisq;
        m_al_1   = tmp_al_0;
        m_V_al_1 = tmp_V_al_0;
        m_al_a   = tmp_al_a;
      }
      break;
    } else {
      for (int k = 0; k < m_TrackCount; k++) tmp_each_chisq[k] = m_EachCHIsq[k];
      tmp_chisq  = chisq;
      tmp_al_0   = m_al_1;
      tmp_V_al_0 = m_V_al_1;
      tmp_al_a   = m_al_a;
      if (i == KFitConst::kMaxIterationCount - 1) {
        m_FlagOverIteration = true;
      }
    }
  }
 
 
  if (m_ErrorCode != KFitError::kNoError) return m_ErrorCode;
 
  if (prepareOutputMatrix() != KFitError::kNoError) return m_ErrorCode;
 
  m_CHIsq = chisq;
 
  return m_ErrorCode = KFitError::kNoError;
}

getCHIsq()

double getCHIsq ( void ) const

virtualinherited

Get a chi-square of the fit.

Returns

chi-square of the fit

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

Definition at line 121 of file KFitBase.cc.

{
  return m_CHIsq;
}

getCHIsqVertex()

double getCHIsqVertex

(

void

)

const

Get a chi-square of the fit excluding IP-constraint part.

Returns

chi-square of the fit excluding IP-constraint part.

Definition at line 140 of file VertexFitKFit.cc.

{
  // only m_FlagBeam = 1
  return m_CHIsqVertex;
}

getCorrelation()

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

virtualinherited

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

inherited

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

inherited

Get a magnetic field.

Returns

magnetic field

Definition at line 128 of file KFitBase.cc.

{
  return m_MagneticField;
}

getNDF()

int getNDF ( void ) const

virtualinherited

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

inherited

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

overridevirtual

Get a chi-square of the track.

Parameters

id

track id

Returns

chi-square of the track

Reimplemented from KFitBase.

Definition at line 156 of file VertexFitKFit.cc.

{
  if (!isTrackIDInRange(id)) return -1;
 
  if (!m_FlagKnownVertex && !m_FlagBeam && m_CorrelationMode) {
    return KFitBase::getTrackCHIsq(id);
  }
 
  return m_EachCHIsq[id];
}

getTrackCount()

int getTrackCount ( void ) const

inherited

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

inherited

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

inherited

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();
}

getTrackPartCHIsq()

double getTrackPartCHIsq

(

void

)

const

Get a sum of the chi-square associated to the input tracks.

The return value should be the same as the one from getCHIsqVertex().

Returns

sum of the chi-square associated to the input tracks

Definition at line 169 of file VertexFitKFit.cc.

{
  if (m_ErrorCode != KFitError::kNoError) {
    KFitError::displayError(__FILE__, __LINE__, __func__, m_ErrorCode);
    return -1;
  }
 
  if (m_TrackCount == 0) {
    KFitError::displayError(__FILE__, __LINE__, __func__, KFitError::kBadTrackSize);
    return -1;
  }
 
  double chisq = 0.0;
  for (int i = 0; i < m_TrackCount; i++) {
    const double i_chisq = this->getTrackCHIsq(i);
    chisq += i_chisq;
  }
 
  return chisq;
}

getTrackPartNDF()

int getTrackPartNDF

(

void

)

const

Get an NDF relevant to the getTrackPartCHIsq().

Returns

NDF relevant to the getTrackPartCHIsq()

Definition at line 192 of file VertexFitKFit.cc.

{
  if (m_ErrorCode != KFitError::kNoError) {
    KFitError::displayError(__FILE__, __LINE__, __func__, m_ErrorCode);
    return 0;
  }
 
  if (m_TrackCount == 0) {
    KFitError::displayError(__FILE__, __LINE__, __func__, KFitError::kBadTrackSize);
    return 0;
  }
 
  return m_TrackCount * 2 - 2;
}

getTrackPosition()

const HepPoint3D getTrackPosition ( const int id ) const

inherited

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();
}

getTrackVertexError()

const HepMatrix getTrackVertexError

(

const int

id

)

const

Get a vertex error matrix of the track.

Parameters

id

track id

Returns

vertex error matrix

Definition at line 148 of file VertexFitKFit.cc.

{
  if (!isTrackIDInRange(id)) return HepMatrix(3, KFitConst::kNumber7, 0);
  return m_AfterTrackVertexError[id];
}

getVertex()

const HepPoint3D getVertex

(

const int

flag = KFitConst::kAfterFit

)

const

Get a vertex position.

Parameters

flag	KFitConst::kBeforeFit or KFitConst::kAfterFit

Returns

vertex position

Definition at line 115 of file VertexFitKFit.cc.

{
  if (flag == KFitConst::kAfterFit && !isFitted()) return HepPoint3D();
 
  switch (flag) {
    case KFitConst::kBeforeFit:
      return m_BeforeVertex;
 
    case KFitConst::kAfterFit:
      return m_AfterVertex;
 
    default:
      KFitError::displayError(__FILE__, __LINE__, __func__, KFitError::kOutOfRange);
      return HepPoint3D();
  }
}

getVertexError()

const HepSymMatrix getVertexError

(

void

)

const

Get a fitted vertex error matrix.

Returns

vertex error matrix

Definition at line 134 of file VertexFitKFit.cc.

{
  return m_AfterVertexError;
}

isFitted()

bool isFitted ( void ) const

inherited

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 )

staticprotectedinherited

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

protectedinherited

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()

enum KFitError::ECode makeCoreMatrix ( void )

overrideprivatevirtual

Build matrices using the kinematical constraint.

Returns

error code (zero if success)

Implements KFitBase.

Definition at line 756 of file VertexFitKFit.cc.

                              {
  // vertex fit
  for (int i = 0; i < m_TrackCount; i++)
  {
    double S, U;
    double sininv;
 
    double px = m_al_1[i * KFitConst::kNumber6 + 0][0];
    double py = m_al_1[i * KFitConst::kNumber6 + 1][0];
    double pz = m_al_1[i * KFitConst::kNumber6 + 2][0];
    double x  = m_al_1[i * KFitConst::kNumber6 + 3][0];
    double y  = m_al_1[i * KFitConst::kNumber6 + 4][0];
    double z  = m_al_1[i * KFitConst::kNumber6 + 5][0];
    double a  = m_property[i][2];
 
    double pt =  sqrt(px * px + py * py);
    if (pt == 0) {
      m_ErrorCode = KFitError::kDivisionByZero;
      KFitError::displayError(__FILE__, __LINE__, __func__, m_ErrorCode);
      return m_ErrorCode;
    }
 
    double invPt   = 1. / pt;
    double invPt2  = invPt * invPt;
    double dlx  =  m_v_a[0][0] - x;
    double dly  =  m_v_a[1][0] - y;
    double dlz  =  m_v_a[2][0] - z;
    double a1   = -dlx * py + dly * px;
    double a2   =  dlx * px + dly * py;
    double r2d2 =  dlx * dlx + dly * dly;
    double Rx   =  dlx - 2.*px * a2 * invPt2;
    double Ry   =  dly - 2.*py * a2 * invPt2;
 
    if (a != 0) { // charged
 
      double B = a * a2 * invPt2;
      if (fabs(B) > 1) {
        m_ErrorCode = KFitError::kCannotGetARCSIN;
        B2DEBUG(10, "KFitError: Cannot calculate arcsin");
        //KFitError::displayError(__FILE__, __LINE__, __func__, m_ErrorCode);
        return m_ErrorCode;
      }
      // sin^(-1)(B)
      sininv = asin(B);
      double tmp0 = 1.0 - B * B;
      if (tmp0 == 0) {
        m_ErrorCode = KFitError::kDivisionByZero;
        KFitError::displayError(__FILE__, __LINE__, __func__, m_ErrorCode);
        return m_ErrorCode;
      }
      // 1/sqrt(1-B^2)
      double sqrtag = 1.0 / sqrt(tmp0);
      S = sqrtag * invPt2;
      U = dlz - pz * sininv / a;
 
    } else { // neutral
 
      sininv = 0.0;
      S = invPt2;
      U = dlz - pz * a2 * invPt2;
    }
 
    // d
    m_d[i * 2 + 0][0] = a1 - 0.5 * a * r2d2;
    m_d[i * 2 + 1][0] = U * pt;
 
    // D
    m_D[i * 2 + 0][i * KFitConst::kNumber6 + 0] =  dly;
    m_D[i * 2 + 0][i * KFitConst::kNumber6 + 1] = -dlx;
    m_D[i * 2 + 0][i * KFitConst::kNumber6 + 2] =  0.0;
    m_D[i * 2 + 0][i * KFitConst::kNumber6 + 3] =  py + a * dlx;
    m_D[i * 2 + 0][i * KFitConst::kNumber6 + 4] = -px + a * dly;
    m_D[i * 2 + 0][i * KFitConst::kNumber6 + 5] =  0.0;
    m_D[i * 2 + 1][i * KFitConst::kNumber6 + 0] = -pz * pt * S * Rx + U * px * invPt;
    m_D[i * 2 + 1][i * KFitConst::kNumber6 + 1] = -pz * pt * S * Ry + U * py * invPt;
    m_D[i * 2 + 1][i * KFitConst::kNumber6 + 2] = a != 0 ? -sininv * pt / a : -a2 * invPt;
    m_D[i * 2 + 1][i * KFitConst::kNumber6 + 3] =  px * pz * pt * S;
    m_D[i * 2 + 1][i * KFitConst::kNumber6 + 4] =  py * pz * pt * S;
    m_D[i * 2 + 1][i * KFitConst::kNumber6 + 5] = -pt;
 
    // E
    m_E[i * 2 + 0][0] = -py - a * dlx;
    m_E[i * 2 + 0][1] =  px - a * dly;
    m_E[i * 2 + 0][2] =  0.0;
    m_E[i * 2 + 1][0] = -px * pz * pt * S;
    m_E[i * 2 + 1][1] = -py * pz * pt * S;
    m_E[i * 2 + 1][2] =  pt;
  }
 
  return m_ErrorCode = KFitError::kNoError;
}

makeError1() [1/2]

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

staticprotectedinherited

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]

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

staticprotectedinherited

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()

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

staticprotectedinherited

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]

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

staticprotectedinherited

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]

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

staticprotectedinherited

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()

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

staticprotectedinherited

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 )

protectedvirtualinherited

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 (const 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()

enum KFitError::ECode prepareInputMatrix ( void )

overrideprivatevirtual

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

Returns

error code (zero if success)

Implements KFitBase.

Definition at line 612 of file VertexFitKFit.cc.

                                  {
  if (!m_CorrelationMode || m_FlagBeam || m_FlagKnownVertex)
  {
    if (m_TrackCount > KFitConst::kMaxTrackCount2) {
      m_ErrorCode = KFitError::kBadTrackSize;
      KFitError::displayError(__FILE__, __LINE__, __func__, m_ErrorCode);
      return m_ErrorCode;
    }
  } else
  {
    if (m_TrackCount > KFitConst::kMaxTrackCount) {
      m_ErrorCode = KFitError::kBadTrackSize;
      KFitError::displayError(__FILE__, __LINE__, __func__, m_ErrorCode);
      return m_ErrorCode;
    }
  }
 
 
  int index = 0;
  HepMatrix    tmp_al_0(KFitConst::kNumber6 * m_TrackCount, 1, 0);
  HepSymMatrix tmp_V_al_0(KFitConst::kNumber6 * m_TrackCount, 0);
  HepMatrix    tmp_property(m_TrackCount, 3, 0);
 
 
  for (const auto& track : m_Tracks)
  {
    // momentum x,y,z and position x,y,z
    for (int j = 0; j < KFitConst::kNumber6; j++)
      tmp_al_0[index * KFitConst::kNumber6 + j][0] = track.getFitParameter(j, KFitConst::kBeforeFit);
    // these error
    tmp_V_al_0.sub(index * KFitConst::kNumber6 + 1, track.getFitError(KFitConst::kBeforeFit));
    // charge , mass , a
    tmp_property[index][0] =  track.getCharge();
    tmp_property[index][1] =  track.getMass();
    const double c = Const::speedOfLight * 1e-4;
    tmp_property[index][2] = -c * m_MagneticField * track.getCharge();
    index++;
  }
 
  // error between tarck and track
  m_V_al_0 = tmp_V_al_0;
  if (!m_FlagKnownVertex && !m_FlagBeam && m_CorrelationMode)
  {
    if (m_FlagCorrelation) {
      this->prepareCorrelation();
      if (m_ErrorCode != KFitError::kNoError) {
        KFitError::displayError(__FILE__, __LINE__, __func__, m_ErrorCode);
        return m_ErrorCode;
      }
    }
  }
 
  // vertex
  m_v_a[0][0] = m_BeforeVertex.x();
  m_v_a[1][0] = m_BeforeVertex.y();
  m_v_a[2][0] = m_BeforeVertex.z();
 
  // set member matrix
  m_al_0     = tmp_al_0;
  m_al_1     = m_al_0;
  m_property = tmp_property;
 
  // define size of matrix
  m_V_al_1 = HepMatrix(KFitConst::kNumber6 * m_TrackCount, KFitConst::kNumber6 * m_TrackCount, 0);
  m_D    = m_V_al_1.sub(1, m_TrackCount * 2, 1, KFitConst::kNumber6 * m_TrackCount);
  m_E    = m_V_al_1.sub(1, m_TrackCount * 2, 1, 3);
  m_d    = m_V_al_1.sub(1, m_TrackCount * 2, 1, 1);
  m_V_D  = m_V_al_1.sub(1, m_TrackCount * 2, 1, m_TrackCount * 2);
  m_lam  = m_V_al_1.sub(1, m_TrackCount * 2, 1, 1);
  m_lam0 = m_V_al_1.sub(1, m_TrackCount * 2, 1, 1);
  m_V_Dt = m_V_al_1.sub(1, m_TrackCount * 2, 1, m_TrackCount * 2);
  m_Cov_v_al_1 = m_V_al_1.sub(1, 3, 1, KFitConst::kNumber6 * m_TrackCount);
 
  return m_ErrorCode = KFitError::kNoError;
}

prepareInputSubMatrix()

enum KFitError::ECode prepareInputSubMatrix ( void )

overrideprivatevirtual

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

Returns

error code (zero if success)

Implements KFitBase.

Definition at line 690 of file VertexFitKFit.cc.

                                     {
  // vertex
  for (int i = 0; i < 3; i++)
  {
    m_v[i][0] = m_v_a[i][0];
  }
  return m_ErrorCode = KFitError::kNoError;
}

prepareOutputMatrix()

enum KFitError::ECode prepareOutputMatrix ( void )

overrideprivatevirtual

Build an output error matrix.

Returns

error code (zero if success)

Implements KFitBase.

Definition at line 701 of file VertexFitKFit.cc.

                                   {
  Hep3Vector h3v;
  unsigned index = 0;
 
  for (auto& pdata : m_Tracks)
  {
    // tracks
    // momentum
    h3v.setX(m_al_1[index * KFitConst::kNumber6 + 0][0]);
    h3v.setY(m_al_1[index * KFitConst::kNumber6 + 1][0]);
    h3v.setZ(m_al_1[index * KFitConst::kNumber6 + 2][0]);
    pdata.setMomentum(HepLorentzVector(h3v, sqrt(h3v.mag2() + pdata.getMass()*pdata.getMass())), KFitConst::kAfterFit);
    // position
    pdata.setPosition(HepPoint3D(
                        m_al_1[index * KFitConst::kNumber6 + 3][0],
                        m_al_1[index * KFitConst::kNumber6 + 4][0],
                        m_al_1[index * KFitConst::kNumber6 + 5][0]), KFitConst::kAfterFit);
    // error of the tracks
    pdata.setError(makeError1(pdata.getMomentum(),
                              m_V_al_1.sub(
                                index    * KFitConst::kNumber6 + 1,
                                (index + 1)*KFitConst::kNumber6,
                                index    * KFitConst::kNumber6 + 1,
                                (index + 1)*KFitConst::kNumber6)),
                   KFitConst::kAfterFit);
    if (m_ErrorCode != KFitError::kNoError) break;
    index++;
  }
 
  // vertex
  m_AfterVertex.setX(m_v_a[0][0]);
  m_AfterVertex.setY(m_v_a[1][0]);
  m_AfterVertex.setZ(m_v_a[2][0]);
 
  // error of the vertex
  for (int i = 0; i < 3; i++) for (int j = i; j < 3; j++)
    {
      m_AfterVertexError[i][j] = m_V_E[i][j];
    }
 
  // error between vertex and tracks
  for (int i = 0; i < m_TrackCount; i++)
  {
    HepMatrix hm(3, KFitConst::kNumber6, 0);
    for (int j = 0; j < 3; j++) for (int k = 0; k < KFitConst::kNumber6; k++) {
        hm[j][k] = m_Cov_v_al_1[j][KFitConst::kNumber6 * i + k];
      }
    m_AfterTrackVertexError.push_back(makeError2(m_Tracks[i].getMomentum(), hm));
  }
 
  return m_ErrorCode = KFitError::kNoError;
}

setCorrelation()

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

virtualinherited

Set a correlation matrix.

Not intended for end user's use.

Parameters

c	(7x7) correlation matrix

Returns

error code (zero if success)

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

setCorrelationMode()

enum KFitError::ECode setCorrelationMode

(

const bool

m

)

Tell the object to perform a fit with track correlations.

Parameters

m	true for with correlation, false for otherwise

Returns

error code (zero if success)

Definition at line 107 of file VertexFitKFit.cc.

                                              {
  m_CorrelationMode = m;
 
  return m_ErrorCode = KFitError::kNoError;
}

setInitialVertex() [1/2]

enum KFitError::ECode setInitialVertex

(

const HepPoint3D &

v

)

Set an initial vertex point for the vertex-vertex constraint fit.

Parameters

v	initial vertex point

Returns

error code (zero if success)

Definition at line 52 of file VertexFitKFit.cc.

                                                   {
  m_BeforeVertex = v;
 
  return m_ErrorCode = KFitError::kNoError;
}

setInitialVertex() [2/2]

enum KFitError::ECode setInitialVertex

(

const ROOT::Math::XYZVector &

v

)

Set an initial vertex point for the mass-vertex constraint fit.

Parameters

v	initial vertex point

Returns

error code (zero if success)

Definition at line 58 of file VertexFitKFit.cc.

{
  m_BeforeVertex = ROOTToCLHEP::getPoint3D(v);
  m_ErrorCode = KFitError::kNoError;
  return m_ErrorCode;
}

setIpProfile()

enum KFitError::ECode setIpProfile	(	const HepPoint3D &	ip,
		const CLHEP::HepSymMatrix &	ipe )

Set an IP-ellipsoid shape for the vertex constraint fit.

Parameters

ip	IP position
ipe	error matrix of the IP

Returns

error code (zero if success)

Definition at line 66 of file VertexFitKFit.cc.

                                                                         {
  if (m_FlagTube)
  {
    char buf[1024];
    sprintf(buf, "%s:%s(): already constrained to IPtube", __FILE__, __func__);
    B2FATAL(buf);
  }
 
  m_FlagBeam = true;
  m_BeforeVertex = ip;
  m_BeamError = ipe;
 
  return m_ErrorCode = KFitError::kNoError;
}

setIpTubeProfile()

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

Set a virtual IP-tube track for the vertex constraint fit.

Parameters

p	Lorentz vector of the virtual IP-tube track
x	IP position
e	error matrix of IP-tube track and IP position
q	charge of the virtual IP-tube track

Returns

error code (zero if success)

Definition at line 83 of file VertexFitKFit.cc.

                                                                                                                     {
  if (m_FlagBeam)
  {
    char buf[1024];
    sprintf(buf, "%s:%s(): already constrained to IP", __FILE__, __func__);
    B2FATAL(buf);
  }
 
  m_FlagTube = true;
  m_TubeTrack = KFitTrack(p, x, e, q);
 
  return m_ErrorCode = KFitError::kNoError;
}

setKnownVertex()

enum KFitError::ECode setKnownVertex

(

const bool

flag = true

)

Tell the object to perform a fit with vertex position fixed.

Parameters

flag	true for fixed vertex, false for otherwise

Returns

error code (zero if success)

Definition at line 99 of file VertexFitKFit.cc.

                                             {
  m_FlagKnownVertex = flag;
 
  return m_ErrorCode = KFitError::kNoError;
}

setMagneticField()

enum KFitError::ECode setMagneticField ( const double mf )

inherited

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 )

virtualinherited

Indicate no correlation between tracks.

Not intended for end user's use.

Returns

error code (zero if success)

Definition at line 85 of file KFitBase.cc.

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

updateMother()

enum KFitError::ECode updateMother

(

Particle *

mother

)

Update mother particle.

Parameters

[in]

mother

Mother particle.

Definition at line 897 of file VertexFitKFit.cc.

{
  MakeMotherKFit kmm;
  kmm.setMagneticField(m_MagneticField);
  unsigned n = getTrackCount();
  for (unsigned i = 0; i < n; ++i) {
    kmm.addTrack(getTrackMomentum(i), getTrackPosition(i), getTrackError(i),
                 getTrack(i).getCharge());
    kmm.setTrackVertexError(getTrackVertexError(i));
    for (unsigned j = i + 1; j < n; ++j) {
      kmm.setCorrelation(getCorrelation(i, j));
    }
  }
  kmm.setVertex(getVertex());
  kmm.setVertexError(getVertexError());
  m_ErrorCode = kmm.doMake();
  if (m_ErrorCode != KFitError::kNoError)
    return m_ErrorCode;
  double chi2 = getCHIsq();
  int ndf = getNDF();
  double prob = TMath::Prob(chi2, ndf);
  //
  bool haschi2 = mother->hasExtraInfo("chiSquared");
  if (haschi2) {
    mother->setExtraInfo("chiSquared", chi2);
    mother->setExtraInfo("ndf", ndf);
  } else {
    mother->addExtraInfo("chiSquared", chi2);
    mother->addExtraInfo("ndf", ndf);
  }
 
  mother->updateMomentum(
    CLHEPToROOT::getLorentzVector(kmm.getMotherMomentum()),
    CLHEPToROOT::getXYZVector(kmm.getMotherPosition()),
    CLHEPToROOT::getTMatrixFSym(kmm.getMotherError()),
    prob);
  m_ErrorCode = KFitError::kNoError;
  return m_ErrorCode;
}

Member Data Documentation

m_AfterTrackVertexError

std::vector<CLHEP::HepMatrix> m_AfterTrackVertexError

private

Array of vertex error matrices after the fit.

Definition at line 172 of file VertexFitKFit.h.

m_AfterVertex

HepPoint3D m_AfterVertex

private

Vertex position after the fit.

Definition at line 168 of file VertexFitKFit.h.

m_AfterVertexError

CLHEP::HepSymMatrix m_AfterVertexError

private

Vertex error matrix after the fit.

Definition at line 170 of file VertexFitKFit.h.

m_al_0

CLHEP::HepMatrix m_al_0

protectedinherited

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

protectedinherited

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

protectedinherited

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

Definition at line 261 of file KFitBase.h.

m_BeamError

CLHEP::HepSymMatrix m_BeamError

private

Error matrix modeling the IP ellipsoid.

Definition at line 177 of file VertexFitKFit.h.

m_BeforeCorrelation

std::vector<CLHEP::HepMatrix> m_BeforeCorrelation

protectedinherited

Container of input correlation matrices.

Definition at line 251 of file KFitBase.h.

m_BeforeVertex

HepPoint3D m_BeforeVertex

private

Vertex position before the fit.

Definition at line 165 of file VertexFitKFit.h.

m_CHIsq

double m_CHIsq

protectedinherited

chi-square of the fit.

Definition at line 297 of file KFitBase.h.

m_CHIsqVertex

double m_CHIsqVertex

private

chi-square of the fit excluding IP-constraint part.

Definition at line 162 of file VertexFitKFit.h.

m_CorrelationMode

bool m_CorrelationMode

private

Flag controlled by setCorrelationMode().

Definition at line 158 of file VertexFitKFit.h.

m_Cov_v_al_1

CLHEP::HepMatrix m_Cov_v_al_1

protectedinherited

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

Definition at line 291 of file KFitBase.h.

m_D

CLHEP::HepMatrix m_D

protectedinherited

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

Definition at line 266 of file KFitBase.h.

m_d

CLHEP::HepMatrix m_d

protectedinherited

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

Definition at line 268 of file KFitBase.h.

m_E

CLHEP::HepMatrix m_E

protectedinherited

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

Definition at line 279 of file KFitBase.h.

m_EachCHIsq

double m_EachCHIsq[KFitConst::kMaxTrackCount2]

private

Container of chi-square's of the input tracks.

Definition at line 160 of file VertexFitKFit.h.

m_ErrorCode

enum KFitError::ECode m_ErrorCode

protectedinherited

Error code.

Definition at line 243 of file KFitBase.h.

m_FlagBeam

bool m_FlagBeam

private

Flag if to perform IP-ellipsoid constraint fit.

Definition at line 175 of file VertexFitKFit.h.

m_FlagCorrelation

bool m_FlagCorrelation

protectedinherited

Flag whether a correlation among tracks exists.

Definition at line 306 of file KFitBase.h.

m_FlagFitted

bool m_FlagFitted

protectedinherited

Flag to indicate if the fit is performed and succeeded.

Definition at line 245 of file KFitBase.h.

m_FlagKnownVertex

bool m_FlagKnownVertex

private

Flag controlled by setKnownVertex().

Definition at line 180 of file VertexFitKFit.h.

m_FlagOverIteration

bool m_FlagOverIteration

protectedinherited

Flag whether the iteration count exceeds the limit.

Definition at line 308 of file KFitBase.h.

m_FlagTube

bool m_FlagTube

private

Flag if to perform IP-tube constraint fit.

Definition at line 183 of file VertexFitKFit.h.

m_iTrackTube

int m_iTrackTube

private

ID of the virtual tube track in the m_Tracks.

Definition at line 185 of file VertexFitKFit.h.

m_lam

CLHEP::HepMatrix m_lam

protectedinherited

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

Definition at line 276 of file KFitBase.h.

m_lam0

CLHEP::HepMatrix m_lam0

protectedinherited

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

Definition at line 283 of file KFitBase.h.

m_MagneticField

double m_MagneticField

protectedinherited

Magnetic field.

Definition at line 311 of file KFitBase.h.

m_NDF

int m_NDF

protectedinherited

NDF of the fit.

Definition at line 295 of file KFitBase.h.

m_NecessaryTrackCount

int m_NecessaryTrackCount

protectedinherited

Number needed tracks to perform fit.

Definition at line 303 of file KFitBase.h.

m_property

CLHEP::HepMatrix m_property

protectedinherited

Container of charges and masses.

Definition at line 263 of file KFitBase.h.

m_TrackCount

int m_TrackCount

protectedinherited

Number of tracks.

Definition at line 301 of file KFitBase.h.

m_Tracks

std::vector<KFitTrack> m_Tracks

protectedinherited

Container of input tracks.

Definition at line 249 of file KFitBase.h.

m_TubeTrack

KFitTrack m_TubeTrack

private

Entity of the virtual IP-tube track.

Definition at line 187 of file VertexFitKFit.h.

m_v

CLHEP::HepMatrix m_v

protectedinherited

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

protectedinherited

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

protectedinherited

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

protectedinherited

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

protectedinherited

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

protectedinherited

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

protectedinherited

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/VertexFitKFit.h
• analysis/VertexFitting/KFit/src/VertexFitKFit.cc