#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.

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

◆ FreeTrackPar

enum tauImpactParameter::TrackHelixVertexFitter::FreeTrackPar

Enumerator
kappa0
lambda0
phi0
NFreeTrackPar

Definition at line 27 of file TrackHelixVertexFitter.h.

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

◆ FreeVertexPar

enum tauImpactParameter::TrackHelixVertexFitter::FreeVertexPar

Enumerator
x0
y0
z0
NFreeVertexPar

Definition at line 26 of file TrackHelixVertexFitter.h.

26 { 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.

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

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.

◆ ~TrackHelixVertexFitter()

TrackHelixVertexFitter::~TrackHelixVertexFitter ( )

virtual

Definition at line 66 of file TrackHelixVertexFitter.cc.

66 {}

Member Function Documentation

◆ chiSquare()

virtual double tauImpactParameter::TrackHelixVertexFitter::chiSquare ( )

inlinevirtual

Definition at line 35 of file TrackHelixVertexFitter.h.

35 { return chi2_; }

References 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.

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

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

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

◆ computeLorentzVectorPar()

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

static

Definition at line 213 of file TrackHelixVertexFitter.cc.

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

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

◆ computeMotherLorentzVectorPar()

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

staticprivate

Definition at line 234 of file TrackHelixVertexFitter.cc.

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

Referenced by getMother().

◆ computePar()

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

staticprivate

Definition at line 188 of file TrackHelixVertexFitter.cc.

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

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

Referenced by getRefitTracks(), and updateChisquare().

◆ computeTrackPar()

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

staticprivate

Definition at line 200 of file TrackHelixVertexFitter.cc.

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

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

Referenced by computePar().

◆ 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.

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

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

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

◆ freeParName()

TString TrackHelixVertexFitter::freeParName ( int Par )

protectedvirtual

Definition at line 265 of file TrackHelixVertexFitter.cc.

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

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

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

◆ getMother()

LorentzVectorParticle TrackHelixVertexFitter::getMother ( int pdgid )

Definition at line 121 of file TrackHelixVertexFitter.cc.

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

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

◆ getRefitLorentzVectorParticles()

std::vector< LorentzVectorParticle > TrackHelixVertexFitter::getRefitLorentzVectorParticles ( )

Definition at line 99 of file TrackHelixVertexFitter.cc.

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

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

◆ getRefitTracks()

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

virtual

Definition at line 75 of file TrackHelixVertexFitter.cc.

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

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

◆ getVertex()

TVector3 TrackHelixVertexFitter::getVertex ( )

virtual

Definition at line 143 of file TrackHelixVertexFitter.cc.

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

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

◆ getVertexError()

TMatrixTSym< double > TrackHelixVertexFitter::getVertexError ( )

virtual

Definition at line 147 of file TrackHelixVertexFitter.cc.

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

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

◆ measuredValueIndex()

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

inlinestaticprivate

Definition at line 68 of file TrackHelixVertexFitter.h.

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

References tauImpactParameter::TrackParticle::NHelixPar.

Referenced by computePar(), and TrackHelixVertexFitter().

◆ ndf()

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

inlinevirtual

Definition at line 36 of file TrackHelixVertexFitter.h.

36 { return ndf_; }

References 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.

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

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

Referenced by computeLorentzVectorPar(), and computeMotherLorentzVectorPar().

◆ updateChisquare()

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

virtual

Definition at line 68 of file TrackHelixVertexFitter.cc.

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

References computePar(), cov_inv_, and val_.

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

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

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Static Private Member Functions

Private Attributes

Detailed Description

Member Enumeration Documentation

◆ ExtraPar

◆ FreeTrackPar

◆ FreeVertexPar

Constructor & Destructor Documentation

◆ TrackHelixVertexFitter()

◆ ~TrackHelixVertexFitter()

Member Function Documentation

◆ chiSquare()

◆ computedxydz()

◆ computeLorentzVectorPar()

◆ computeMotherLorentzVectorPar()

◆ computePar()

◆ computeTrackPar()

◆ fit()

◆ freeParIndex()

◆ freeParName()

◆ getMother()

◆ getRefitLorentzVectorParticles()

◆ getRefitTracks()

◆ getVertex()

◆ getVertexError()

◆ measuredValueIndex()

◆ ndf()

◆ parSizeInfo()

◆ updateChisquare()

Member Data Documentation

◆ chi2_

◆ cov_

◆ cov_inv_

◆ isConfigured_

◆ isFit_

◆ ndf_

◆ nPar_

◆ nParticles_

◆ nVal_

◆ par_

◆ parcov_

◆ particles_

◆ val_