BKLMTrack.cc

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
/* Own header. */
#include "klm/dataobjects/bklm/BKLMTrack.h"
 
using namespace Belle2;
 
BKLMTrack::BKLMTrack():
  RelationsObject(),
  m_Valid(false),
  m_Good(false),
  m_Chi2(0.0),
  m_NumHit(0)
{
  for (int ii = 0 ; ii < 4; ii ++) {
    m_TrackParam[0] = 0.0;
    m_LocalTrackParam[ii] = 0.0;
    for (int jj = 0 ; jj < 4; jj ++) {
      m_TrackParamErr[ii][jj] =  0.0;
      m_LocalTrackParamErr[ii][jj] = 0.0;
    }
  }
}
 
BKLMTrack::BKLMTrack(const BKLMTrack& track) :
  RelationsObject(track),
  m_Valid(track.m_Valid),
  m_Good(track.m_Good),
  m_Chi2(track.m_Chi2),
  m_NumHit(track.m_NumHit)
{
 
  for (int ii = 0 ; ii < 4; ii ++) {
    m_TrackParam[ii] = track.m_TrackParam[ii];
    m_LocalTrackParam[ii] = track.m_LocalTrackParam[ii];
    for (int jj = 0 ; jj < 4; jj ++) {
      m_TrackParamErr[ii][jj] = track.m_TrackParamErr[ii][jj];
      m_LocalTrackParamErr[ii][jj] = track.m_LocalTrackParamErr[ii][jj];
    }
  }
}
 
BKLMTrack& BKLMTrack::operator=(const BKLMTrack& track)
{
  m_Valid = track.m_Valid;
  m_Good = track.m_Good;
  m_Chi2 = track.m_Chi2;
  m_NumHit = track.m_NumHit;
 
  for (int ii = 0 ; ii < 4; ii ++) {
    m_TrackParam[ii] = track.m_TrackParam[ii];
    m_LocalTrackParam[ii] = track.m_LocalTrackParam[ii];
    for (int jj = 0 ; jj < 4; jj ++) {
      m_TrackParamErr[ii][jj] = track.m_TrackParamErr[ii][jj];
      m_LocalTrackParamErr[ii][jj] = track.m_LocalTrackParamErr[ii][jj];
    }
  }
  return *this;
}
 
TVectorD BKLMTrack::getTrackParam()
{
  TVectorD trackParam(4);
  trackParam[0] = m_TrackParam[0];
  trackParam[1] = m_TrackParam[1];
  trackParam[2] = m_TrackParam[2];
  trackParam[3] = m_TrackParam[3];
 
  return trackParam;
}
 
 
TVectorD BKLMTrack::getLocalTrackParam()
{
  TVectorD trackParam(4);
  trackParam[0] = m_LocalTrackParam[0];
  trackParam[1] = m_LocalTrackParam[1];
  trackParam[2] = m_LocalTrackParam[2];
  trackParam[3] = m_LocalTrackParam[3];
 
  return trackParam;
}
 
TMatrixDSym BKLMTrack::getTrackParamErr()
{
  TMatrixDSym  trkParamErr(4);
  for (int ii = 0 ; ii < 4; ii ++) {
    for (int jj = 0 ; jj < 4; jj ++) {
      trkParamErr[ii][jj] = m_TrackParamErr[ii][jj];
    }
  }
  return trkParamErr;
}
 
TMatrixDSym BKLMTrack::getLocalTrackParamErr()
{
  TMatrixDSym  trkParamErr(4);
  for (int ii = 0 ; ii < 4; ii ++) {
    for (int jj = 0 ; jj < 4; jj ++) {
      trkParamErr[ii][jj] = m_LocalTrackParamErr[ii][jj];
    }
  }
  return trkParamErr;
}
 
void BKLMTrack::setTrackParam(const CLHEP::HepVector& trkPar)
{
  m_TrackParam[0] = trkPar[0];
  m_TrackParam[1] = trkPar[1];
  m_TrackParam[2] = trkPar[2];
  m_TrackParam[3] = trkPar[3];
 
}
 
void BKLMTrack::setTrackParamErr(const CLHEP::HepSymMatrix& trkParErr)
{
  for (int ii = 0 ; ii < 4; ii ++) {
    for (int jj = 0 ; jj < 4; jj ++) {
      m_TrackParamErr[ii][jj] = trkParErr[ii][jj];
    }
  }
}
 
void BKLMTrack::setLocalTrackParam(const CLHEP::HepVector& trkPar)
{
  m_LocalTrackParam[0] = trkPar[0];
  m_LocalTrackParam[1] = trkPar[1];
  m_LocalTrackParam[2] = trkPar[2];
  m_LocalTrackParam[3] = trkPar[3];
 
}
 
void BKLMTrack::setLocalTrackParamErr(const CLHEP::HepSymMatrix& trkParErr)
{
  for (int ii = 0 ; ii < 4; ii ++) {
    for (int jj = 0 ; jj < 4; jj ++) {
      m_LocalTrackParamErr[ii][jj] = trkParErr[ii][jj];
    }
  }
}
 
ROOT::Math::XYZVector BKLMTrack::getLocalIntercept(double x)
{
 
  ROOT::Math::XYZVector intercept;
 
  intercept.SetX(x);
  intercept.SetY(m_LocalTrackParam[ 0 ] + x * m_LocalTrackParam[ 1 ]);
  intercept.SetZ(m_LocalTrackParam[ 2 ] + x * m_LocalTrackParam[ 3 ]);
 
  return intercept;
 
}
 
TMatrixD BKLMTrack::getLocalInterceptVariance(double x)
{
 
  TMatrixD  errors(2, 2, 0);
  TMatrixD  A(2, 4, 0);
  A[ 0 ][ 0 ] = 1.0;
  A[ 0 ][ 1 ] =   x;
  A[ 1 ][ 2 ] = 1.0;
  A[ 1 ][ 3 ] =   x;
  errors = A * getLocalTrackParamErr() * A.T();
 
  return errors;
 
}