X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=ITS%2FAliITStrackerMI.h;h=b84db3b55f217266854b104687fc44b6b683f8a4;hb=4235ca030bf219cd3ad927b8abf7f94471ceaca8;hp=bbd40520f01be72f1d344f2f8ab283d4a718690c;hpb=23197852b55a2f848f715a9f57e1dc811c9d3f50;p=u%2Fmrichter%2FAliRoot.git

diff --git a/ITS/AliITStrackerMI.h b/ITS/AliITStrackerMI.h
index bbd40520f01..b84db3b55f2 100644
--- a/ITS/AliITStrackerMI.h
+++ b/ITS/AliITStrackerMI.h
@@ -17,14 +17,18 @@ class TTree;
 class TTreeSRedirector;
 class AliESDEvent;
 
+class AliITSPlaneEff;
+class AliITSChannelStatus;
+class AliITSDetTypeRec;
+class AliPlaneEff;
+
 #include <TObjArray.h>
-#include "AliITSRecPoint.h"
+
 #include "AliITStrackMI.h"
-#include "AliITSPlaneEff.h"
-#include "AliITSChannelStatus.h"
-#include "AliITSDetTypeRec.h"
-#include "AliPlaneEff.h"
+#include "AliITSRecPoint.h"
 #include "AliTracker.h"
+#include "AliRefArray.h"
+#include "AliITSPIDResponse.h"
 
 //-------------------------------------------------------------------------
 class AliITStrackerMI : public AliTracker {
@@ -50,26 +54,38 @@ public:
 		 const AliITStrackMI *clusters, Bool_t extra=kFALSE, Bool_t planeeff=kFALSE);
   Bool_t RefitAt(Double_t x, AliITStrackMI *track, 
 		 const Int_t *clusters, Bool_t extra=kFALSE, Bool_t planeeff=kFALSE);
-  void SetupFirstPass(Int_t *flags, Double_t *cuts=0);
-  void SetupSecondPass(Int_t *flags, Double_t *cuts=0);
+  void SetupFirstPass(const Int_t *flags,const Double_t *cuts=0);
+  void SetupSecondPass(const Int_t *flags,const Double_t *cuts=0);
 
   void SetLastLayerToTrackTo(Int_t l=0) {fLastLayerToTrackTo=l;} 
-  void SetLayersNotToSkip(Int_t *l);
   void UseClusters(const AliKalmanTrack *t, Int_t from=0) const;
 
-  void  GetDCASigma(AliITStrackMI* track, Float_t & sigmarfi, Float_t &sigmaz);
+  void  GetDCASigma(const AliITStrackMI* track, Float_t & sigmarfi, Float_t &sigmaz);
   Double_t GetPredictedChi2MI(AliITStrackMI* track, const AliITSRecPoint *cluster,Int_t layer);
   Int_t UpdateMI(AliITStrackMI* track, const AliITSRecPoint* cl,Double_t chi2,Int_t layer) const;
   AliPlaneEff *GetPlaneEff() {return (AliPlaneEff*)fPlaneEff;}   // return the pointer to AliPlaneEff
-  void SetDetTypeRec(AliITSDetTypeRec *detTypeRec) {fDetTypeRec = detTypeRec; ReadBadFromDetTypeRec(); }
-
+  void SetDetTypeRec(const AliITSDetTypeRec *detTypeRec) {fkDetTypeRec = detTypeRec; ReadBadFromDetTypeRec(); }
+  TObjArray* GetTrackHypothesys()  {return &fTrackHypothesys;}
+  TObjArray* GetBestHypothesys()   {return &fBestHypothesys;}
+  TObjArray* GetOriginal()         {return &fOriginal;}
+  TTreeSRedirector *GetDebugStreamer() const {return fDebugStreamer;}
+  static Int_t CorrectForTPCtoITSDeadZoneMaterial(AliITStrackMI *t);
+  void  SetForceSkippingOfLayer();
+  Int_t ForceSkippingOfLayer(Int_t l) const { return fForceSkippingOfLayer[l]; }
+  //
+  // methods for debugging (RS) >>
+  Int_t FindClusterOfTrack(int label, int lr, int* store) const;
+  //  Int_t GetPattern(const AliITStrackMI* track, char* patt);
+  // methods for debugging (RS) <<
+  //
   class AliITSdetector { 
   public:
-    AliITSdetector():fR(0),fPhi(0),fSinPhi(0),fCosPhi(0),fYmin(0),fYmax(0),fZmin(0),fZmax(0),fIsBad(kFALSE),fNChips(0),fChipIsBad(0) {}
-    AliITSdetector(Double_t r,Double_t phi):fR(r),fPhi(phi),fSinPhi(TMath::Sin(phi)),fCosPhi(TMath::Cos(phi)),fYmin(10000),fYmax(-1000),fZmin(10000),fZmax(-1000),fIsBad(kFALSE),fNChips(0),fChipIsBad(0) {}
+    AliITSdetector():fR(0),fRmisal(0),fPhi(0),fSinPhi(0),fCosPhi(0),fYmin(0),fYmax(0),fZmin(0),fZmax(0),fIsBad(kFALSE),fNChips(0),fChipIsBad(0) {}
+    AliITSdetector(Double_t r,Double_t phi):fR(r),fRmisal(r),fPhi(phi),fSinPhi(TMath::Sin(phi)),fCosPhi(TMath::Cos(phi)),fYmin(10000),fYmax(-1000),fZmin(10000),fZmax(-1000),fIsBad(kFALSE),fNChips(0),fChipIsBad(0) {}
     ~AliITSdetector() {if(fChipIsBad) delete [] fChipIsBad;}
     inline void GetGlobalXYZ( const AliITSRecPoint *cl, Double_t xyz[3]) const;
     Double_t GetR()   const {return fR;}
+    Double_t GetRmisal()   const {return fRmisal;}
     Double_t GetPhi() const {return fPhi;}
     Double_t GetYmin() const {return fYmin;}
     Double_t GetYmax() const {return fYmax;}
@@ -78,19 +94,21 @@ public:
     Bool_t   IsBad() const {return fIsBad;}
     Int_t    GetNChips() const {return fNChips;}
     Bool_t   IsChipBad(Int_t iChip) const {return (fChipIsBad ? fChipIsBad[iChip] : kFALSE);}
+    void SetRmisal(Double_t rmisal) {fRmisal = rmisal;}
     void SetYmin(Double_t min) {fYmin = min;}
     void SetYmax(Double_t max) {fYmax = max;}
     void SetZmin(Double_t min) {fZmin = min;}
     void SetZmax(Double_t max) {fZmax = max;}
     void SetBad() {fIsBad = kTRUE;}
-    void ReadBadDetectorAndChips(Int_t ilayer,Int_t idet,AliITSDetTypeRec *detTypeRec);
+    void ReadBadDetectorAndChips(Int_t ilayer,Int_t idet,const AliITSDetTypeRec *detTypeRec);
   private:
     AliITSdetector(const AliITSdetector& det);
     AliITSdetector & operator=(const AliITSdetector& det){
       this->~AliITSdetector();new(this) AliITSdetector(det);
       return *this;}
-    Double_t fR;    // polar coordinates 
-    Double_t fPhi;  // of this detector
+    Double_t fR;    // polar coordinates: r 
+    Double_t fRmisal;    // polar coordinates: r, with misalignment 
+    Double_t fPhi;  // polar coordinates: phi
     Double_t fSinPhi; // sin of phi;
     Double_t fCosPhi; // cos of phi 
     Double_t fYmin;   //  local y minimal
@@ -117,8 +135,8 @@ public:
     Double_t GetRoad() const {return fRoad;}
     Double_t GetR() const {return fR;}
     Int_t FindClusterIndex(Float_t z) const;
-    AliITSRecPoint *GetCluster(Int_t i) const {return i<fN? fClusters[i]:0;} 
-    Float_t         *GetWeight(Int_t i) {return i<fN ?&fClusterWeight[i]:0;}
+    AliITSRecPoint *GetCluster(Int_t i) const {return i<fN ? fClusters[i]:0;} 
+    Float_t  *GetWeight(Int_t i)  {return i<fN ? &fClusterWeight[i]:0;}
     AliITSdetector &GetDetector(Int_t n) const { return fDetectors[n]; }
     Int_t FindDetectorIndex(Double_t phi, Double_t z) const;
     Double_t GetThickness(Double_t y, Double_t z, Double_t &x0) const;
@@ -132,6 +150,7 @@ public:
     Int_t GetAccepted() const {return fAccepted;}    
     Int_t GetClusterTracks(Int_t i, Int_t j) const {return fClusterTracks[i][j];}
     void SetClusterTracks(Int_t i, Int_t j, Int_t c) {fClusterTracks[i][j]=c;}
+    Int_t FindClusterForLabel(Int_t label, Int_t *store) const; //RS
   protected:
     AliITSlayer(const AliITSlayer& layer);
     AliITSlayer & operator=(const AliITSlayer& layer){
@@ -144,32 +163,32 @@ public:
     Int_t fNdetectors;          // detectors/ladder
     AliITSdetector *fDetectors; // array of detectors
     Int_t fN;                   // number of clusters
-    AliITSRecPoint *fClusters[AliITSRecoParam::fgkMaxClusterPerLayer]; // pointers to clusters
-    Int_t        fClusterIndex[AliITSRecoParam::fgkMaxClusterPerLayer]; // pointers to clusters
-    Float_t fY[AliITSRecoParam::fgkMaxClusterPerLayer];                // y position of the clusters      
-    Float_t fZ[AliITSRecoParam::fgkMaxClusterPerLayer];                // z position of the clusters      
+    AliITSRecPoint *fClusters[AliITSRecoParam::kMaxClusterPerLayer]; // pointers to clusters
+    Int_t        fClusterIndex[AliITSRecoParam::kMaxClusterPerLayer]; // pointers to clusters
+    Float_t fY[AliITSRecoParam::kMaxClusterPerLayer];                // y position of the clusters      
+    Float_t fZ[AliITSRecoParam::kMaxClusterPerLayer];                // z position of the clusters      
     Float_t fYB[2];                                       // ymin and ymax
     //
-    AliITSRecPoint *fClusters5[6][AliITSRecoParam::fgkMaxClusterPerLayer5]; // pointers to clusters -     slice in y
-    Int_t        fClusterIndex5[6][AliITSRecoParam::fgkMaxClusterPerLayer5]; // pointers to clusters -     slice in y    
-    Float_t fY5[6][AliITSRecoParam::fgkMaxClusterPerLayer5];                // y position of the clusters  slice in y    
-    Float_t fZ5[6][AliITSRecoParam::fgkMaxClusterPerLayer5];                // z position of the clusters  slice in y 
+    AliITSRecPoint *fClusters5[6][AliITSRecoParam::kMaxClusterPerLayer5]; // pointers to clusters -     slice in y
+    Int_t        fClusterIndex5[6][AliITSRecoParam::kMaxClusterPerLayer5]; // pointers to clusters -     slice in y    
+    Float_t fY5[6][AliITSRecoParam::kMaxClusterPerLayer5];                // y position of the clusters  slice in y    
+    Float_t fZ5[6][AliITSRecoParam::kMaxClusterPerLayer5];                // z position of the clusters  slice in y 
     Int_t fN5[6];                                       // number of cluster in slice
     Float_t fDy5;                                       //delta y
     Float_t fBy5[6][2];                                    //slice borders
     //
-    AliITSRecPoint *fClusters10[11][AliITSRecoParam::fgkMaxClusterPerLayer10]; // pointers to clusters -     slice in y
-    Int_t        fClusterIndex10[11][AliITSRecoParam::fgkMaxClusterPerLayer10]; // pointers to clusters -     slice in y    
-    Float_t fY10[11][AliITSRecoParam::fgkMaxClusterPerLayer10];                // y position of the clusters  slice in y    
-    Float_t fZ10[11][AliITSRecoParam::fgkMaxClusterPerLayer10];                // z position of the clusters  slice in y 
+    AliITSRecPoint *fClusters10[11][AliITSRecoParam::kMaxClusterPerLayer10]; // pointers to clusters -     slice in y
+    Int_t        fClusterIndex10[11][AliITSRecoParam::kMaxClusterPerLayer10]; // pointers to clusters -     slice in y    
+    Float_t fY10[11][AliITSRecoParam::kMaxClusterPerLayer10];                // y position of the clusters  slice in y    
+    Float_t fZ10[11][AliITSRecoParam::kMaxClusterPerLayer10];                // z position of the clusters  slice in y 
     Int_t fN10[11];                                       // number of cluster in slice
     Float_t fDy10;                                        // delta y
     Float_t fBy10[11][2];                                 // slice borders
     //
-    AliITSRecPoint *fClusters20[21][AliITSRecoParam::fgkMaxClusterPerLayer20]; // pointers to clusters -     slice in y
-    Int_t        fClusterIndex20[21][AliITSRecoParam::fgkMaxClusterPerLayer20]; // pointers to clusters -     slice in y    
-    Float_t fY20[21][AliITSRecoParam::fgkMaxClusterPerLayer20];                // y position of the clusters  slice in y    
-    Float_t fZ20[21][AliITSRecoParam::fgkMaxClusterPerLayer20];                // z position of the clusters  slice in y 
+    AliITSRecPoint *fClusters20[21][AliITSRecoParam::kMaxClusterPerLayer20]; // pointers to clusters -     slice in y
+    Int_t        fClusterIndex20[21][AliITSRecoParam::kMaxClusterPerLayer20]; // pointers to clusters -     slice in y    
+    Float_t fY20[21][AliITSRecoParam::kMaxClusterPerLayer20];                // y position of the clusters  slice in y    
+    Float_t fZ20[21][AliITSRecoParam::kMaxClusterPerLayer20];                // z position of the clusters  slice in y 
     Int_t fN20[21];                                       // number of cluster in slice
     Float_t fDy20;                                        //delta y 
     Float_t fBy20[21][2];                                 //slice borders
@@ -181,8 +200,9 @@ public:
     Int_t    fNcs;                                        //number of clusters in current slice    
     Int_t fCurrentSlice;                                  //current slice
     //
-    Float_t  fClusterWeight[AliITSRecoParam::fgkMaxClusterPerLayer]; // probabilistic weight of the cluster
-    Int_t    fClusterTracks[4][AliITSRecoParam::fgkMaxClusterPerLayer]; //tracks registered to given cluster
+    Float_t  fClusterWeight[AliITSRecoParam::kMaxClusterPerLayer]; // probabilistic weight of the cluster
+    Int_t    fClusterTracks[4][AliITSRecoParam::kMaxClusterPerLayer]; //tracks registered to given cluster
+    Float_t fZmin;      //    the
     Float_t fZmax;      //    edges
     Float_t fYmin;      //   of  the
     Float_t fYmax;      //   "window"
@@ -191,19 +211,25 @@ public:
     Int_t fSkip;     // indicates possibility to skip cluster
     Int_t fAccepted;     // accept indicator 
     Double_t fRoad;      // road defined by the cluster density
+    Double_t fMaxSigmaClY; // maximum cluster error Y (to enlarge road)
+    Double_t fMaxSigmaClZ; // maximum cluster error Z (to enlarge road)
+    Double_t fNMaxSigmaCl; // number of sigma for road enlargement
   };
   AliITStrackerMI::AliITSlayer    & GetLayer(Int_t layer) const;
   AliITStrackerMI::AliITSdetector & GetDetector(Int_t layer, Int_t n) const {return GetLayer(layer).GetDetector(n); }
-
-protected:
   Int_t GetNearestLayer(const Double_t *xr) const;  //get nearest upper layer close to the point xr
-  void FindV02(AliESDEvent *event);  //try to find V0
-  void RefitV02(AliESDEvent *event);  //try to refit  V0's
-  void UpdateTPCV0(AliESDEvent *event);  //try to update, or reject TPC  V0s
+  void SetCurrentEsdTrack(Int_t i) {fCurrentEsdTrack=i;}
+  void FollowProlongationTree(AliITStrackMI * otrack, Int_t esdindex, Bool_t constrain);
+  //
+  void   FlagFakes(const TObjArray &itsTracks);
+  //
+protected:
+  Bool_t ComputeRoad(AliITStrackMI* track,Int_t ilayer,Int_t idet,Double_t &zmin,Double_t &zmax,Double_t &ymin,Double_t &ymax) const;
+    
   void CookLabel(AliKalmanTrack *t,Float_t wrong) const;
   void CookLabel(AliITStrackMI *t,Float_t wrong) const;
   Double_t GetEffectiveThickness();
-  void FollowProlongationTree(AliITStrackMI * otrack, Int_t esdindex, Bool_t constrain);
+  Int_t    GetEffectiveThicknessLbyL(Double_t* xMS, Double_t* x2x0MS);
   void ResetBestTrack() {
      fBestTrack.~AliITStrackMI();
      new(&fBestTrack) AliITStrackMI(fTrackToFollow);
@@ -213,28 +239,40 @@ protected:
      new(&fTrackToFollow) AliITStrackMI(t);
   }
   void CookdEdx(AliITStrackMI* track);
+
+  Int_t GetParticleId(const AliESDtrack* track) const{
+    ULong_t trStatus=track->GetStatus();
+    Bool_t isSA=kTRUE;
+    if(trStatus&AliESDtrack::kTPCin) isSA=kFALSE;
+    return fITSPid->GetParticleIdFromdEdxVsP(track->P(),track->GetITSsignal(),isSA);
+  }
+  Int_t GetParticleId(const AliITStrackV2* track) const{
+    if(track->GetESDtrack()) return GetParticleId(track->GetESDtrack());
+    return fITSPid->GetParticleIdFromdEdxVsP(track->P(),track->GetdEdx(),kFALSE);
+  }
+
   Double_t GetNormalizedChi2(AliITStrackMI * track, Int_t mode);
-  Double_t GetTruncatedChi2(AliITStrackMI * track, Float_t fac);
+  Double_t GetTruncatedChi2(const AliITStrackMI * track, Float_t fac);
   Double_t NormalizedChi2(AliITStrackMI * track, Int_t layer);
-  Double_t GetInterpolatedChi2(AliITStrackMI * forwardtrack, AliITStrackMI * backtrack);  
-  Double_t GetMatchingChi2(AliITStrackMI * track1, AliITStrackMI * track2);
-  Double_t GetSPDDeadZoneProbability(Double_t zpos, Double_t zerr);
+  Double_t GetInterpolatedChi2(const AliITStrackMI * forwardtrack,const AliITStrackMI * backtrack);  
+  Double_t GetMatchingChi2(const AliITStrackMI * track1,const AliITStrackMI * track2);
+  Double_t GetSPDDeadZoneProbability(Double_t zpos, Double_t zerr) const;
 
   Float_t    *GetWeight(Int_t index);
   void AddTrackHypothesys(AliITStrackMI * track, Int_t esdindex);
   void SortTrackHypothesys(Int_t esdindex, Int_t maxcut, Int_t mode);
   AliITStrackMI * GetBestHypothesys(Int_t esdindex, AliITStrackMI * original, Int_t checkmax); 
   void  GetBestHypothesysMIP(TObjArray &itsTracks); 
-  void RegisterClusterTracks(AliITStrackMI* track, Int_t id);
-  void UnRegisterClusterTracks(AliITStrackMI* track, Int_t id);
+  void RegisterClusterTracks(const AliITStrackMI* track, Int_t id);
+  void UnRegisterClusterTracks(const AliITStrackMI* track, Int_t id);
   Float_t GetNumberOfSharedClusters(AliITStrackMI* track,Int_t id, Int_t list[6], AliITSRecPoint *clist[6]);
-  Int_t GetOverlapTrack(AliITStrackMI *track, Int_t trackID, Int_t &shared, Int_t clusterlist[6], Int_t overlist[6]);
-  AliITStrackMI * GetBest2Tracks(Int_t trackID1, Int_t treackID2, Float_t th0, Float_t th1);
+  Int_t GetOverlapTrack(const AliITStrackMI *track, Int_t trackID, Int_t &shared, Int_t clusterlist[6], Int_t overlist[6]);
+  AliITStrackMI * GetBest2Tracks(Int_t trackID1, Int_t treackID2, Float_t th0, Float_t th1,AliITStrackMI* original);
   Float_t  * GetErrY(Int_t trackindex) const {return &fCoefficients[trackindex*48];}
   Float_t  * GetErrZ(Int_t trackindex) const {return &fCoefficients[trackindex*48+12];}
   Float_t  * GetNy(Int_t trackindex) const {return &fCoefficients[trackindex*48+24];}
   Float_t  * GetNz(Int_t trackindex) const {return &fCoefficients[trackindex*48+36];}
-  void       SignDeltas( TObjArray *ClusterArray, Float_t zv);
+  void       SignDeltas(const TObjArray *clusterArray, Float_t zv);
   void MakeCoefficients(Int_t ntracks);
   void BuildMaterialLUT(TString material);
   void MakeTrksMaterialLUT(Int_t ntracks);
@@ -244,14 +282,14 @@ protected:
   Int_t CorrectForLayerMaterial(AliITStrackMI *t, Int_t layerindex, Double_t oldGlobXYZ[3], TString direction="inward");
   void UpdateESDtrack(AliITStrackMI* track, ULong_t flags) const;
   void ReadBadFromDetTypeRec();
-  Int_t CheckSkipLayer(AliITStrackMI *track,Int_t ilayer,Int_t idet) const;
-  Int_t CheckDeadZone(AliITStrackMI *track,Int_t ilayer,Int_t idet,Double_t zmin,Double_t zmax,Double_t ymin,Double_t ymax,Bool_t noClusters=kFALSE) const;
-  Bool_t LocalModuleCoord(Int_t ilayer,Int_t idet,AliITStrackMI *track,
+  Int_t CheckSkipLayer(const AliITStrackMI *track,Int_t ilayer,Int_t idet) const;
+  Int_t CheckDeadZone(AliITStrackMI *track,Int_t ilayer,Int_t idet,Double_t dz,Double_t dy,Bool_t noClusters=kFALSE) const;
+  Bool_t LocalModuleCoord(Int_t ilayer,Int_t idet,const AliITStrackMI *track,
 			  Float_t &xloc,Float_t &zloc) const;
 // method to be used for Plane Efficiency evaluation
-  Bool_t IsOKForPlaneEff(AliITStrackMI* track, Int_t ilayer) const; // Check if a track is usable 
-                                                                    // for Plane Eff evaluation
-  void UseTrackForPlaneEff(AliITStrackMI* track, Int_t ilayer);     // Use this track for Plane Eff 
+  Bool_t IsOKForPlaneEff(const AliITStrackMI* track, const Int_t *clusters, Int_t ilayer) const; // Check if a track is usable
+                                                                                           // for Plane Eff evaluation
+  void UseTrackForPlaneEff(const AliITStrackMI* track, Int_t ilayer);                            // Use this track for Plane Eff
 // 
   Int_t fI;                              // index of the current layer
   static AliITSlayer fgLayers[AliITSgeomTGeo::kNLayers];// ITS layers
@@ -266,7 +304,7 @@ protected:
   Int_t fPass;                           // current pass through the data 
   Int_t fConstraint[2];                  // constraint flags
   Bool_t fAfterV0;                       //indicates V0 founded
-  Int_t fLayersNotToSkip[AliITSgeomTGeo::kNLayers];     // layer masks
+  Int_t fForceSkippingOfLayer[AliITSgeomTGeo::kNLayers]; // layers to be skipped
   Int_t fLastLayerToTrackTo;             // the innermost layer to track to
   Float_t * fCoefficients;               //! working array with errors and mean cluster shape
   AliESDEvent  * fEsd;                   //! pointer to the ESD event
@@ -274,6 +312,9 @@ protected:
   TString fTrackingPhase;                // current tracking phase
   Int_t fUseTGeo;                        // use TGeo to get material budget
   Int_t   fNtracks;                      // number of tracks to prolong
+  Bool_t  fFlagFakes;                    // request fakes flagging
+  Bool_t  fSelectBestMIP03;              // use Chi2MIP[0]*Chi2MIP[3] in hypothesis analysis instead of Chi2MIP[0]
+  Bool_t  fUseImproveKalman;             // use Kalman version of Improve
   Float_t fxOverX0Pipe;                  // material budget
   Float_t fxTimesRhoPipe;                // material budget
   Float_t fxOverX0Shield[2];             // material budget
@@ -288,12 +329,15 @@ protected:
   Float_t *fxTimesRhoLayerTrks;          //! material budget
   TTreeSRedirector *fDebugStreamer;      //!debug streamer
   AliITSChannelStatus *fITSChannelStatus;//! bitmaps with channel status for SPD and SDD
-  AliITSDetTypeRec *fDetTypeRec;         //! ITS det type rec, from AliITSReconstructor
+  const AliITSDetTypeRec *fkDetTypeRec;         //! ITS det type rec, from AliITSReconstructor
   AliITSPlaneEff *fPlaneEff;             //! Pointer to the ITS plane efficicency
+  Bool_t* fSPDChipIntPlaneEff;      //! Map of the SPD chips already intersected by a track (for FO studies)
+  AliITSPIDResponse *fITSPid;            //! parameters for ITS pid 
+  //
 private:
   AliITStrackerMI(const AliITStrackerMI &tracker);
   AliITStrackerMI & operator=(const AliITStrackerMI &tracker);
-  ClassDef(AliITStrackerMI,5)   //ITS tracker MI
+  ClassDef(AliITStrackerMI,11)   //ITS tracker MI
 };
 
 
@@ -307,7 +351,7 @@ private:
 
 
 
-inline void AliITStrackerMI::SetupFirstPass(Int_t *flags, Double_t *cuts) {
+inline void AliITStrackerMI::SetupFirstPass(const Int_t *flags,const Double_t *cuts) {
   // This function sets up flags and cuts for the first tracking pass   
   //
   //   flags[0] - vertex constaint flag                                
@@ -316,10 +360,10 @@ inline void AliITStrackerMI::SetupFirstPass(Int_t *flags, Double_t *cuts) {
   //              positive means "normal constraint"                    
 
    fConstraint[0]=flags[0];
-   if (cuts==0) return;
+   if (!cuts) return;
 }
 
-inline void AliITStrackerMI::SetupSecondPass(Int_t *flags, Double_t *cuts) {
+inline void AliITStrackerMI::SetupSecondPass(const Int_t *flags,const Double_t *cuts) {
   // This function sets up flags and cuts for the second tracking pass   
   //
   //   flags[0] - vertex constaint flag                                
@@ -328,7 +372,7 @@ inline void AliITStrackerMI::SetupSecondPass(Int_t *flags, Double_t *cuts) {
   //              positive means "normal constraint"                    
 
    fConstraint[1]=flags[0];
-   if (cuts==0) return;
+   if (!cuts) return;
 }
 
 inline void AliITStrackerMI::CookLabel(AliKalmanTrack *t,Float_t wrong) const {
@@ -367,3 +411,4 @@ inline void  AliITStrackerMI::AliITSdetector::GetGlobalXYZ(const AliITSRecPoint
   xyz[1] = fR*fSinPhi + cl->GetY()*fCosPhi;
 }
 #endif
+