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=0)

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

enum tauImpactParameter::TrackHelixVertexFitter::ExtraPar

Enumerator
BField0
MassOffSet
NExtraPar

Definition at line 28 of file TrackHelixVertexFitter.h.

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

enum tauImpactParameter::TrackHelixVertexFitter::FreeTrackPar

Enumerator
kappa0
lambda0
phi0
NFreeTrackPar

Definition at line 27 of file TrackHelixVertexFitter.h.

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

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	(	const std::vector< TrackParticle > &	particles,
		const TVector3 &	vguess
	)

Definition at line 13 of file TrackHelixVertexFitter.cc.

References cov_, cov_inv_, freeParIndex(), isConfigured_, j, relval_steps::k, tauImpactParameter::TrackParticle::kappa, kappa0, tauImpactParameter::TrackParticle::lambda, lambda0, measuredValueIndex(), ndf_, tauImpactParameter::TrackParticle::NHelixPar, nPar_, nVal_, AlCaHLTBitMon_ParallelJobs::p, par_, parcov_, 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 ( )

virtual

Definition at line 59 of file TrackHelixVertexFitter.cc.

{}

Member Function Documentation

virtual double tauImpactParameter::TrackHelixVertexFitter::chiSquare ( )

inlinevirtual

Definition at line 35 of file TrackHelixVertexFitter.h.

References chi2_.

{return chi2_;}

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 137 of file TrackHelixVertexFitter.cc.

References funct::cos(), freeParIndex(), kappa, kappa0, lambda0, phi0, Pi, funct::sin(), funct::tan(), findQualityFiles::v, 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);
}

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

static

Definition at line 177 of file TrackHelixVertexFitter.cc.

References BField0, computedxydz(), funct::cos(), kappa, tauImpactParameter::LorentzVectorParticle::m, HLT_25ns14e33_v1_cff::massHypothesis, MassOffSet, tauImpactParameter::LorentzVectorParticle::NLorentzandVertexPar, np, AlCaHLTBitMon_ParallelJobs::p, parSizeInfo(), phi, tauImpactParameter::LorentzVectorParticle::px, tauImpactParameter::LorentzVectorParticle::py, tauImpactParameter::LorentzVectorParticle::pz, alignCSCRings::s, funct::sin(), funct::tan(), tauImpactParameter::LorentzVectorParticle::vx, tauImpactParameter::LorentzVectorParticle::vy, tauImpactParameter::LorentzVectorParticle::vz, x, detailsBasic3DVector::y, and detailsBasic3DVector::z.

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

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

staticprivate

Definition at line 197 of file TrackHelixVertexFitter.cc.

References BField0, computeLorentzVectorPar(), freeParIndex(), 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;
}

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

staticprivate

Definition at line 154 of file TrackHelixVertexFitter.cc.

References computeTrackPar(), i, measuredValueIndex(), NFreeTrackPar, NFreeVertexPar, tauImpactParameter::TrackParticle::NHelixPar, 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;
}

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

staticprivate

Definition at line 164 of file TrackHelixVertexFitter.cc.

References computedxydz(), tauImpactParameter::TrackParticle::dxy, tauImpactParameter::TrackParticle::dz, tauImpactParameter::TrackParticle::kappa, kappa, tauImpactParameter::TrackParticle::lambda, tauImpactParameter::TrackParticle::NHelixPar, phi, tauImpactParameter::TrackParticle::phi, alignCSCRings::s, x, detailsBasic3DVector::y, and detailsBasic3DVector::z.

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

virtual bool tauImpactParameter::TrackHelixVertexFitter::fit ( )

pure virtual

Implemented in tauImpactParameter::Chi2VertexFitter.

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

inlinestaticprivate

Definition at line 59 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);
   }

TString TrackHelixVertexFitter::freeParName ( int  Par )

protectedvirtual

Definition at line 225 of file TrackHelixVertexFitter.cc.

References cmsHarvester::index, kappa0, lambda0, gen::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;
}

LorentzVectorParticle TrackHelixVertexFitter::getMother

(

int

pdgid

)

Definition at line 106 of file TrackHelixVertexFitter.cc.

References b, BField0, EnergyCorrector::c, computeMotherLorentzVectorPar(), i, j, MassOffSet, NExtraPar, AlCaHLTBitMon_ParallelJobs::p, par_, parcov_, particles_, 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);
}

std::vector< LorentzVectorParticle > TrackHelixVertexFitter::getRefitLorentzVectorParticles

(

)

Definition at line 86 of file TrackHelixVertexFitter.cc.

References ecalTB2006H4_GenSimDigiReco_cfg::bField, BField0, computeLorentzVectorPar(), freeParIndex(), i, j, MassOffSet, NExtraPar, NFreeTrackPar, AlCaHLTBitMon_ParallelJobs::p, par_, parcov_, particles_, benchmark_cfg::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;
}

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

virtual

Definition at line 68 of file TrackHelixVertexFitter.cc.

References ecalTB2006H4_GenSimDigiReco_cfg::bField, computePar(), freeParIndex(), i, j, NFreeTrackPar, AlCaHLTBitMon_ParallelJobs::p, par_, parcov_, particles_, benchmark_cfg::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;
}

TVector3 TrackHelixVertexFitter::getVertex ( )

virtual

Definition at line 125 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)));
}

TMatrixTSym< double > TrackHelixVertexFitter::getVertexError ( )

virtual

Definition at line 129 of file TrackHelixVertexFitter.cc.

References EnergyCorrector::c, freeParIndex(), i, 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;
}

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

inlinestaticprivate

Definition at line 56 of file TrackHelixVertexFitter.h.

References tauImpactParameter::TrackParticle::NHelixPar.

Referenced by computePar(), and TrackHelixVertexFitter().

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

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

inlinevirtual

Definition at line 36 of file TrackHelixVertexFitter.h.

References ndf_.

{return ndf_;}

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

staticprivate

Definition at line 242 of file TrackHelixVertexFitter.cc.

References MassOffSet, NExtraPar, NFreeTrackPar, and NFreeVertexPar.

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

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

virtual

Definition at line 61 of file TrackHelixVertexFitter.cc.

References counter::c2, 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

double tauImpactParameter::TrackHelixVertexFitter::chi2_

protected

Definition at line 50 of file TrackHelixVertexFitter.h.

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

TMatrixTSym<double> tauImpactParameter::TrackHelixVertexFitter::cov_

private

Definition at line 67 of file TrackHelixVertexFitter.h.

Referenced by TrackHelixVertexFitter().

TMatrixTSym<double> tauImpactParameter::TrackHelixVertexFitter::cov_inv_

private

Definition at line 68 of file TrackHelixVertexFitter.h.

Referenced by TrackHelixVertexFitter(), and updateChisquare().

bool tauImpactParameter::TrackHelixVertexFitter::isConfigured_

protected

Definition at line 46 of file TrackHelixVertexFitter.h.

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

bool tauImpactParameter::TrackHelixVertexFitter::isFit_

protected

Definition at line 46 of file TrackHelixVertexFitter.h.

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

double tauImpactParameter::TrackHelixVertexFitter::ndf_

protected

Definition at line 50 of file TrackHelixVertexFitter.h.

Referenced by ndf(), and TrackHelixVertexFitter().

int tauImpactParameter::TrackHelixVertexFitter::nPar_

private

Definition at line 69 of file TrackHelixVertexFitter.h.

Referenced by TrackHelixVertexFitter().

int tauImpactParameter::TrackHelixVertexFitter::nParticles_

private

Definition at line 69 of file TrackHelixVertexFitter.h.

Referenced by freeParName().

int tauImpactParameter::TrackHelixVertexFitter::nVal_

private

Definition at line 69 of file TrackHelixVertexFitter.h.

Referenced by TrackHelixVertexFitter().

TVectorT<double> tauImpactParameter::TrackHelixVertexFitter::par_

protected

Definition at line 47 of file TrackHelixVertexFitter.h.

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

TMatrixTSym<double> tauImpactParameter::TrackHelixVertexFitter::parcov_

protected

Definition at line 48 of file TrackHelixVertexFitter.h.

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

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

private

Definition at line 65 of file TrackHelixVertexFitter.h.

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

TVectorT<double> tauImpactParameter::TrackHelixVertexFitter::val_

private

Definition at line 66 of file TrackHelixVertexFitter.h.

Referenced by TrackHelixVertexFitter(), and updateChisquare().