tauImpactParameter::TrackHelixVertexFitter Class Reference

#include <TrackHelixVertexFitter.h>

Inheritance diagram for tauImpactParameter::TrackHelixVertexFitter:

Public Types
enum	ExtraPar { BField0 = 0, MassOffSet = 1, NExtraPar = 1 }
enum	FreeTrackPar { kappa0 = 3, lambda0, phi0, NFreeTrackPar }
enum	FreeVertexPar { x0 = 0, y0, z0, NFreeVertexPar }

Public Member Functions
virtual double	chiSquare ()
virtual bool	fit ()=0
LorentzVectorParticle	getMother (int pdgid)
std::vector< LorentzVectorParticle >	getRefitLorentzVectorParticles ()
virtual std::vector< TrackParticle >	getRefitTracks ()
virtual TVector3	getVertex ()
virtual TMatrixTSym< double >	getVertexError ()
virtual double	ndf ()
	TrackHelixVertexFitter (const std::vector< TrackParticle > &particles, const TVector3 &vguess)
virtual double	updateChisquare (const TVectorT< double > &inpar)
virtual	~TrackHelixVertexFitter ()

Static Public Member Functions
static void	computedxydz (const TVectorT< double > &inpar, int particle, double &kappa, double &lam, double &phi, double &x, double &y, double &z, double &s, double &dxy, double &dz)
static TVectorT< double >	computeLorentzVectorPar (const TVectorT< double > &inpar)

Protected Member Functions
virtual TString	freeParName (int Par)

Protected Attributes
double	chi2_
bool	isConfigured_
bool	isFit_
double	ndf_
TVectorT< double >	par_
TMatrixTSym< double >	parcov_

Static Private Member Functions
static TVectorT< double >	computeMotherLorentzVectorPar (const TVectorT< double > &inpar)
static TVectorT< double >	computePar (const TVectorT< double > &inpar)
static TVectorT< double >	computeTrackPar (const TVectorT< double > &inpar, int p=0)
static int	freeParIndex (int Par, int Particle)
static int	measuredValueIndex (int TrackPar, int Particle)
static void	parSizeInfo (const TVectorT< double > &inpar, int &np, int &parsize, bool hasextras=false)

Private Attributes
TMatrixTSym< double >	cov_
TMatrixTSym< double >	cov_inv_
int	nPar_
int	nParticles_
int	nVal_
std::vector< TrackParticle >	particles_
TVectorT< double >	val_

Detailed Description

Definition at line 24 of file TrackHelixVertexFitter.h.

Member Enumeration Documentation

ExtraPar

enum tauImpactParameter::TrackHelixVertexFitter::ExtraPar

Enumerator
BField0
MassOffSet
NExtraPar

Definition at line 28 of file TrackHelixVertexFitter.h.

{ BField0 = 0, MassOffSet = 1, NExtraPar = 1 };

FreeTrackPar

enum tauImpactParameter::TrackHelixVertexFitter::FreeTrackPar

Enumerator
kappa0
lambda0
phi0
NFreeTrackPar

Definition at line 27 of file TrackHelixVertexFitter.h.

{ kappa0 = 3, lambda0, phi0, NFreeTrackPar };

FreeVertexPar

enum tauImpactParameter::TrackHelixVertexFitter::FreeVertexPar

Enumerator
x0
y0
z0
NFreeVertexPar

Definition at line 26 of file TrackHelixVertexFitter.h.

{ x0 = 0, y0, z0, NFreeVertexPar };

Constructor & Destructor Documentation

TrackHelixVertexFitter()

TrackHelixVertexFitter::TrackHelixVertexFitter	(	const std::vector< TrackParticle > &	particles,
		const TVector3 &	vguess
	)

Definition at line 13 of file TrackHelixVertexFitter.cc.

References cov_, cov_inv_, freeParIndex(), isConfigured_, dqmiolumiharvest::j, dqmdumpme::k, tauImpactParameter::TrackParticle::kappa, kappa0, tauImpactParameter::TrackParticle::lambda, lambda0, measuredValueIndex(), ndf_, tauImpactParameter::TrackParticle::NHelixPar, nPar_, nVal_, AlCaHLTBitMon_ParallelJobs::p, par_, parcov_, ecalTrigSettings_cff::particles, particles_, tauImpactParameter::TrackParticle::phi, phi0, val_, x0, y0, and z0.

    : isFit_(false),
      isConfigured_(false),
      nParticles_(particles.size()),
      nPar_((NFreeTrackPar - NFreeVertexPar) * particles.size() + NFreeVertexPar),
      nVal_(TrackParticle::NHelixPar * particles.size()) {
  particles_ = particles;
  par_.ResizeTo(nPar_);
  parcov_.ResizeTo(nPar_, nPar_);
  val_.ResizeTo(nVal_);
  cov_.ResizeTo(nVal_, nVal_);
  for (unsigned int p = 0; p < particles.size(); p++) {
    for (unsigned int j = 0; j < TrackParticle::NHelixPar; j++) {
      val_(measuredValueIndex(j, p)) = particles[p].parameter(j);
      for (unsigned int k = 0; k < TrackParticle::NHelixPar; k++) {
        cov_(measuredValueIndex(j, p), measuredValueIndex(k, p)) = particles[p].covariance(j, k);
      }
    }
  }
  TDecompBK Inverter(cov_);
  double det = cov_.Determinant();
  if (!Inverter.Decompose()) {
    edm::LogWarning("TrackHelixVertexFitter::TrackHelixVertexFitter")
        << "Fit failed: unable to invert SYM gain matrix " << det << " \n"
        << std::endl;
    return;
  }

  cov_inv_.ResizeTo(nVal_, nVal_);
  cov_inv_ = Inverter.Invert();
  ndf_ = nVal_ - nPar_;
  // Set Initial conditions within reason
  par_(x0) = vguess.X();
  parcov_(x0, x0) = 1.0;
  par_(y0) = vguess.Y();
  parcov_(y0, y0) = 1.0;
  par_(z0) = vguess.Z();
  parcov_(z0, z0) = 1.0;
  for (unsigned int p = 0; p < particles_.size(); p++) {
    par_(freeParIndex(kappa0, p)) = val_(measuredValueIndex(TrackParticle::kappa, p));
    par_(freeParIndex(lambda0, p)) = val_(measuredValueIndex(TrackParticle::lambda, p));
    par_(freeParIndex(phi0, p)) = val_(measuredValueIndex(TrackParticle::phi, p));

    parcov_(freeParIndex(kappa0, p), freeParIndex(kappa0, p)) =
        cov_(measuredValueIndex(TrackParticle::kappa, p), measuredValueIndex(TrackParticle::kappa, p));
    parcov_(freeParIndex(lambda0, p), freeParIndex(lambda0, p)) =
        cov_(measuredValueIndex(TrackParticle::lambda, p), measuredValueIndex(TrackParticle::lambda, p));
    parcov_(freeParIndex(phi0, p), freeParIndex(phi0, p)) =
        cov_(measuredValueIndex(TrackParticle::phi, p), measuredValueIndex(TrackParticle::phi, p));
  }
  isConfigured_ = true;
}

~TrackHelixVertexFitter()

TrackHelixVertexFitter::~TrackHelixVertexFitter ( )

virtual

Definition at line 66 of file TrackHelixVertexFitter.cc.

{}

Member Function Documentation

chiSquare()

virtual double tauImpactParameter::TrackHelixVertexFitter::chiSquare ( )

inlinevirtual

Definition at line 35 of file TrackHelixVertexFitter.h.

References chi2_.

{ return chi2_; }

computedxydz()

void TrackHelixVertexFitter::computedxydz ( const TVectorT< double > &  inpar, int  particle, double &  kappa, double &  lam, double &  phi, double &  x, double &  y, double &  z, double &  s, double &  dxy, double &  dz  )

static

Definition at line 157 of file TrackHelixVertexFitter.cc.

References funct::cos(), PVValHelper::dxy, PVValHelper::dz, freeParIndex(), hgcalLayerClusters_cfi::kappa, kappa0, lambda0, AlCaHLTBitMon_ParallelJobs::p, phi0, Pi, alignCSCRings::s, funct::sin(), funct::tan(), findQualityFiles::v, x, x0, y0, and z0.

Referenced by computeLorentzVectorPar(), computeTrackPar(), and tauImpactParameter::ParticleBuilder::createTrackParticle().

                                                      {
  kappa = inpar(freeParIndex(kappa0, p));
  lam = inpar(freeParIndex(lambda0, p));
  phi = inpar(freeParIndex(phi0, p));
  x = inpar(freeParIndex(x0, p));
  y = inpar(freeParIndex(y0, p));
  z = inpar(freeParIndex(z0, p));
  double v = (2.0 * kappa * (x * cos(phi) + y * sin(phi)));
  double arcsinv = 0;
  if (v >= 1.0) {
    arcsinv = TMath::Pi() / 2;
  } else if (v <= -1.0) {
    arcsinv = -TMath::Pi() / 2;
  } else {
    arcsinv = asin(v);
  }
  s = 1.0 / (2.0 * kappa) * arcsinv;
  dxy = y * cos(phi) - x * sin(phi) - (1 / kappa) * sin(kappa * s) * sin(kappa * s);
  dz = z - s * tan(lam);
}

computeLorentzVectorPar()

TVectorT< double > TrackHelixVertexFitter::computeLorentzVectorPar ( const TVectorT< double > &  inpar )

static

Definition at line 213 of file TrackHelixVertexFitter.cc.

References B, BField0, computedxydz(), funct::cos(), PVValHelper::dxy, PVValHelper::dz, hgcalLayerClusters_cfi::kappa, tauImpactParameter::LorentzVectorParticle::m, HLT_2022v12_cff::massHypothesis, MassOffSet, tauImpactParameter::LorentzVectorParticle::NLorentzandVertexPar, np, AlCaHLTBitMon_ParallelJobs::p, parSizeInfo(), tauImpactParameter::LorentzVectorParticle::px, tauImpactParameter::LorentzVectorParticle::py, tauImpactParameter::LorentzVectorParticle::pz, alignCSCRings::s, funct::sin(), funct::tan(), tauImpactParameter::LorentzVectorParticle::vx, tauImpactParameter::LorentzVectorParticle::vy, tauImpactParameter::LorentzVectorParticle::vz, and x.

Referenced by computeMotherLorentzVectorPar(), tauImpactParameter::ParticleBuilder::createLorentzVectorParticle(), getRefitLorentzVectorParticles(), and tauImpactParameter::TrackTools::lorentzParticleAtPosition().

                                                                                              {
  int np(0), parsize(0);
  parSizeInfo(inpar, np, parsize, true);
  double B = inpar(parsize + BField0);
  double massHypothesis = inpar(parsize + MassOffSet);
  TVectorT<double> LV(LorentzVectorParticle::NLorentzandVertexPar);
  double kappa, lam, phi, x, y, z, s, dxy, dz;
  int p = 0;
  TrackHelixVertexFitter::computedxydz(inpar, p, kappa, lam, phi, x, y, z, s, dxy, dz);
  double phi1 = 2 * s * kappa + phi;
  double bOverK = B * (1.0 / fabs(kappa));
  LV(LorentzVectorParticle::px) = bOverK * cos(phi1);
  LV(LorentzVectorParticle::py) = bOverK * sin(phi1);
  LV(LorentzVectorParticle::pz) = bOverK * tan(lam);
  LV(LorentzVectorParticle::m) = massHypothesis;
  LV(LorentzVectorParticle::vx) = x;
  LV(LorentzVectorParticle::vy) = y;
  LV(LorentzVectorParticle::vz) = z;
  return LV;
}

computeMotherLorentzVectorPar()

TVectorT< double > TrackHelixVertexFitter::computeMotherLorentzVectorPar ( const TVectorT< double > &  inpar )

staticprivate

Definition at line 234 of file TrackHelixVertexFitter.cc.

References BField0, computeLorentzVectorPar(), freeParIndex(), mps_fire::i, tauImpactParameter::LorentzVectorParticle::m, MassOffSet, NExtraPar, NFreeTrackPar, tauImpactParameter::LorentzVectorParticle::NLorentzandVertexPar, np, AlCaHLTBitMon_ParallelJobs::p, parSizeInfo(), tauImpactParameter::LorentzVectorParticle::px, tauImpactParameter::LorentzVectorParticle::py, tauImpactParameter::LorentzVectorParticle::pz, mathSSE::sqrt(), tauImpactParameter::LorentzVectorParticle::vx, tauImpactParameter::LorentzVectorParticle::vy, and tauImpactParameter::LorentzVectorParticle::vz.

Referenced by getMother().

                                                                                                    {
  TVectorT<double> mother(LorentzVectorParticle::NLorentzandVertexPar);
  double E(0);
  int np(0), parsize(0);
  parSizeInfo(inpar, np, parsize, true);
  for (int p = 0; p < np; p++) {
    TVectorT<double> particlepar(NFreeTrackPar + NExtraPar + MassOffSet);
    for (int i = 0; i < NFreeTrackPar; i++) {
      particlepar(i) = inpar(freeParIndex(i, p));
    }
    particlepar(NFreeTrackPar + BField0) = inpar(parsize + BField0);
    particlepar(NFreeTrackPar + MassOffSet) = inpar(parsize + MassOffSet + p);
    TVectorT<double> daughter = TrackHelixVertexFitter::computeLorentzVectorPar(particlepar);
    mother(LorentzVectorParticle::px) += daughter(LorentzVectorParticle::px);
    mother(LorentzVectorParticle::py) += daughter(LorentzVectorParticle::py);
    mother(LorentzVectorParticle::pz) += daughter(LorentzVectorParticle::pz);
    mother(LorentzVectorParticle::vx) = daughter(LorentzVectorParticle::vx);
    mother(LorentzVectorParticle::vy) = daughter(LorentzVectorParticle::vy);
    mother(LorentzVectorParticle::vz) = daughter(LorentzVectorParticle::vz);
    E += sqrt((daughter(LorentzVectorParticle::px) * daughter(LorentzVectorParticle::px) +
               daughter(LorentzVectorParticle::py) * daughter(LorentzVectorParticle::py) +
               daughter(LorentzVectorParticle::pz) * daughter(LorentzVectorParticle::pz) +
               daughter(LorentzVectorParticle::m) * daughter(LorentzVectorParticle::m)));
  }
  double P2 = (mother(LorentzVectorParticle::px) * mother(LorentzVectorParticle::px) +
               mother(LorentzVectorParticle::py) * mother(LorentzVectorParticle::py) +
               mother(LorentzVectorParticle::pz) * mother(LorentzVectorParticle::pz));
  mother(LorentzVectorParticle::m) = (E * E - P2) / sqrt(fabs(E * E - P2));
  return mother;
}

computePar()

TVectorT< double > TrackHelixVertexFitter::computePar ( const TVectorT< double > &  inpar )

staticprivate

Definition at line 188 of file TrackHelixVertexFitter.cc.

References computeTrackPar(), mps_fire::i, measuredValueIndex(), NFreeTrackPar, NFreeVertexPar, tauImpactParameter::TrackParticle::NHelixPar, l1NNTauProducerPuppi_cfi::nparticles, and AlCaHLTBitMon_ParallelJobs::p.

Referenced by getRefitTracks(), and updateChisquare().

                                                                                 {
  int nparticles = (inpar.GetNrows() - NFreeVertexPar) / (NFreeTrackPar - NFreeVertexPar);
  TVectorT<double> helices(nparticles * TrackParticle::NHelixPar);
  for (int p = 0; p < nparticles; p++) {
    TVectorT<double> TrackPar = computeTrackPar(inpar, p);
    for (int i = 0; i < TrackParticle::NHelixPar; i++) {
      helices(measuredValueIndex(i, p)) = TrackPar(i);
    }
  }
  return helices;
}

computeTrackPar()

TVectorT< double > TrackHelixVertexFitter::computeTrackPar ( const TVectorT< double > &  inpar, int  p = 0  )

staticprivate

Definition at line 200 of file TrackHelixVertexFitter.cc.

References computedxydz(), tauImpactParameter::TrackParticle::dxy, PVValHelper::dxy, tauImpactParameter::TrackParticle::dz, PVValHelper::dz, tauImpactParameter::TrackParticle::kappa, hgcalLayerClusters_cfi::kappa, tauImpactParameter::TrackParticle::lambda, tauImpactParameter::TrackParticle::NHelixPar, AlCaHLTBitMon_ParallelJobs::p, tauImpactParameter::TrackParticle::phi, alignCSCRings::s, and x.

Referenced by computePar().

                                                                                             {
  TVectorT<double> helix(TrackParticle::NHelixPar);
  // copy parameters that are 1 to 1
  double kappa, lam, phi, x, y, z, s, dxy, dz;
  TrackHelixVertexFitter::computedxydz(inpar, p, kappa, lam, phi, x, y, z, s, dxy, dz);
  helix(TrackParticle::kappa) = kappa;
  helix(TrackParticle::lambda) = lam;
  helix(TrackParticle::phi) = phi;
  helix(TrackParticle::dxy) = dxy;
  helix(TrackParticle::dz) = dz;
  return helix;
}

fit()

virtual bool tauImpactParameter::TrackHelixVertexFitter::fit ( )

pure virtual

Implemented in tauImpactParameter::Chi2VertexFitter.

Referenced by trackingPlots.Iteration::modules().

freeParIndex()

static int tauImpactParameter::TrackHelixVertexFitter::freeParIndex ( int  Par, int  Particle  )

inlinestaticprivate

Definition at line 69 of file TrackHelixVertexFitter.h.

References NFreeTrackPar, NFreeVertexPar, x0, y0, and z0.

Referenced by computedxydz(), computeMotherLorentzVectorPar(), getRefitLorentzVectorParticles(), getRefitTracks(), getVertex(), getVertexError(), and TrackHelixVertexFitter().

                                                   {
      if (Par == x0 || Par == y0 || Par == z0)
        return Par;
      return Par + Particle * (NFreeTrackPar - NFreeVertexPar);
    }

freeParName()

TString TrackHelixVertexFitter::freeParName ( int  Par )

protectedvirtual

Definition at line 265 of file TrackHelixVertexFitter.cc.

References kappa0, lambda0, dqmiodumpmetadata::n, NFreeTrackPar, NFreeVertexPar, nParticles_, AlCaHLTBitMon_ParallelJobs::p, phi0, x0, y0, and z0.

Referenced by tauImpactParameter::Chi2VertexFitter::fit().

                                                   {
  int p(0);
  if (Par == x0)
    return "x0";
  if (Par == y0)
    return "y0";
  if (Par == z0)
    return "z0";
  for (p = 0; p < nParticles_; p++) {
    if ((Par - NFreeVertexPar) < (p + 1) * (NFreeTrackPar - NFreeVertexPar))
      break;
  }
  TString n;
  int index = Par - p * (NFreeTrackPar - NFreeVertexPar);
  if (index == kappa0)
    n = "kappa0";
  if (index == lambda0)
    n = "lambda0";
  if (index == phi0)
    n = "phi0";
  n += "_particle";
  n += p;
  return n;
}

getMother()

LorentzVectorParticle TrackHelixVertexFitter::getMother

(

int

pdgid

)

Definition at line 121 of file TrackHelixVertexFitter.cc.

References b, BField0, c, computeMotherLorentzVectorPar(), mps_fire::i, dqmiolumiharvest::j, EgHLTOffHistBins_cfi::mass, MassOffSet, NExtraPar, AlCaHLTBitMon_ParallelJobs::p, par_, parcov_, particles_, EgammaValidation_cff::pdgid, and tauImpactParameter::ErrorMatrixPropagator::propagateError().

                                                                 {
  double c(0), b(0);
  TVectorT<double> FreePar(par_.GetNrows() + NExtraPar + particles_.size());
  TMatrixTSym<double> FreeParCov(par_.GetNrows() + NExtraPar + particles_.size());
  for (int i = 0; i < par_.GetNrows(); i++) {
    FreePar(i) = par_(i);
    for (int j = 0; j < par_.GetNrows(); j++) {
      FreeParCov(i, j) = parcov_(i, j);
    }
  }
  for (unsigned int p = 0; p < particles_.size(); p++) {
    b = particles_[p].bField();
    c += particles_[p].charge();
    FreePar(par_.GetNrows() + MassOffSet + p) = particles_[p].mass();
  }
  FreePar(par_.GetNrows() + BField0) = b;
  TVectorT<double> mpar = computeMotherLorentzVectorPar(FreePar);
  TMatrixTSym<double> mcov = ErrorMatrixPropagator::propagateError(
      &TrackHelixVertexFitter::computeMotherLorentzVectorPar, FreePar, FreeParCov);
  return LorentzVectorParticle(mpar, mcov, pdgid, c, b);
}

getRefitLorentzVectorParticles()

std::vector< LorentzVectorParticle > TrackHelixVertexFitter::getRefitLorentzVectorParticles

(

)

Definition at line 99 of file TrackHelixVertexFitter.cc.

References Calorimetry_cff::bField, BField0, ALCARECOTkAlJpsiMuMu_cff::charge, computeLorentzVectorPar(), freeParIndex(), mps_fire::i, dqmiolumiharvest::j, MassOffSet, NExtraPar, NFreeTrackPar, AlCaHLTBitMon_ParallelJobs::p, par_, parcov_, particles_, EgammaValidation_cff::pdgId, and tauImpactParameter::ErrorMatrixPropagator::propagateError().

                                                                                        {
  std::vector<LorentzVectorParticle> refitParticles;
  for (unsigned int p = 0; p < particles_.size(); p++) {
    TVectorT<double> FreePar(NFreeTrackPar + NExtraPar + MassOffSet);
    TMatrixTSym<double> FreeParCov(NFreeTrackPar + NExtraPar + MassOffSet);
    for (int i = 0; i < NFreeTrackPar; i++) {
      FreePar(i) = par_(freeParIndex(i, p));
      for (int j = 0; j < NFreeTrackPar; j++) {
        FreeParCov(i, j) = parcov_(freeParIndex(i, p), freeParIndex(j, p));
      }
    }
    FreePar(NFreeTrackPar + MassOffSet) = particles_[p].mass();
    FreePar(NFreeTrackPar + BField0) = particles_[p].bField();
    TVectorT<double> LVPar = computeLorentzVectorPar(FreePar);
    TMatrixTSym<double> LVCov =
        ErrorMatrixPropagator::propagateError(&TrackHelixVertexFitter::computeLorentzVectorPar, FreePar, FreeParCov);
    refitParticles.push_back(
        LorentzVectorParticle(LVPar, LVCov, particles_[p].pdgId(), particles_[p].charge(), particles_[p].bField()));
  }
  return refitParticles;
}

getRefitTracks()

std::vector< TrackParticle > TrackHelixVertexFitter::getRefitTracks ( )

virtual

Definition at line 75 of file TrackHelixVertexFitter.cc.

References Calorimetry_cff::bField, ALCARECOTkAlJpsiMuMu_cff::charge, computePar(), freeParIndex(), mps_fire::i, dqmiolumiharvest::j, EgHLTOffHistBins_cfi::mass, NFreeTrackPar, AlCaHLTBitMon_ParallelJobs::p, par_, parcov_, particles_, EgammaValidation_cff::pdgId, and tauImpactParameter::ErrorMatrixPropagator::propagateError().

                                                                {
  std::vector<TrackParticle> refitParticles;
  for (unsigned int p = 0; p < particles_.size(); p++) {
    TVectorT<double> FreePar(NFreeTrackPar);
    TMatrixTSym<double> FreeParCov(NFreeTrackPar);
    for (int i = 0; i < FreeParCov.GetNrows(); i++) {
      FreePar(i) = par_(freeParIndex(i, p));
      for (int j = 0; j < FreeParCov.GetNrows(); j++) {
        FreeParCov(i, j) = parcov_(freeParIndex(i, p), freeParIndex(j, p));
      }
    }
    TVectorT<double> TrackPar = computePar(FreePar);
    TMatrixTSym<double> TrackCov =
        ErrorMatrixPropagator::propagateError(&TrackHelixVertexFitter::computePar, FreePar, FreeParCov);
    refitParticles.push_back(TrackParticle(TrackPar,
                                           TrackCov,
                                           particles_[p].pdgId(),
                                           particles_[p].mass(),
                                           particles_[p].charge(),
                                           particles_[p].bField()));
  }
  return refitParticles;
}

getVertex()

TVector3 TrackHelixVertexFitter::getVertex ( )

virtual

Definition at line 143 of file TrackHelixVertexFitter.cc.

References freeParIndex(), par_, x0, y0, and z0.

                                           {
  return TVector3(par_(freeParIndex(x0, 0)), par_(freeParIndex(y0, 0)), par_(freeParIndex(z0, 0)));
}

getVertexError()

TMatrixTSym< double > TrackHelixVertexFitter::getVertexError ( )

virtual

Definition at line 147 of file TrackHelixVertexFitter.cc.

References c, freeParIndex(), mps_fire::i, dqmiolumiharvest::j, NFreeVertexPar, and parcov_.

                                                           {
  TMatrixTSym<double> c(NFreeVertexPar);
  for (unsigned int i = 0; i < NFreeVertexPar; i++) {
    for (unsigned int j = 0; j < NFreeVertexPar; j++) {
      c(freeParIndex(i, 0), freeParIndex(j, 0)) = parcov_(freeParIndex(i, 0), freeParIndex(j, 0));
    }
  }
  return c;
}

measuredValueIndex()

static int tauImpactParameter::TrackHelixVertexFitter::measuredValueIndex ( int  TrackPar, int  Particle  )

inlinestaticprivate

Definition at line 68 of file TrackHelixVertexFitter.h.

References tauImpactParameter::TrackParticle::NHelixPar.

Referenced by computePar(), and TrackHelixVertexFitter().

{ return TrackPar + Particle * TrackParticle::NHelixPar; }

ndf()

virtual double tauImpactParameter::TrackHelixVertexFitter::ndf ( void  )

inlinevirtual

Definition at line 36 of file TrackHelixVertexFitter.h.

References ndf_.

{ return ndf_; }

parSizeInfo()

void TrackHelixVertexFitter::parSizeInfo ( const TVectorT< double > &  inpar, int &  np, int &  parsize, bool  hasextras = false  )

staticprivate

Definition at line 290 of file TrackHelixVertexFitter.cc.

References MassOffSet, NExtraPar, NFreeTrackPar, NFreeVertexPar, and np.

Referenced by computeLorentzVectorPar(), and computeMotherLorentzVectorPar().

                                                                                                             {
  if (hasextras)
    np = (inpar.GetNrows() - NFreeVertexPar - NExtraPar) / (NFreeTrackPar + MassOffSet - NFreeVertexPar);
  else
    np = (inpar.GetNrows() - NFreeVertexPar) / (NFreeTrackPar - NFreeVertexPar);
  parsize = np * (NFreeTrackPar - NFreeVertexPar) + NFreeVertexPar;
}

updateChisquare()

double TrackHelixVertexFitter::updateChisquare ( const TVectorT< double > &  inpar )

virtual

Definition at line 68 of file TrackHelixVertexFitter.cc.

References computePar(), cov_inv_, and val_.

Referenced by tauImpactParameter::ChiSquareFunctionUpdator::operator()().

                                                                            {
  TVectorT<double> vprime = computePar(inpar);
  TVectorT<double> dalpha = vprime - val_;
  double c2 = dalpha * (cov_inv_ * dalpha);
  return c2;
}

Member Data Documentation

chi2_

double tauImpactParameter::TrackHelixVertexFitter::chi2_

protected

Definition at line 61 of file TrackHelixVertexFitter.h.

Referenced by chiSquare(), and tauImpactParameter::Chi2VertexFitter::fit().

cov_

TMatrixTSym<double> tauImpactParameter::TrackHelixVertexFitter::cov_

private

Definition at line 78 of file TrackHelixVertexFitter.h.

Referenced by TrackHelixVertexFitter().

cov_inv_

TMatrixTSym<double> tauImpactParameter::TrackHelixVertexFitter::cov_inv_

private

Definition at line 79 of file TrackHelixVertexFitter.h.

Referenced by TrackHelixVertexFitter(), and updateChisquare().

isConfigured_

bool tauImpactParameter::TrackHelixVertexFitter::isConfigured_

protected

Definition at line 57 of file TrackHelixVertexFitter.h.

Referenced by tauImpactParameter::Chi2VertexFitter::fit(), and TrackHelixVertexFitter().

isFit_

bool tauImpactParameter::TrackHelixVertexFitter::isFit_

protected

Definition at line 57 of file TrackHelixVertexFitter.h.

Referenced by tauImpactParameter::Chi2VertexFitter::fit().

ndf_

double tauImpactParameter::TrackHelixVertexFitter::ndf_

protected

Definition at line 61 of file TrackHelixVertexFitter.h.

Referenced by ndf(), and TrackHelixVertexFitter().

nPar_

int tauImpactParameter::TrackHelixVertexFitter::nPar_

private

Definition at line 80 of file TrackHelixVertexFitter.h.

Referenced by TrackHelixVertexFitter().

nParticles_

int tauImpactParameter::TrackHelixVertexFitter::nParticles_

private

Definition at line 80 of file TrackHelixVertexFitter.h.

Referenced by freeParName().

nVal_

int tauImpactParameter::TrackHelixVertexFitter::nVal_

private

Definition at line 80 of file TrackHelixVertexFitter.h.

Referenced by TrackHelixVertexFitter().

par_

TVectorT<double> tauImpactParameter::TrackHelixVertexFitter::par_

protected

Definition at line 58 of file TrackHelixVertexFitter.h.

Referenced by tauImpactParameter::Chi2VertexFitter::fit(), getMother(), getRefitLorentzVectorParticles(), getRefitTracks(), getVertex(), and TrackHelixVertexFitter().

parcov_

TMatrixTSym<double> tauImpactParameter::TrackHelixVertexFitter::parcov_

protected

Definition at line 59 of file TrackHelixVertexFitter.h.

Referenced by tauImpactParameter::Chi2VertexFitter::fit(), getMother(), getRefitLorentzVectorParticles(), getRefitTracks(), getVertexError(), and TrackHelixVertexFitter().

particles_

std::vector<TrackParticle> tauImpactParameter::TrackHelixVertexFitter::particles_

private

Definition at line 76 of file TrackHelixVertexFitter.h.

Referenced by getMother(), getRefitLorentzVectorParticles(), getRefitTracks(), and TrackHelixVertexFitter().

val_

TVectorT<double> tauImpactParameter::TrackHelixVertexFitter::val_

private

Definition at line 77 of file TrackHelixVertexFitter.h.

Referenced by TrackHelixVertexFitter(), and updateChisquare().