Separate class for the V0 reconstruction parameters (M.Ivanov)
authorhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 21 Jun 2005 12:44:58 +0000 (12:44 +0000)
committerhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 21 Jun 2005 12:44:58 +0000 (12:44 +0000)
STEER/AliESDV0MI.cxx
STEER/AliESDV0MI.h
STEER/AliESDV0MIParams.cxx [new file with mode: 0644]
STEER/AliESDV0MIParams.h [new file with mode: 0644]
STEER/ESDLinkDef.h
STEER/libESD.pkg

index 1f66849..baa66a4 100644 (file)
 /* $Id$ */
 
 //-------------------------------------------------------------------------
+//
+//    Implementation of the ESD V0MI vertex class
+//            This class is part of the Event Data Summary
+//            set of classes and contains information about
+//            V0 kind vertexes generated by a neutral particle
+//    Numerical part - AliHelix functionality used             
+//    
+//    Likelihoods for Point angle, DCA and Causality defined => can be used as cut parameters
+//    HIGHLY recomended
+//                                 
+//    Quality information can be used as additional cut variables
+//
 //    Origin: Marian Ivanov marian.ivanov@cern.ch
 //-------------------------------------------------------------------------
 
@@ -28,6 +40,9 @@
 
 ClassImp(AliESDV0MI)
 
+AliESDV0MIParams  AliESDV0MI::fgkParams;
+
+
 AliESDV0MI::AliESDV0MI() :
   AliESDv0(),
   fParamP(),
@@ -56,6 +71,212 @@ AliESDV0MI::AliESDV0MI() :
   for (Int_t i=0;i<2;i++){fNormDCAPrim[0]=0;fNormDCAPrim[1]=0;}
 }
 
+Double_t AliESDV0MI::GetSigmaY(){
+  //
+  // return sigmay in y  at vertex position  using covariance matrix 
+  //
+  const Double_t * cp  = fParamP.GetCovariance();
+  const Double_t * cm  = fParamM.GetCovariance();
+  Double_t sigmay = cp[0]+cm[0]+ cp[5]*(fParamP.X()-fRr)*(fParamP.X()-fRr)+ cm[5]*(fParamM.X()-fRr)*(fParamM.X()-fRr);
+  return (sigmay>0) ? TMath::Sqrt(sigmay):100;
+}
+
+Double_t AliESDV0MI::GetSigmaZ(){
+  //
+  // return sigmay in y  at vertex position  using covariance matrix 
+  //
+  const Double_t * cp  = fParamP.GetCovariance();
+  const Double_t * cm  = fParamM.GetCovariance();
+  Double_t sigmaz = cp[2]+cm[2]+ cp[9]*(fParamP.X()-fRr)*(fParamP.X()-fRr)+ cm[9]*(fParamM.X()-fRr)*(fParamM.X()-fRr);
+  return (sigmaz>0) ? TMath::Sqrt(sigmaz):100;
+}
+
+Double_t AliESDV0MI::GetSigmaD0(){
+  //
+  // Sigma parameterization using covariance matrix
+  //
+  // sigma of distance between two tracks in vertex position 
+  // sigma of DCA is proportianal to sigmaD0
+  // factor 2 difference is explained by the fact that the DCA is calculated at the position 
+  // where the tracks as closest together ( not exact position of the vertex)
+  //
+  const Double_t * cp      = fParamP.GetCovariance();
+  const Double_t * cm      = fParamM.GetCovariance();
+  Double_t sigmaD0   = cp[0]+cm[0]+cp[2]+cm[2]+fgkParams.fPSigmaOffsetD0*fgkParams.fPSigmaOffsetD0;
+  sigmaD0           += ((fParamP.X()-fRr)*(fParamP.X()-fRr))*(cp[5]+cp[9]);
+  sigmaD0           += ((fParamM.X()-fRr)*(fParamM.X()-fRr))*(cm[5]+cm[9]);
+  return (sigmaD0>0)? TMath::Sqrt(sigmaD0):100;
+}
+
+
+Double_t AliESDV0MI::GetSigmaAP0(){
+  //
+  //Sigma parameterization using covariance matrices
+  //
+  Double_t prec  = TMath::Sqrt((fPM[0]+fPP[0])*(fPM[0]+fPP[0])
+                              +(fPM[1]+fPP[1])*(fPM[1]+fPP[1])
+                              +(fPM[2]+fPP[2])*(fPM[2]+fPP[2]));
+  Double_t normp = TMath::Sqrt(fPP[0]*fPP[0]+fPP[1]*fPP[1]+fPP[2]*fPP[2])/prec;  // fraction of the momenta
+  Double_t normm = TMath::Sqrt(fPM[0]*fPM[0]+fPM[1]*fPM[1]+fPM[2]*fPM[2])/prec;  
+  const Double_t * cp      = fParamP.GetCovariance();
+  const Double_t * cm      = fParamM.GetCovariance();
+  Double_t sigmaAP0 = fgkParams.fPSigmaOffsetAP0*fgkParams.fPSigmaOffsetAP0;                           // minimal part
+  sigmaAP0 +=  (cp[5]+cp[9])*(normp*normp)+(cm[5]+cm[9])*(normm*normm);          // angular resolution part
+  Double_t sigmaAP1 = GetSigmaD0()/(TMath::Abs(fRr)+0.01);                       // vertex position part
+  sigmaAP0 +=  0.5*sigmaAP1*sigmaAP1;                              
+  return (sigmaAP0>0)? TMath::Sqrt(sigmaAP0):100;
+}
+
+Double_t AliESDV0MI::GetEffectiveSigmaD0(){
+  //
+  // minimax - effective Sigma parameterization 
+  // p12 effective curvature and v0 radius postion used as parameters  
+  //  
+  Double_t p12 = TMath::Sqrt(fParamP.GetParameter()[4]*fParamP.GetParameter()[4]+
+                            fParamM.GetParameter()[4]*fParamM.GetParameter()[4]);
+  Double_t sigmaED0= TMath::Max(TMath::Sqrt(fRr)-fgkParams.fPSigmaRminDE,0.0)*fgkParams.fPSigmaCoefDE*p12*p12;
+  sigmaED0*= sigmaED0;
+  sigmaED0*= sigmaED0;
+  sigmaED0 = TMath::Sqrt(sigmaED0+fgkParams.fPSigmaOffsetDE*fgkParams.fPSigmaOffsetDE);
+  return (sigmaED0<fgkParams.fPSigmaMaxDE) ? sigmaED0: fgkParams.fPSigmaMaxDE;
+}
+
+
+Double_t AliESDV0MI::GetEffectiveSigmaAP0(){
+  //
+  // effective Sigma parameterization of point angle resolution 
+  //
+  Double_t p12 = TMath::Sqrt(fParamP.GetParameter()[4]*fParamP.GetParameter()[4]+
+                            fParamM.GetParameter()[4]*fParamM.GetParameter()[4]);
+  Double_t sigmaAPE= fgkParams.fPSigmaBase0APE;
+  sigmaAPE+= fgkParams.fPSigmaR0APE/(fgkParams.fPSigmaR1APE+fRr);
+  sigmaAPE*= (fgkParams.fPSigmaP0APE+fgkParams.fPSigmaP1APE*p12);
+  sigmaAPE = TMath::Min(sigmaAPE,fgkParams.fPSigmaMaxAPE);
+  return sigmaAPE;
+}
+
+
+Double_t  AliESDV0MI::GetMinimaxSigmaAP0(){
+  //
+  // calculate mini-max effective sigma of point angle resolution
+  //
+  //compv0->fTree->SetAlias("SigmaAP2","max(min((SigmaAP0+SigmaAPE0)*0.5,1.5*SigmaAPE0),0.5*SigmaAPE0+0.003)");
+  Double_t    effectiveSigma = GetEffectiveSigmaAP0();
+  Double_t    sigmaMMAP = 0.5*(GetSigmaAP0()+effectiveSigma);
+  sigmaMMAP  = TMath::Min(sigmaMMAP, fgkParams.fPMaxFractionAP0*effectiveSigma);
+  sigmaMMAP  = TMath::Max(sigmaMMAP, fgkParams.fPMinFractionAP0*effectiveSigma+fgkParams.fPMinAP0);
+  return sigmaMMAP;
+}
+Double_t  AliESDV0MI::GetMinimaxSigmaD0(){
+  //
+  // calculate mini-max sigma of dca resolution
+  // 
+  //compv0->fTree->SetAlias("SigmaD2","max(min((SigmaD0+SigmaDE0)*0.5,1.5*SigmaDE0),0.5*SigmaDE0)");
+  Double_t    effectiveSigma = GetEffectiveSigmaD0();
+  Double_t    sigmaMMD0 = 0.5*(GetSigmaD0()+effectiveSigma);
+  sigmaMMD0  = TMath::Min(sigmaMMD0, fgkParams.fPMaxFractionD0*effectiveSigma);
+  sigmaMMD0  = TMath::Max(sigmaMMD0, fgkParams.fPMinFractionD0*effectiveSigma+fgkParams.fPMinD0);
+  return sigmaMMD0;
+}
+
+
+Double_t AliESDV0MI::GetLikelihoodAP(Int_t mode0, Int_t mode1){
+  //
+  // get likelihood for point angle
+  //
+  Double_t sigmaAP = 0.007;            //default sigma
+  switch (mode0){
+  case 0:
+    sigmaAP = GetSigmaAP0();           // mode 0  - covariance matrix estimates used 
+    break;
+  case 1:
+    sigmaAP = GetEffectiveSigmaAP0();  // mode 1 - effective sigma used
+    break;
+  case 2:
+    sigmaAP = GetMinimaxSigmaAP0();    // mode 2 - minimax sigma
+    break;
+  }
+  Double_t apNorm = TMath::Min(TMath::ACos(fPointAngle)/sigmaAP,50.);  
+  //normalized point angle, restricted - because of overflow problems in Exp
+  Double_t likelihood = 0;
+  switch(mode1){
+  case 0:
+    likelihood = TMath::Exp(-0.5*apNorm*apNorm);   
+    // one component
+    break;
+  case 1:
+    likelihood = (TMath::Exp(-0.5*apNorm*apNorm)+0.5* TMath::Exp(-0.25*apNorm*apNorm))/1.5;
+    // two components
+    break;
+  case 2:
+    likelihood = (TMath::Exp(-0.5*apNorm*apNorm)+0.5* TMath::Exp(-0.25*apNorm*apNorm)+0.25*TMath::Exp(-0.125*apNorm*apNorm))/1.75;
+    // three components
+    break;
+  }
+  return likelihood;
+}
+
+Double_t AliESDV0MI::GetLikelihoodD(Int_t mode0, Int_t mode1){
+  //
+  // get likelihood for DCA
+  //
+  Double_t sigmaD = 0.03;            //default sigma
+  switch (mode0){
+  case 0:
+    sigmaD = GetSigmaD0();           // mode 0  - covariance matrix estimates used 
+    break;
+  case 1:
+    sigmaD = GetEffectiveSigmaD0();  // mode 1 - effective sigma used
+    break;
+  case 2:
+    sigmaD = GetMinimaxSigmaD0();    // mode 2 - minimax sigma
+    break;
+  }
+  Double_t dNorm = TMath::Min(fDist2/sigmaD,50.);  
+  //normalized point angle, restricted - because of overflow problems in Exp
+  Double_t likelihood = 0;
+  switch(mode1){
+  case 0:
+    likelihood = TMath::Exp(-2.*dNorm);   
+    // one component
+    break;
+  case 1:
+    likelihood = (TMath::Exp(-2.*dNorm)+0.5* TMath::Exp(-dNorm))/1.5;
+    // two components
+    break;
+  case 2:
+    likelihood = (TMath::Exp(-2.*dNorm)+0.5* TMath::Exp(-dNorm)+0.25*TMath::Exp(-0.5*dNorm))/1.75;
+    // three components
+    break;
+  }
+  return likelihood;
+
+}
+
+Double_t AliESDV0MI::GetLikelihoodC(Int_t mode0, Int_t /*mode1*/){
+  //
+  // get likelihood for Causality
+  // !!!  Causality variables defined in AliITStrackerMI !!! 
+  //      when more information was available
+  //  
+  Double_t likelihood = 0.5;
+  Double_t minCausal  = TMath::Min(fCausality[0],fCausality[1]);
+  Double_t maxCausal  = TMath::Max(fCausality[0],fCausality[1]);
+  //  minCausal           = TMath::Max(minCausal,0.5*maxCausal);
+  //compv0->fTree->SetAlias("LCausal","(1.05-(2*(0.8-exp(-max(RC.fV0rec.fCausality[0],RC.fV0rec.fCausality[1])))+2*(0.8-exp(-min(RC.fV0rec.fCausality[0],RC.fV0rec.fCausality[1]))))/2)**4");
+  
+  switch(mode0){
+  case 0:
+    //normalization 
+    likelihood = TMath::Power((1.05-2*(0.8-TMath::Exp(-maxCausal))),4.);
+    break;
+  case 1:
+    likelihood = TMath::Power(1.05-(2*(0.8-TMath::Exp(-maxCausal))+(2*(0.8-TMath::Exp(-minCausal))))*0.5,4.);
+    break;
+  }
+  return likelihood;
+  
+}
 
 void AliESDV0MI::SetCausality(Float_t pb0, Float_t pb1, Float_t pa0, Float_t pa1)
 {
@@ -300,7 +521,8 @@ void  AliESDV0MI::Update(Float_t vertex[3])
   Double_t v[3] = {fXr[0]-vertex[0],fXr[1]-vertex[1],fXr[2]-vertex[2]};
   Double_t p[3] = {fPP[0]+fPM[0], fPP[1]+fPM[1],fPP[2]+fPM[2]};
   Double_t vnorm2 = v[0]*v[0]+v[1]*v[1];
-  Double_t vnorm3 = TMath::Sqrt(v[2]*v[2]+vnorm2);
+  if (TMath::Abs(v[2])>100000) return;
+  Double_t vnorm3 = TMath::Sqrt(TMath::Abs(v[2]*v[2]+vnorm2));
   vnorm2 = TMath::Sqrt(vnorm2);
   Double_t pnorm2 = p[0]*p[0]+p[1]*p[1];
   Double_t pnorm3 = TMath::Sqrt(p[2]*p[2]+pnorm2);
index 640440c..4e86072 100644 (file)
 //-------------------------------------------------------------------------
 
 #include "AliESDv0.h"
+#include "AliESDV0MIParams.h"
 #include "AliExternalTrackParam.h"
 
 class AliESDtrack;
 
+
 class AliESDV0MI :  public AliESDv0 {
 public:
   //  friend class AliITStrackerMI;
   AliESDV0MI();             //constructor
+  Double_t GetSigmaY();     // sigma of y coordinate at vertex posistion
+  Double_t GetSigmaZ();     // sigma of z coordinate at vertex posistion
+  Double_t GetSigmaAP0();   // calculate sigma of Point angle resolution at vertex pos.
+  Double_t GetSigmaD0();    // calculate sigma of position resolution at vertex pos.
+  Double_t GetEffectiveSigmaAP0();   // calculate sigma of point angle resolution at vertex pos. effecive parameterization
+  Double_t GetEffectiveSigmaD0();    // calculate sigma of position resolution at vertex pos.
+  Double_t GetMinimaxSigmaAP0();    // calculate mini-max sigma of point angle resolution
+  Double_t GetMinimaxSigmaD0();     // calculate mini-max sigma of dca resolution
+  Double_t GetLikelihoodAP(Int_t mode0, Int_t mode1);   // get likelihood for point angle
+  Double_t GetLikelihoodD(Int_t mode0, Int_t mode1);    // get likelihood for DCA
+  Double_t GetLikelihoodC(Int_t mode0, Int_t mode1);    // get likelihood for Causality
+  //
   //
   const AliExternalTrackParam *GetParamP() const {return &fParamP;}
   const AliExternalTrackParam *GetParamM() const {return &fParamM;}
+  static const AliESDV0MIParams & GetParameterization(){return fgkParams;}
   void SetP(const AliExternalTrackParam & paramp); 
   void SetM(const AliExternalTrackParam & paramd);
   void SetRp(const Double_t *rp);
@@ -69,19 +84,19 @@ public:
   void SetClusters(Int_t *clp, Int_t *clm);
   const Int_t * GetClusters(Int_t i) const {return fClusters[i];}
   void SetNormDCAPrim(Float_t nd0, Float_t nd1){fNormDCAPrim[0] = nd0; fNormDCAPrim[1]=nd1;}
-  const Float_t  *GetNormDCAPrimP(){return fNormDCAPrim;}
+  const Float_t  *GetNormDCAPrimP() const {return fNormDCAPrim;}
 private:
-  AliExternalTrackParam fParamP;
-  AliExternalTrackParam fParamM;
+  AliExternalTrackParam fParamP;  // external parameters of positive particle
+  AliExternalTrackParam fParamM;  // external parameters of negative particle
   Float_t        fRP[5];         // combined pid positive
   Float_t        fRM[5];         // combined pid positive
-  Int_t          fID;
+  Int_t          fID;            // ID number of the V0 in the ESDV0 container
   Int_t          fLab[2];         // MC label of the particle
   Int_t          fIndex[2];       // reconstructed labels of the tracks
   Int_t          fClusters[2][6]; //! its clusters 
   //
   //  
-  Float_t       fNormDCAPrim[2];  // normalize distance to the priary vertex
+  Float_t        fNormDCAPrim[2];  // normalize distance to the priary vertex
   Double_t       fDist1;    //info about closest distance according closest MC - linear DCA
   Double_t       fDist2;    //info about closest distance parabolic DCA
   //
@@ -91,7 +106,7 @@ private:
   Double_t       fXr[3];      //rec. position according helix
   Double_t       fAngle[3];   //three angles
   Double_t       fRr;         //rec position of the vertex 
-  Int_t          fStatus;       //status  - 1 - TPC V0  2- ITS V0  4- accepted - 0 -rejected
+  Int_t          fStatus;       //status
   Int_t          fRow0;         // critical layer
   Int_t          fOrder[3]; //order of the vertex 
   //  quality information
@@ -105,7 +120,9 @@ private:
   Float_t        fPointAngleFi; //point angle fi
   Float_t        fPointAngleTh; //point angle theta
   Double_t       fPointAngle;   //point angle full
-
+  //
+  // parameterization coefficients
+  static AliESDV0MIParams fgkParams;  // resolution and likelihood parameterization  
   ClassDef(AliESDV0MI,4)      // ESD V0 vertex
 };
 
diff --git a/STEER/AliESDV0MIParams.cxx b/STEER/AliESDV0MIParams.cxx
new file mode 100644 (file)
index 0000000..98c792d
--- /dev/null
@@ -0,0 +1,77 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+
+//-------------------------------------------------------------------------
+//            Helper -DATA  class ESD V0MI vertex class
+//            contains effective errror parameterization 
+//            Effective parameterization of resolution in DCA and PA  as function of radii and momenta
+//            Mini-max coeficient    fPMinFraction... fPMaxFraction...
+//                                   as limits for Error parameterization using Covariance matrix             
+//            For detailes : see  AliESDV0MI class   
+//             
+//    Origin: Marian Ivanov marian.ivanov@cern.ch
+//-------------------------------------------------------------------------
+
+
+#include "AliESDV0MIParams.h"
+
+
+ClassImp(AliESDV0MIParams)
+
+
+AliESDV0MIParams::AliESDV0MIParams(){
+  //
+  // Default constructor
+  // Consult AliESDV0MI to see actual error parameterization 
+  //
+
+  //
+  // This constants are used in the error parameterization using covariance matrix
+  // minimal sigma in AP and DCA 
+  fPSigmaOffsetD0 = 0.03;      // minimal sigma of error estimate
+  fPSigmaOffsetAP0 = 0.005;    // 
+  //
+  // Effective parameterization of DCA resolution as function of pt and decay radii
+  //
+  fPSigmaMaxDE    = 0.5;
+  fPSigmaOffsetDE = 0.06;
+  fPSigmaCoefDE   = 0.02;
+  fPSigmaRminDE   = 2.7;
+  //
+  //
+  // Effective parameterization of PA resolution as function of pt and decay radii
+  //
+  fPSigmaBase0APE  = 0.005;
+  fPSigmaMaxAPE    = 0.06;
+  fPSigmaR0APE     = 0.02;
+  fPSigmaR1APE     = 0.1; 
+  fPSigmaP0APE     = 0.7*0.4;
+  fPSigmaP1APE     = 0.3*0.4;
+  //
+  //
+  // Minimax parameters
+  //
+  fPMinFractionAP0 =0.5;
+  fPMaxFractionAP0 =1.5;
+  fPMinAP0         =0.003;
+  fPMinFractionD0 =0.5;
+  fPMaxFractionD0 =1.5;
+  fPMinD0         =0.05;
+  //
+}
+
+
+
diff --git a/STEER/AliESDV0MIParams.h b/STEER/AliESDV0MIParams.h
new file mode 100644 (file)
index 0000000..29d1c19
--- /dev/null
@@ -0,0 +1,50 @@
+#ifndef ALIESDV0MIPARAMS_H
+#define ALIESDV0MIPARAMS_H
+
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+
+//-------------------------------------------------------------------------
+//                          ESD V0 Vertex Class - parameterization 
+//          This class is part of the Event Summary Data set of classes
+//    Origin: Marian Ivanov marian.ivanov@cern.ch
+//-------------------------------------------------------------------------
+
+#include "TObject.h"
+
+class AliESDV0MIParams : public TObject{
+  friend class AliESDV0MI;
+ public:
+  AliESDV0MIParams();
+ private:
+  Double_t  fPSigmaOffsetD0;        // sigma offset DCA
+  Double_t  fPSigmaOffsetAP0;       // sigma offset AP
+  // effective sigma DCA params    
+  Double_t  fPSigmaMaxDE;           // maximal allowed sigma DCA
+  Double_t  fPSigmaOffsetDE;        // offset sigma DCA
+  Double_t  fPSigmaCoefDE;          // sigma coefiecient 
+  Double_t  fPSigmaRminDE;          // max radius  - with momentum dependence 
+  // effective sigma PA params
+  Double_t  fPSigmaBase0APE;        // base sigma PA
+  Double_t  fPSigmaMaxAPE;          // maximal sigma PA
+  Double_t  fPSigmaR0APE;           // radial dependent part   - coeficient
+  Double_t  fPSigmaR1APE;           // radial dependent part   - offset 
+  Double_t  fPSigmaP0APE;           // momentum dependent part - coeficient
+  Double_t  fPSigmaP1APE;           // momentum dependent part - offset
+  // minimax parameters
+  Double_t fPMinFractionAP0;        // minimal allowed fraction of effective params - PA
+  Double_t fPMaxFractionAP0;        // maximal allowed fraction of effective params - PA
+  Double_t fPMinAP0;                // minimal minimax - PA sigma 
+  //
+  Double_t fPMinFractionD0;         // minimal allowed fraction of effective params - DCA
+  Double_t fPMaxFractionD0;         // maximal allowed fraction of effective params - DCA
+  Double_t fPMinD0;                 // minimal minimax - DCA sigma
+  //
+  ClassDef(AliESDV0MIParams,1)      // ESD V0 vertex - error and likelihood parameterization constant
+};
+
+
+
+#endif
index 57a9a4b..9718b11 100644 (file)
@@ -21,6 +21,7 @@
 #pragma link C++ class  AliESDpid+;
 #pragma link C++ class  AliESDkink+;
 #pragma link C++ class  AliESDV0MI+;
+#pragma link C++ class  AliESDV0MIParams+;
 
 #pragma link C++ class  AliKalmanTrack+;
 #pragma link C++ class  AliHelix+;
index 1b8e1dc..7ccc1d1 100644 (file)
@@ -4,7 +4,7 @@ SRCS = AliESD.cxx \
        AliESDv0.cxx AliESDcascade.cxx AliESDVertex.cxx \
        AliESDpid.cxx AliESDkink.cxx AliESDV0MI.cxx \
        AliKalmanTrack.cxx AliHelix.cxx AliExternalTrackParam.cxx \
-       AliTrackParam.cxx AliLog.cxx AliPID.cxx
+       AliTrackParam.cxx AliLog.cxx AliPID.cxx AliESDV0MIParams.cxx
 
 HDRS:= $(SRCS:.cxx=.h)