Vertex Fitters

OfflineVertexFitter

Developer: Yuehong Xie

As the name suggests, this is a vertex fitter used for secondary vertex fitting in the offline data analysis. It is now the default vertex fitter in DaVinci. The fitter takes as input a vector of particles, performs the fit and updates the mother particle. Note the input particles are not modified after the fit.

In the first step, the fitter classifies the input particles into the following four categories:

• Flying: A Flying particle is one that flies a considerably long distance before it decays. Charged basic particles (kaon, pion, muon, electron and proton), Kshort, neutral and charged D mesons, Ds meson are all in this categoy.
• Vertexed: A Vertexed particle is a particle with a reconstructible and reconstructed vertex, which has at least two flying particles or at least one vertexed particles as its daughters. Examples include Jpsi, phi and D*+(->D0pi+).
• Photon: A Photon is just a photon with a calorimeter cluster. Photons convreted into e+e- in the detector are not considered so far.
• PhotonPair: This refers to pi0(->gammagamma) and eta(->gammagamma).

The classification is controlled by the option "useResonanceVertex". If "useResonanceVertex" is set to true (default), the fitter just classifies the particles given as input without checking their daughters. If "useResonanceVertex" is set to false, the fitter automatically decomposes all Vertexed particles into Flying particles, Photons and PhotonPairs.

If a composite particle is not Vertexed, it is also decomposed regardless of "useResonanceVertex". An example: D*0->D0gamma. In this case, The D0 and gamma are used in the fit instead of the D*0.

The basic idea is to factorize the fitting of a vertex into five types of actions:

• seeding: This is always the first action. It tries to find a Vertexed particle or form a vertex using two Flying particles. Failing this, the fit stops.
• addVertexed: If there are more than one Vertexed particles, their vertices are merged to the vertex of the seed vertex.
• addFlying: Flying particles are added to the seed vertex one by one.
• addPhoton: After all the Vertexed and Flying particles are added to the seed vertex, the seed vertex is assumed to be the production vertex of all Photons. The four momentum of a photon is recalculated and added to the four momentum associated with the seed vertex. The position and errors of the seed vertex are not changed. The covariance matrix between the vertex position and the mother particle momentum is updated.
• addPhotonPair: Similar to that done for a single photon. If mass constraint is required for the photon pair, this not only affects the four momentum of the PhotonPair, but also the vertex position and errors!

If the options "applyDauMassConstraint" (default: false) and "useResonanceVertex" (default: true) are set to true, the mass of any composite daughter whose decay width is less than a threshold controlled by the option "widthThreshold" (default: 2 MeV) is constrained to its nominal value.

An exception: no mass constraint is applied to composite particles which are not Vertexed, such as D*0->D0gamma. This can only be cured in a case by case way.

At the end of the vertex fit, the mother particle is updated with new four momentum, mass, vertex position, their covariance matrix, the vertex chi2 and the number of degrees of freedom obatined from the fit.

Note the chi2 of the vertex fit and the number of degrees of freedom may depend on the option "useResonanceVertex". Always check the number of degrees of freedom when you use the chi2 in your analysis. Take Bd->JpsiK* as an example. If "useResonanceVertex" is true, the number of degrees of freedom is 3. If "useResonanceVertex" is false, the number of degrees of freedom is 2*4-3=5.

Work to do

• Describe the method and technical details in a note.
• Add option to apply mass constraint on the mother particle.
• Provide the possibility to constrain particle mass to a given value different from the nominal value.
• Check consistency with particle transporters.
• Move the mass constraint before transporting a composite daughter particle
• Anything else?

Tips:

If you want to change the default behaviour of the OfflineVeretxFitter in your algorithm named YourAlgName, add this line in your option file

YourAlgName.OfflineVertexFitter.[property] = [new value] ;

E.g.,

YourAlgName.OfflineVertexFitter.useResonanceVertex= false ;

YourAlgName.OfflineVertexFitter.applyDauMassConstraint = true ;

TrgVertexFitter

LoKi::VertexFitter, aka BlindVertexFitter

Developer: Vanya Belyaev

BlindVertexFitter is probably the most trivial implementation of IVertexFit abstract interface. Unfortunately the implementation is not complete: the method remove(const LHCb::Particle*,LHCb::Vertex&) is not implemented (yet?). The fitter is completely "blind" with respect to the input particles:

• it does not check if the input particles are compound or basic
  • Note: it is not true anymore: it does check compound versus basic
• it does not check if the input particle are "flying" or "resonances"
  • Note: it is not true enymore: it does check "flying" versus "resonances"
• it does not check if the input particles are photon, diphotons ( ) etc..

It is a full responsibility of the client to prepare the particles for the vertex fit and to use them properly. Please also note that the tool implements also:

• IParticleCombiner abstract interface
• IParticleReFitter abstract interface

These two interfaces are the main interfaces for "combining" the particles and "refitting" them, and they play a major role in LoKi.

The tool internally used the formalism of Kalman Fitter. Since the inetrnal representation of the particle ("measurement") is a vector with 7-components the formalism becomes very simple and after the decomposition of all matrices it is just amazingly trivial and transparent.

Vertex fit as Kalman Filter

Let be a vector containing the parameters of the track. Let be the covariance matrix of these parameters, and is formal inverse matrix . for the trivial case of both matrices and could be defined properly and non-singular. Here we'll try to extend the standard Kalman Filter formalism for almost linear model, by embedding the minimal -model into more dimensions. In particular we choose the : The vertex fit determines the new parameters - position of the common vertex and - 4-momentum of the track, constrained to originate in .

The covariance matrix of fit parameters could be split into sub-matrices:

• the vertex part :
• particle momentum part :
• correlation between the vertex position and the particle momentum part :
• correlation between the momenta of different particles :

Such choice of and allows to obtain almost trivial projection matrices and :

Kalman filter proceeds in the following steps

1

initialize the vertex position by an estimate (guess) with covariance matrix (infinity) and .

2

add one particle after the other to the vertex and update the vertex fit: Let be the vertex position with the first tracks participating in the fit. The track is then included by the following recursion relations:

Covariance matrices:

, where

New fit values:

New :

3

Once all tracks are added, the fit parameters have to be smoothed, in order to update each filter step with the information of all measured particles:

4

The procedure need to be iterated with the measurement evaluated around the new (improved) fit parameters, until convergence is reached. In particular it need that the particle parameter vector need to be reevaluated in vicinity of the found vertex position . In spite of linear formalism of projection matrices, the iterations are necessary for proper extrapolation of parameter vector to the vertex position.

5

After the convergence, the covariance matrices of the smoothed fit parameters are computed:

With the chosen parameterization of one gets and .

Assuming the existence of the matrix and its block structure one can rewrite the equations as:

From these equations one sees that the blocks of the inverse covariance matrix enters into the expressions only through the combinations

• ,
• and
• .

Using the formal expression , one gets:

Finally one gets that Kalman Filter procedure (except for the expression for ) requires the validity of only the following matrix expressions:

In next section it is shown that these expression are always valid matrix expression, in spite of ill-defined matrices and .

Covariance Matrices

Lets consider the change of the track parameterization form canonical _state_-parameterization to the representation, adopted for the class LHCb::Particle as 2-step procedure , where

Obviously the covariance matrix for , is well-defined and non-singular: .

Both corresponding covariance matrices for the parameters and , and are either singular or not existing. It will be shown that one can define the formal inverse covariance matrix , but there is no way to define neither the proper matrix no the proper matrix .

The re-parameterization with fake parameter does not allow to write the sensible covariance matrix for . But one can write the formal expression for the inverse covariance matrix where

For simplicity the matrix could be represented as block matrix , where the matrices and has the structure and . Correspondingly .

Taking into account this block structures one writes:

Here the block representation of the matrix has been used . The matrix is singular, rank 5 matrix. It is worth to stress here that the upper top block is singular rank 2 matrix, while the lower right block in general is not singular and has the inverse matrix . The components of the formal inverse (fake) matrix are

The parameterization formally allows to express the covariance matrix through the fake matrix as , where

Here for simplicity the matrix is represented as block matrix, where matrix

has the structure correspondingly

Obviously the lower right block of this matrix is singular.

Making the comparison of these expressions one gets all formal expressions needed for Kalman Filter procedure:

In spite of the fact that neither the matrix nor matrices could be constructed explicitly all required expressions for Kalman Filter procedure are valid matrix expressions.

Implemented methods:

Following methods are implemented:

The vertex fitting method without creation of a Particle (IVertexFit interface)

 1000virtual StatusCode fit 
 1010  ( const LHCb::Particle::ConstVector& daughters ,
 1020    LHCb::Vertex&                      vertex    ) const ;  

The vertex fitting method with creation of LHCb::Particle ("classical") (IVertexFit interface)

 1000virtual StatusCode fit 
 1010  ( const LHCb::Particle::ConstVector& daughters ,
 1020    LHCb::Particle&        particle  ,
 1030    LHCb::Vertex&          vertex    ) const ;  

Add the particle to the vertex and refit (IVertexFit interface)

 1000virtual StatusCode add
 1010  ( const LHCb::Particle*  particle , 
 1020    LHCb::Vertex&          vertex   ) const ;  
 1030 

The method for "combining" the daughter particles into "mother" particle (IParticleCombiner interface)

 1000virtual StatusCode combine
 1010  ( const LHCb::Particle::ConstVector&  daughters ,  
 1020    LHCb::Particle&                     mother    , 
 1030    LHCb::Vertex&                       vertex    ) const  { return fit ( daughters , mother , vertex ) ; } ;

Please note that the method combine is reimplemented in a terms of fit, which guarantees the coherency between IParticleCombiner and IVertexFit actions.

The method for "refit" of the particle (IParticleReFitter interface)

 1000virtual StatusCode reFit ( LHCb::Particle& particle ) const  
 1010  {
 1020    LHCb::Vertex* vertex = particle.endVertex() ;
 1030    const IVertexFit* vFit = this ;
 1040    return vFit->fit ( vertex->outgoingParticles().begin() , 
 1050                       vertex->outgoingParticles().end  () , 
 1060                       particle , *vertex                  ) ; 
 1070  } ;

Please note that the method reFit is reimplemented in a terms of fit, which guarantees the coherency between IParticleReFitter and IVertexFit actions.

The method remove is not implemented yet.

The initial seed and iterations

If the (input) position of the vertex for the method fit belong to a fiducial cylinder, defined by minimal and maximal z and the maximal radius, the position of the vertex is considered as seed for the vertex fitter. It is a useful trick for re-fitting of the vertices and it is also a way to supply the tool with the information about the expected position of the vertex.

The iterations performed until the change in the vertex position is in excess of 1 micrometer and the change in the is in excess of 0.01 or the maximum number of iterations is reached.

Standard configuration in DaVinci

The tool is available in the standard default configurtaion of DaVinci algorithm under the following nicknames:

• "Blind"
• "Kalman"

 1000/// get the vertex fitter by nickname:
 1010IVertexFit* vfit1 = vertexFitter ( "Blind") ;
 1020
 1030/// get the vertex fitter by nickname:
 1040IVertexFit* vfit2 = vertexFitter ( "Blind") ;
 1050
 1060
 1070/// get the particle combiner by nickname:
 1080IParticleCombiner* pcomb1 = particleCombiner ( "Blind") ;
 1090
 1100/// get the particle combiner by nickname:
 1110IParticleCombiner* pcomb1 = particleCombiner ( "Kalman") ;
 1120
 1130
 1140// get the particle refitter by nickname:
 1150IParticleReFitter* rfit1 = particleReFitter ( "Blind" ) ;
 1160
 1170/// get the particle refitter by nickname:
 1180IParticleReFitter* rfit1 = particleReFitter ( "Kalman" ) ;

This mapping is under the control by the properties of class DVAlgorithm and could be modified:

 1000MyAlg.VertexFitters =  {
 1010   "Offline"  : "OfflineVertexFitter" ,
 1020   "Trigger" : "TrgVertexFitter" , 
 1030   "Kalman" : "BlindVertexFitter" ,
 1040   "Blind"   : "BlindVertexFitter" , 
 1050   "ParticleAdder" : "ParticleAdder"
 1060};
 1070
 1080MyAlg.ParticleCombiners =  {
 1090   ""          : "OfflineVertexFitter" , 
 1100   "Offline"  : "OfflineVertexFitter" ,
 1110   "Trigger" : "TrgVertexFitter" , 
 1120   "Kalman" : "BlindVertexFitter" ,
 1130   "Blind"   : "BlindVertexFitter" , 
 1140   "ParticleAdder" : "ParticleAdder"
 1150};
 1160
 1170MyAlg.ParticleReFitters =  {
 1180   ""          : "OfflineVertexFitter" , 
 1190   "Offline"  : "OfflineVertexFitter" , 
 1200   "Kalman" : "BlindVertexFitter" ,
 1210   "Blind"   : "BlindVertexFitter" , 
 1220   "ParticleAdder" : "ParticleAdder"
 1230};
 1240

The configuration of the tool itself

The tool has following specific p[roperties:

Property	Type	Default	Description
MaxIterations	int	10	The maximum allowed number of iterations for fit, combine & reFit methods
MaxIterationsForAdd	int	5	The maximum allowed number of iterations for add method
MaxIterationsFroRemove	int	5	The maximum allowed number of iterations for remove method
SeedZmin	double	-1.5 m	The z-min of the seed fiducial volume
SeedZmax	double	3.0 m	The z-max of the seed fiducial volume
SeedRho	double	50 cm	The rho-max of the seed fiducial volume
Transporter	string	""	The type/name of particle transporter tool to be used

The performance of the tool

The tool has been tested for comparisions with TrgVertexFitter and OfflineVertexFitter for the simple cases of and . For these simple cases the physical performance of BlindVertexFitter have been found to be very similar with OfflineVertexFitter:

• no difference in the fitted vertex positions have been observed within ,
• the sums of the eigenvalues of the covariance matrix for the vertex positions have been found to be equal with the relative precision at the percentage level.

Number of fit failures for random tracks is a bit larger while for the signal tracks which do form the vertex the number of failures is very small and statistically the same as the number of fit failures for OfflineVertexFitter.

CPU performance has been found to be just in between of TrgVertexFitter and OfflineVertexFitter. With maximal number of iterations equal to three the CPU perfrormance is very close to TrgVertexFitter.

ParticleAdder

Developers: Yasmine Amhis & Olivier Deschamps

ParticleAdder can be used for decays with typically one charged track in the final state and one neutral particle. Let us consider for example:

ParticleAdder simply computes the invariant mass of the system .

No vertexing is performed, an offset value for the vertex is set to -10000 mm.

Usage for selections written in python:

Seq.VertexFitters.update( { " " : ParticleAdder } )

--Yasmine Amhis -- 21 Nov 2008

-- Yuehong Xie - 26 Sep 2007

-- JuanPalacios - 29 Sep 2007

-- Vanya Belyaev - 29 Sep