Coding rules
authorcblume <cblume@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 7 Aug 2009 11:28:51 +0000 (11:28 +0000)
committercblume <cblume@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 7 Aug 2009 11:28:51 +0000 (11:28 +0000)
34 files changed:
TRD/AliTRDchamberTimeBin.cxx
TRD/AliTRDchamberTimeBin.h
TRD/AliTRDgtuSim.cxx
TRD/AliTRDpidESD.cxx
TRD/AliTRDpidUtil.cxx
TRD/AliTRDpidUtil.h
TRD/AliTRDpropagationLayer.cxx
TRD/AliTRDpropagationLayer.h
TRD/AliTRDrecoParam.h
TRD/AliTRDseed.cxx
TRD/AliTRDseed.h
TRD/AliTRDseedV1.cxx
TRD/AliTRDseedV1.h
TRD/AliTRDtrack.cxx
TRD/AliTRDtrack.h
TRD/AliTRDtrackGTU.cxx
TRD/AliTRDtrackGTU.h
TRD/AliTRDtrackV1.cxx
TRD/AliTRDtrackV1.h
TRD/AliTRDtracker.cxx
TRD/AliTRDtracker.h
TRD/AliTRDtrackerDebug.cxx
TRD/AliTRDtrackerDebug.h
TRD/AliTRDtrackerV1.cxx
TRD/AliTRDtrackerV1.h
TRD/AliTRDtrackingChamber.cxx
TRD/AliTRDtrackingChamber.h
TRD/AliTRDtrackingSector.cxx
TRD/AliTRDtrackingSector.h
TRD/Cal/AliTRDCalPID.h
TRD/Cal/AliTRDCalPIDNN.cxx
TRD/Cal/AliTRDCalPIDRefMaker.cxx
TRD/qaRec/AliTRDcheckPID.cxx
TRD/qaRec/AliTRDpidRefMaker.cxx

index 2d9057b..cdf92d6 100644 (file)
 ///////////////////////////////////////////////////////////////////////////////
 
 #include <TObject.h>
-#include <TROOT.h>
 #include <TMath.h>
-#include <TStopwatch.h>
 #include <TTreeStream.h>
 
 #include "AliLog.h"
-
+#include "AliTRDcluster.h"
 #include "AliTRDgeometry.h"
 #include "AliTRDpadPlane.h"
 #include "AliTRDchamberTimeBin.h"
@@ -49,7 +47,7 @@ ClassImp(AliTRDchamberTimeBin)
 //_____________________________________________________________________________
 AliTRDchamberTimeBin::AliTRDchamberTimeBin(Int_t plane, Int_t stack, Int_t sector, Double_t z0, Double_t zLength)
   :TObject()
-  ,fReconstructor(0x0)
+  ,fkReconstructor(NULL)
   ,fPlane(plane)
   ,fStack(stack)
   ,fSector(sector)
@@ -73,7 +71,7 @@ AliTRDchamberTimeBin::AliTRDchamberTimeBin(Int_t plane, Int_t stack, Int_t secto
 //_____________________________________________________________________________
 AliTRDchamberTimeBin::AliTRDchamberTimeBin(const AliTRDchamberTimeBin &layer):
   TObject()
-  ,fReconstructor(layer.fReconstructor)
+  ,fkReconstructor(layer.fkReconstructor)
   ,fPlane(layer.fPlane)
   ,fStack(layer.fStack)
   ,fSector(layer.fSector)
@@ -107,6 +105,7 @@ AliTRDchamberTimeBin &AliTRDchamberTimeBin::operator=(const AliTRDchamberTimeBin
 //_____________________________________________________________________________
 void AliTRDchamberTimeBin::Clear(const Option_t *) 
 { 
+  // Reset the Chamber Timebin
   if(IsOwner())
     for(Int_t it = 0; it<kMaxClustersLayer; it++)
       delete fClusters[it];
@@ -120,7 +119,7 @@ void AliTRDchamberTimeBin::Copy(TObject &o) const
 // Copy method. Performs a deep copy of all data from this object to object o.
   
   AliTRDchamberTimeBin &layer = (AliTRDchamberTimeBin &)o;
-  layer.fReconstructor = fReconstructor;
+  layer.fkReconstructor = fkReconstructor;
   layer.fPlane       = fPlane;
   layer.fStack       = fStack;
   layer.fSector      = fSector;
@@ -216,7 +215,7 @@ void AliTRDchamberTimeBin::Bootstrap(const AliTRDReconstructor *rec, Int_t det)
 // Reinitialize all data members from the clusters array
 // It has to be used after reading from disk
 
-  fReconstructor = rec;
+  fkReconstructor = rec;
   fPlane  = AliTRDgeometry::GetLayer(det);
   fStack  = AliTRDgeometry::GetStack(det);
   fSector = AliTRDgeometry::GetSector(det);
@@ -247,7 +246,7 @@ void AliTRDchamberTimeBin::BuildIndices(Int_t iter)
   Int_t nClStack = 0;                                  // Internal counter
   for(Int_t i = 0; i < fN; i++){
     if(fClusters[i]->IsUsed() || fClusters[i]->IsShared()){
-      fClusters[i] = 0x0;
+      fClusters[i] = NULL;
       fIndex[i] = 0xffff;
     } else nClStack++;
   }
@@ -268,7 +267,7 @@ void AliTRDchamberTimeBin::BuildIndices(Int_t iter)
   nClStack = 0;
   // Defining iterators
   AliTRDcluster **fcliter = &fClusters[0], **hcliter = &helpCL[0]; UInt_t *finditer = &fIndex[0], *hinditer = &helpInd[0];
-  AliTRDcluster *tmpcl = 0x0;
+  AliTRDcluster *tmpcl = NULL;
   for(Int_t i = 0; i < TMath::Min(fN, kMaxClustersLayer); i++){
     if(!(tmpcl = *(fcliter++))){
        finditer++;
@@ -276,7 +275,7 @@ void AliTRDchamberTimeBin::BuildIndices(Int_t iter)
     }
     *(hcliter++)  = tmpcl;
     *(hinditer++) = *finditer;
-    tmpcl = 0x0;
+    tmpcl = NULL;
     *(finditer++) = 0xffff;
     nClStack++;
   }
@@ -317,9 +316,9 @@ void AliTRDchamberTimeBin::BuildIndices(Int_t iter)
     fX += cl->GetX(); 
     
     // Debug Streaming
-    if(fReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) >= 3){
+    if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) >= 3){
       AliTRDcluster dcl(*cl);
-      TTreeSRedirector &cstream = *fReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
+      TTreeSRedirector &cstream = *fkReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
       cstream << "BuildIndices"
       << "Plane="    << fPlane
       << "Stack="    << fStack
@@ -513,7 +512,7 @@ Int_t AliTRDchamberTimeBin::SearchNearestCluster(Double_t y, Double_t z, Double_
 }
 
 //_____________________________________________________________________________
-void AliTRDchamberTimeBin::BuildCond(AliTRDcluster *cl, Double_t *cond, UChar_t Layer, Double_t theta, Double_t phi)
+void AliTRDchamberTimeBin::BuildCond(AliTRDcluster * const cl, Double_t *cond, UChar_t Layer, Double_t theta, Double_t phi)
 {
 // Helper function to calculate the area where to expect a cluster in THIS
 // layer. 
@@ -537,7 +536,7 @@ void AliTRDchamberTimeBin::BuildCond(AliTRDcluster *cl, Double_t *cond, UChar_t
 //End_Html
 //
 
-  if(!fReconstructor){
+  if(!fkReconstructor){
     AliError("Reconstructor not set.");
     return;
   }
@@ -545,18 +544,18 @@ void AliTRDchamberTimeBin::BuildCond(AliTRDcluster *cl, Double_t *cond, UChar_t
   if(Layer == 0){
     cond[0] = cl->GetY();                      // center: y-Direction
     cond[1] = cl->GetZ();                      // center: z-Direction
-    cond[2] = fReconstructor->GetRecoParam()->GetMaxPhi()   * (cl->GetX() - GetX()) + 1.0;                     // deviation: y-Direction
-    cond[3] = fReconstructor->GetRecoParam()->GetMaxTheta() * (cl->GetX() - GetX()) + 1.0;                     // deviation: z-Direction
+    cond[2] = fkReconstructor->GetRecoParam()->GetMaxPhi()   * (cl->GetX() - GetX()) + 1.0;                    // deviation: y-Direction
+    cond[3] = fkReconstructor->GetRecoParam()->GetMaxTheta() * (cl->GetX() - GetX()) + 1.0;                    // deviation: z-Direction
   } else {
     cond[0] = cl->GetY() + phi   * (GetX() - cl->GetX()); 
     cond[1] = cl->GetZ() + theta * (GetX() - cl->GetX());
-    cond[2] = fReconstructor->GetRecoParam()->GetRoad0y() + phi;
-    cond[3] = fReconstructor->GetRecoParam()->GetRoad0z();
+    cond[2] = fkReconstructor->GetRecoParam()->GetRoad0y() + phi;
+    cond[3] = fkReconstructor->GetRecoParam()->GetRoad0z();
   }
 }
 
 //_____________________________________________________________________________
-void AliTRDchamberTimeBin::GetClusters(Double_t *cond, Int_t *index, Int_t& ncl, Int_t BufferSize)
+void AliTRDchamberTimeBin::GetClusters(const Double_t * const cond, Int_t *index, Int_t& ncl, Int_t BufferSize)
 {
 // Finds all clusters situated in this layer inside a rectangle  given by the center an ranges.
 //
@@ -631,11 +630,11 @@ AliTRDcluster *AliTRDchamberTimeBin::GetNearestCluster(Double_t *cond)
 // successfull) by the help of the method FindNearestCluster
   
   
-  Double_t maxroad  = fReconstructor->GetRecoParam()->GetRoad2y();
-  Double_t maxroadz = fReconstructor->GetRecoParam()->GetRoad2z();
+  Double_t maxroad  = fkReconstructor->GetRecoParam()->GetRoad2y();
+  Double_t maxroadz = fkReconstructor->GetRecoParam()->GetRoad2z();
   
   Int_t index = SearchNearestCluster(cond[0],cond[1],maxroad,maxroadz);
-  AliTRDcluster *returnCluster = 0x0;
+  AliTRDcluster *returnCluster = NULL;
   if(index != -1) returnCluster = (AliTRDcluster *) fClusters[index];
   return returnCluster;
 }
index c7b96fb..7c49543 100644 (file)
 #include "TObject.h"
 #endif
 
-#ifndef ALITRDCLUSTER_H
-#include "AliTRDcluster.h"
-#endif
-
+class AliTRDcluster;
 class AliTRDReconstructor;
+
 class AliTRDchamberTimeBin : public TObject
 {
 public:
@@ -42,16 +40,16 @@ public:
   AliTRDchamberTimeBin&
                  operator=(const AliTRDchamberTimeBin &myLayer);
   AliTRDcluster* operator[](const Int_t i) const {
-    return ((i < fN) && (i >= 0)) ? fClusters[i] : 0x0;
+    return ((i < fN) && (i >= 0)) ? fClusters[i] : NULL;
   }
 
   void           Bootstrap(const AliTRDReconstructor *rec, Int_t det);
   void           BuildIndices(Int_t iter = 0);
-  void           BuildCond(AliTRDcluster *cl, Double_t *cond, UChar_t Layer, Double_t theta=0., Double_t phi=0.);
-  void           Clear(const Option_t *opt = 0x0);
-  AliTRDcluster* GetCluster(Int_t index) const {return index < fN && index >= 0 ? fClusters[index] : 0x0;}
+  void           BuildCond(AliTRDcluster * const cl, Double_t *cond, UChar_t Layer, Double_t theta=0., Double_t phi=0.);
+  void           Clear(const Option_t *opt = NULL);
+  AliTRDcluster* GetCluster(Int_t index) const {return index < fN && index >= 0 ? fClusters[index] : NULL;}
   Int_t          GetGlobalIndex(Int_t index) const {return ((index < fN) && (index >= 0)) ? fIndex[index] : 0; }
-  void           GetClusters(Double_t *cond, Int_t *index, Int_t& ncl, Int_t BufferSize = kMaxClustersLayer);
+  void           GetClusters(const Double_t * const cond, Int_t *index, Int_t& ncl, Int_t BufferSize = kMaxClustersLayer);
   AliTRDcluster* GetNearestCluster(Double_t *cond);
   Double_t       GetX()                            const {
   return fX;      }
@@ -66,12 +64,12 @@ public:
   Bool_t         IsT0() const {return TestBit(kT0);}
   Bool_t         IsOwner() const {return TestBit(kOwner);}
 
-  void           Print(Option_t *opt=0x0) const;
+  void           Print(Option_t *opt=NULL) const;
   Int_t          SearchNearestCluster(Double_t y, Double_t z, Double_t Roady, Double_t Roadz) const;
   void           SetRange(Float_t z0, Float_t zLength);
   void           SetNRows(Int_t nRows){ fNRows = nRows; }
   void           SetPlane(Int_t plane){ fPlane = plane; }
-  void           SetReconstructor(const AliTRDReconstructor *rec) {fReconstructor = rec;}
+  void           SetReconstructor(const AliTRDReconstructor *rec) {fkReconstructor = rec;}
   void           SetStack(Int_t stack){ fStack = stack; }
   void           SetSector(Int_t sector){ fSector = sector; }
   void           SetOwner(Bool_t copy=kTRUE);
@@ -84,7 +82,7 @@ private:
   Int_t          FindNearestYCluster(Double_t y, UChar_t z) const;
 
 private:
-  const AliTRDReconstructor *fReconstructor; //!
+  const AliTRDReconstructor *fkReconstructor; //!
   Char_t        fPlane;               //! Plane number
   Char_t        fStack;               //!  stack number in supermodule
   Char_t        fSector;              //! Sector mumber
index 6eba70d..832f170 100644 (file)
 #include "TROOT.h"
 #include "TClonesArray.h"
 
+#include "AliRun.h"
+#include "AliRunLoader.h"
+#include "AliLoader.h"
+#include "AliLog.h"
+#include "AliESDTrdTrack.h"
+
 #include "AliTRDgtuSim.h"
 #include "AliTRDgtuTMU.h"
 #include "AliTRDtrackGTU.h"
 #include "AliTRDtrackletMCM.h"
 #include "AliESDEvent.h"
 
-#include "AliRun.h"
-#include "AliRunLoader.h"
-#include "AliLoader.h"
-#include "AliLog.h"
-
 ClassImp(AliTRDgtuSim)
 
 AliTRDgtuSim::AliTRDgtuSim(AliRunLoader *rl) 
index 4a6fb2a..1087b0e 100644 (file)
@@ -38,7 +38,7 @@
 #include "AliTRDpidESD.h"
 #include "AliTRDgeometry.h"
 #include "AliTRDcalibDB.h"
-#include "AliTRDtrack.h"
+#include "Cal/AliTRDCalPID.h"
 
 ClassImp(AliTRDpidESD)
 
@@ -49,7 +49,7 @@ Int_t   AliTRDpidESD::fgMinPlane         = 0;
 //_____________________________________________________________________________
 AliTRDpidESD::AliTRDpidESD()
   :TObject()
-  ,fTrack(0x0)
+  ,fTrack(NULL)
 {
   //
   // Default constructor
@@ -60,7 +60,7 @@ AliTRDpidESD::AliTRDpidESD()
 //_____________________________________________________________________________
 AliTRDpidESD::AliTRDpidESD(const AliTRDpidESD &p)
   :TObject(p)
-  ,fTrack(0x0)
+  ,fTrack(NULL)
 {
   //
   // AliTRDpidESD copy constructor
@@ -103,7 +103,7 @@ void AliTRDpidESD::Copy(TObject &p) const
   ((AliTRDpidESD &) p).fgCheckTrackStatus         = fgCheckTrackStatus;
   ((AliTRDpidESD &) p).fgCheckKinkStatus          = fgCheckKinkStatus;
   ((AliTRDpidESD &) p).fgMinPlane                 = fgMinPlane;
-  ((AliTRDpidESD &) p).fTrack                     = 0x0;
+  ((AliTRDpidESD &) p).fTrack                     = NULL;
   
 }
 
@@ -146,8 +146,8 @@ Int_t AliTRDpidESD::MakePID(AliESDEvent * const event)
 
   // Loop through all ESD tracks
   Double_t p[10];
-  AliESDtrack *t = 0x0;
-  Float_t dedx[AliTRDtrack::kNslice], dEdx;
+  AliESDtrack *t = NULL;
+  Float_t dedx[AliTRDCalPID::kNSlicesLQ], dEdx;
   Int_t   timebin;
   Float_t mom, length;
   Int_t   nPlanePID;
@@ -170,7 +170,7 @@ Int_t AliTRDpidESD::MakePID(AliESDEvent * const event)
 
     for (Int_t iLayer = 0; iLayer < AliTRDgeometry::kNlayer; iLayer++) {
       // read data for track segment
-      for(int iSlice=0; iSlice<AliTRDtrack::kNslice; iSlice++)
+      for(int iSlice=0; iSlice<AliTRDCalPID::kNSlicesLQ; iSlice++)
         dedx[iSlice] = t->GetTRDslice(iLayer, iSlice);
       dEdx    = t->GetTRDslice(iLayer, -1);
       timebin = t->GetTRDTimBin(iLayer);
@@ -264,7 +264,7 @@ Bool_t AliTRDpidESD::RecalculateTrackSegmentKine(AliESDtrack * const esd
     return kFALSE;
   }
 
-  AliExternalTrackParam *param = 0x0;
+  AliExternalTrackParam *param = NULL;
   if(!fTrack){
     fTrack = new AliExternalTrackParam(*op);
     param = fTrack;
index fa2668f..277b9a4 100644 (file)
@@ -1,3 +1,13 @@
+/***********************************************************************************************************
+ *                                                                                                         *
+ * Helper class for TRD PID efficiency calculation Calculation of the hadron efficiency depenedent on      *
+ * momentum and of the errors implemented in function CalculatePionEff. The pion efficiency is based on a  * 
+ * predefined electron efficiency. The default is 90%. To change the, one has to call the function         *
+ * SetElectronEfficiency.                                                                                  *
+ * Other Helper functions decide based on 90% electron efficiency whether a certain track is accepted      *
+ * as Electron Track. The reference data is stored in the TRD OCDB.                                        *
+ *                                                                                                         *
+ ***********************************************************************************************************/
 #include "TObject.h"
 #include "TObjArray.h"
 #include "TMath.h"
@@ -18,7 +28,7 @@
 ClassImp(AliTRDpidUtil)
 
 
-Float_t AliTRDpidUtil::fEleEffi = 0.9;
+Float_t AliTRDpidUtil::fgEleEffi = 0.9;
 
 //________________________________________________________________________
 AliTRDpidUtil::AliTRDpidUtil() 
@@ -33,8 +43,6 @@ AliTRDpidUtil::AliTRDpidUtil()
   //
 }
 
-
-
 //________________________________________________________________________
 Bool_t  AliTRDpidUtil::CalculatePionEffi(TH1* histo1, TH1* histo2)
 // Double_t  AliTRDpidUtil::GetError()
@@ -55,9 +63,9 @@ Bool_t  AliTRDpidUtil::CalculatePionEffi(TH1* histo1, TH1* histo2)
   Int_t abinE, bbinE, cbinE = -1;                    
   Double_t aBinSumE, bBinSumE;                  // content of a single bin
   Bool_t bFirst = 1;                            // checks if threshold is crossed for the first time
-  Double_t SumElecsE[kBins+2], SumPionsE[kBins+2];  // array of the integrated sum in each bin
-  memset(SumElecsE, 0, (kBins+2)*sizeof(Double_t));
-  memset(SumPionsE, 0, (kBins+2)*sizeof(Double_t));
+  Double_t sumElecE[kBins+2], sumPionsE[kBins+2];  // array of the integrated sum in each bin
+  memset(sumElecE, 0, (kBins+2)*sizeof(Double_t));
+  memset(sumPionsE, 0, (kBins+2)*sizeof(Double_t));
 
 
   // calculate electron efficiency of each bin
@@ -65,12 +73,12 @@ Bool_t  AliTRDpidUtil::CalculatePionEffi(TH1* histo1, TH1* histo2)
    aBinSumE = 0;
     aBinSumE = histo1 -> GetBinContent(abinE);
     
-    SumElecsE[abinE] = SumElecsE[abinE+1] + aBinSumE;
+    sumElecE[abinE] = sumElecE[abinE+1] + aBinSumE;
 
-    if((SumElecsE[abinE] >= fEleEffi) && (bFirst == 1)){
+    if((sumElecE[abinE] >= fgEleEffi) && (bFirst == 1)){
       bFirst = 0;
       cbinE = abinE;
-      fCalcEleEffi = (SumElecsE[cbinE]); 
+      fCalcEleEffi = (sumElecE[cbinE]); 
     }
   }
   
@@ -81,29 +89,29 @@ Bool_t  AliTRDpidUtil::CalculatePionEffi(TH1* histo1, TH1* histo2)
     bBinSumE = 0;
     bBinSumE = histo2 -> GetBinContent(bbinE);
 
-    SumPionsE[bbinE] = SumPionsE[bbinE+1] + bBinSumE;
+    sumPionsE[bbinE] = sumPionsE[bbinE+1] + bBinSumE;
     if(bbinE == cbinE){
-      fPionEffi = (SumPionsE[cbinE]);
+      fPionEffi = (sumPionsE[cbinE]);
     }
   }
   
 
   // pion efficiency vs electron efficiency
-  TGraph gEffis(kBins, SumElecsE, SumPionsE);
+  TGraph gEffis(kBins, sumElecE, sumPionsE);
 
   // use fit function to get derivate of the TGraph for error calculation
-  TF1 f1("f1","[0]*x*x+[1]*x+[2]", fEleEffi-.05, fEleEffi+.05);
-  gEffis.Fit(&f1, "Q", "", fEleEffi-.05, fEleEffi+.05);
+  TF1 f1("f1","[0]*x*x+[1]*x+[2]", fgEleEffi-.05, fgEleEffi+.05);
+  gEffis.Fit(&f1, "Q", "", fgEleEffi-.05, fgEleEffi+.05);
   
   // return the error of the pion efficiency
   if(((1.-fPionEffi) < 0) || ((1.-fCalcEleEffi) < 0)){
     AliWarning(" EleEffi or PioEffi > 1. Error can not be calculated. Please increase statistics or check your simulation!");
     return kFALSE;
   }
-  fError = sqrt(((1/histo2 -> GetEntries())*fPionEffi*(1-fPionEffi))+((f1.Derivative(fEleEffi))*(f1.Derivative(fEleEffi))*(1/histo1 -> GetEntries())*fCalcEleEffi*(1-fCalcEleEffi)));
+  fError = sqrt(((1/histo2 -> GetEntries())*fPionEffi*(1-fPionEffi))+((f1.Derivative(fgEleEffi))*(f1.Derivative(fgEleEffi))*(1/histo1 -> GetEntries())*fCalcEleEffi*(1-fCalcEleEffi)));
 
 //   AliInfo(Form("Pion Effi at [%f] : [%f +/- %f], Threshold[%f]", fCalcEleEffi, fPionEffi, fError, fThreshold));
-//   AliInfo(Form("Derivative at %4.2f : %f\n", fEleEffi, f1.Derivative(fEleEffi)));
+//   AliInfo(Form("Derivative at %4.2f : %f\n", fgEleEffi, f1.Derivative(fgEleEffi)));
   return kTRUE;
 }
 
@@ -154,10 +162,10 @@ Bool_t AliTRDpidUtil::IsElectron(const AliESDtrack *track, ETRDPIDMethod method)
   if(method == kESD) method = kNN;
   TString histname[2] = {"fHistThreshLQ", "fHistThreshNN"};
   AliCDBManager *cdb = AliCDBManager::Instance(); 
-  AliCDBEntry *cdb_thresholds = cdb->Get("TRD/Calib/PIDThresholds");
-  TObjArray *histos = dynamic_cast<TObjArray *>(cdb_thresholds->GetObject());
-  TH1 * threshold_hist = dynamic_cast<TH1F *>(histos->FindObject(histname[method].Data()));
-  Double_t threshold = threshold_hist->GetBinContent(GetMomentumBin(track->P()) + 1);
+  AliCDBEntry *cdbThresholds = cdb->Get("TRD/Calib/PIDThresholds");
+  TObjArray *histos = dynamic_cast<TObjArray *>(cdbThresholds->GetObject());
+  TH1 * thresholdHist = dynamic_cast<TH1F *>(histos->FindObject(histname[method].Data()));
+  Double_t threshold = thresholdHist->GetBinContent(GetMomentumBin(track->P()) + 1);
   
   // Do Decision
   Double_t pid_probs[5];
@@ -176,10 +184,10 @@ Double_t AliTRDpidUtil::GetSystematicError(const AliESDtrack *track, ETRDPIDMeth
   if(method == kESD) method = kNN;
   TString histname[2] = {"fHistPionEffLQ", "fHistPionEffNN"};
   AliCDBManager *cdb = AliCDBManager::Instance(); 
-  AliCDBEntry *cdb_thresholds = cdb->Get("TRD/Calib/PIDThresholds");
-  TObjArray *histos = dynamic_cast<TObjArray *>(cdb_thresholds->GetObject());
-  TH1 * threshold_hist = dynamic_cast<TH1F *>(histos->FindObject(histname[method].Data()));
-  return threshold_hist->GetBinContent(GetMomentumBin(track->P()) + 1);
+  AliCDBEntry *cdbThresholds = cdb->Get("TRD/Calib/PIDThresholds");
+  TObjArray *histos = dynamic_cast<TObjArray *>(cdbThresholds->GetObject());
+  TH1 * thresholdHist = dynamic_cast<TH1F *>(histos->FindObject(histname[method].Data()));
+  return thresholdHist->GetBinContent(GetMomentumBin(track->P()) + 1);
 }
 
 //________________________________________________________________________
index 3353d5b..c5d320e 100644 (file)
@@ -31,7 +31,7 @@ public:
 
   Bool_t       CalculatePionEffi(TH1* histo1, TH1* histo2);
 
-  static Float_t  ElectronEfficiency()   { return fEleEffi;};
+  static Float_t  ElectronEfficiency()   { return fgEleEffi;};
   
   static Bool_t   IsElectron(const AliESDtrack *track, ETRDPIDMethod method = kNN);
   static Double_t GetSystematicError(const AliESDtrack *track, ETRDPIDMethod method = kNN);
@@ -43,13 +43,13 @@ public:
 
   static Int_t GetMomentumBin(Double_t p);
   static Int_t Pdg2Pid(Int_t pdg);
-  static void  SetElectronEfficiency(Float_t eleeffi) {fEleEffi = eleeffi;};
+  static void  SetElectronEfficiency(Float_t eleeffi) {fgEleEffi = eleeffi;};
 
 private:
   AliTRDpidUtil(const AliTRDpidUtil&);               // not implemented
   AliTRDpidUtil& operator=(const AliTRDpidUtil&);    // not implemented
 
-  static Float_t fEleEffi;               // electron efficiency
+  static Float_t fgEleEffi;               // electron efficiency
 
   Double_t fCalcEleEffi;                 // electron efficiency after calculation
   Double_t fPionEffi;                    // pion efficiency 
index cd229cf..b8df200 100644 (file)
@@ -113,8 +113,8 @@ AliTRDpropagationLayer::AliTRDpropagationLayer(const AliTRDpropagationLayer &p)
   :TObject((TObject&)p)
   ,fN(p.fN)
   ,fSec(p.fSec)
-  ,fClusters(0x0)
-  ,fIndex(0x0)
+  ,fClusters(NULL)
+  ,fIndex(NULL)
   ,fX(p.fX)
   ,fdX(p.fdX)
   ,fRho(p.fRho)
@@ -220,7 +220,7 @@ void AliTRDpropagationLayer::Copy(TObject &o) const
 }
 
 //_____________________________________________________________________________
-void AliTRDpropagationLayer::SetZ(Double_t *center, Double_t *w, Double_t *wsensitive )
+void AliTRDpropagationLayer::SetZ(Double_t * const center, Double_t * const w, Double_t * const wsensitive )
 {
   //
   // Set centers and the width of sectors
@@ -235,7 +235,7 @@ void AliTRDpropagationLayer::SetZ(Double_t *center, Double_t *w, Double_t *wsens
 }
 
 //_____________________________________________________________________________
-void AliTRDpropagationLayer::SetHoles(Bool_t *holes)
+void AliTRDpropagationLayer::SetHoles(Bool_t * const holes)
 {
   //
   // Set centers and the width of sectors
index ddcc286..9bdd0b9 100644 (file)
@@ -42,8 +42,8 @@ class AliTRDpropagationLayer : public TObject
   void         SetYmax(Double_t w, Double_t wsensitive)         { fYmax          = w;
                                                                   fYmaxSensitive = wsensitive;  }
 
-  void         SetZ(Double_t* center, Double_t *w, Double_t *wsensitive);
-  void         SetHoles(Bool_t* holes);
+  void         SetZ(Double_t * const center, Double_t * const w, Double_t * const wsensitive);
+  void         SetHoles(Bool_t * const holes);
   //void         SetHole(Double_t Zmax, Double_t Ymax
   //                  , Double_t rho = 1.29e-3, Double_t x0 = 36.66
   //                   , Double_t Yc = 0.0, Double_t Zc = 0.0);
@@ -65,7 +65,7 @@ class AliTRDpropagationLayer : public TObject
   Bool_t       IsSensitive() const                              { return (fTimeBinIndex >= 0) ? kTRUE : kFALSE;}
        Bool_t       IsT0() const {return TestBit(1);}
 
-  void         Clear(const Option_t * /*o*/)                    { ; } 
+  void         Clear(const Option_t * /*o*/) const              { ; } 
   void         Clear()                                          { for (Int_t i = 0; i < fN; i++) 
                                                                     fClusters[i] = NULL;
                                                                  fN = 0;                       }
index b3cc9e5..1be90bb 100644 (file)
@@ -111,7 +111,7 @@ private:
   Double_t  fkTrackLikelihood;       // Track likelihood for tracklets Rieman fit
   
   Double_t  fSysCovMatrix[5];        // Systematic uncertainty from calibration and alignment for each tracklet
-  Double_t  fPIDThreshold[AliTRDCalPID::kNMom];
+  Double_t  fPIDThreshold[AliTRDCalPID::kNMom];   // PID Thresholds for Electron candidate decision
 
   // Clusterization parameter
   Double_t  fMinMaxCutSigma;         // Threshold sigma noise pad middle
index 6a77664..0b4feec 100644 (file)
@@ -27,7 +27,6 @@
 #include "AliMathBase.h"
 
 #include "AliTRDseed.h"
-#include "AliTRDcalibDB.h"
 #include "AliTRDcluster.h"
 #include "AliTRDtracker.h"
 #include "AliTRDtrackerV1.h"
@@ -64,7 +63,7 @@ AliTRDseed::AliTRDseed()
     fY[i]        = 0;   // y position
     fZ[i]        = 0;   // z position
     fIndexes[i]  = 0;   // Indexes
-    fClusters[i] = 0x0; // Clusters
+    fClusters[i] = NULL; // Clusters
     fUsable[i]   = 0;   // Indication  - usable cluster
   }
 
@@ -185,7 +184,7 @@ void AliTRDseed::Reset()
     fY[i]        = 0;  // Y position
     fZ[i]        = 0;  // Z position
     fIndexes[i]  = 0;  // Indexes
-    fClusters[i] = 0x0;  // Clusters
+    fClusters[i] = NULL;  // Clusters
     fUsable[i]   = kFALSE;    
   }
 
@@ -447,8 +446,8 @@ void AliTRDseed::Update()
     fUsable[i] = kFALSE;
     if (!fClusters[i]) continue;
     if (!fClusters[i]->IsInChamber()) continue;
-    if (TMath::Abs(fZ[i] - allowedz[i]) > 2){fClusters[i] = 0x0; continue;}
-    if (TMath::Abs(yres[i] - mean) > 4.0 * sigma){fClusters[i] = 0x0;  continue;}
+    if (TMath::Abs(fZ[i] - allowedz[i]) > 2){fClusters[i] = NULL; continue;}
+    if (TMath::Abs(yres[i] - mean) > 4.0 * sigma){fClusters[i] = NULL;  continue;}
     fUsable[i] = kTRUE;
     fN2++;
     fMPads += fClusters[i]->GetNPads();
index 31e9ed0..822c16c 100644 (file)
@@ -60,8 +60,8 @@ public:
           Float_t  GetMeanz() const                         { return fMeanz;         }
           Float_t  GetZProb() const                         { return fZProb;         }
           Int_t    GetLabels(Int_t i) const                 { return fLabels[i];     }
-         Float_t  GetMPads() const                         { return fMPads;         }
-         Int_t    GetNbClusters() const                    { return fN;             }
+               Float_t  GetMPads() const                         { return fMPads;         }
+               Int_t    GetNbClusters() const                    { return fN;             }
           Int_t    GetN2() const                            { return fN2;            }
           Int_t    GetNChange() const                       { return fNChange;       }
           Int_t    GetNUsed() const                         { return fNUsed;         }
@@ -79,7 +79,7 @@ public:
           void     SetY(Int_t i, Float_t y)                 { fY[i]        = y;      }
           void     SetZ(Int_t i, Float_t z)                 { fZ[i]        = z;      }
           void     SetIndexes(Int_t i, Int_t idx)           { fIndexes[i]  = idx;    }
-          void     SetClusters(Int_t i, AliTRDcluster *c)   { fClusters[i] = c;      }
+          void     SetClusters(Int_t i, AliTRDcluster * const c)   { fClusters[i] = c;      }
           void     SetUsable(Int_t i, Bool_t usable)        { fUsable[i]   = usable; }
           void     SetYref(Int_t i, Float_t yref)           { fYref[i]     = yref;   }
           void     SetZref(Int_t i, Float_t zref)           { fZref[i]     = zref;   }
index 1cd77b3..91e50ca 100644 (file)
 
 ClassImp(AliTRDseedV1)
 
-TLinearFitter *AliTRDseedV1::fgFitterY = 0x0;
-TLinearFitter *AliTRDseedV1::fgFitterZ = 0x0;
+TLinearFitter *AliTRDseedV1::fgFitterY = NULL;
+TLinearFitter *AliTRDseedV1::fgFitterZ = NULL;
 
 //____________________________________________________________________
 AliTRDseedV1::AliTRDseedV1(Int_t det) 
   :AliTRDtrackletBase()
-  ,fReconstructor(0x0)
-  ,fClusterIter(0x0)
+  ,fkReconstructor(NULL)
+  ,fClusterIter(NULL)
   ,fExB(0.)
   ,fVD(0.)
   ,fT0(0.)
@@ -114,8 +114,8 @@ AliTRDseedV1::AliTRDseedV1(Int_t det)
 //____________________________________________________________________
 AliTRDseedV1::AliTRDseedV1(const AliTRDseedV1 &ref)
   :AliTRDtrackletBase((AliTRDtrackletBase&)ref)
-  ,fReconstructor(0x0)
-  ,fClusterIter(0x0)
+  ,fkReconstructor(NULL)
+  ,fClusterIter(NULL)
   ,fExB(0.)
   ,fVD(0.)
   ,fT0(0.)
@@ -176,7 +176,7 @@ AliTRDseedV1::~AliTRDseedV1()
       if(!fClusters[itb]) continue; 
       //AliInfo(Form("deleting c %p @ %d", fClusters[itb], itb));
       delete fClusters[itb];
-      fClusters[itb] = 0x0;
+      fClusters[itb] = NULL;
     }
   }
 }
@@ -191,8 +191,8 @@ void AliTRDseedV1::Copy(TObject &ref) const
   //AliInfo("");
   AliTRDseedV1 &target = (AliTRDseedV1 &)ref; 
 
-  target.fReconstructor = fReconstructor;
-  target.fClusterIter   = 0x0;
+  target.fkReconstructor = fkReconstructor;
+  target.fClusterIter   = NULL;
   target.fExB           = fExB;
   target.fVD            = fVD;
   target.fT0            = fT0;
@@ -347,7 +347,7 @@ void AliTRDseedV1::UseClusters()
       if((*c)->IsShared() || (*c)->IsUsed()){ 
         if((*c)->IsShared()) SetNShared(GetNShared()-1);
         else SetNUsed(GetNUsed()-1);
-        (*c) = 0x0;
+        (*c) = NULL;
         fIndexes[ic] = -1;
         SetN(GetN()-1);
         continue;
@@ -392,7 +392,7 @@ void AliTRDseedV1::CookdEdx(Int_t nslices)
 
   const Double_t kDriftLength = (.5 * AliTRDgeometry::AmThick() + AliTRDgeometry::DrThick());
 
-  AliTRDcluster *c = 0x0;
+  AliTRDcluster *c = NULL;
   for(int ic=0; ic<AliTRDtrackerV1::GetNTimeBins(); ic++){
     if(!(c = fClusters[ic]) && !(c = fClusters[ic+kNtb])) continue;
     Float_t dx = TMath::Abs(fX0 - c->GetX());
@@ -417,7 +417,7 @@ void AliTRDseedV1::CookdEdx(Int_t nslices)
     nclusters[slice]++;
   } // End of loop over clusters
 
-  //if(fReconstructor->GetPIDMethod() == AliTRDReconstructor::kLQPID){
+  //if(fkReconstructor->GetPIDMethod() == AliTRDReconstructor::kLQPID){
   if(nslices == AliTRDpidUtil::kLQslices){
   // calculate mean charge per slice (only LQ PID)
     for(int is=0; is<nslices; is++){ 
@@ -546,7 +546,7 @@ Float_t AliTRDseedV1::GetMomentum(Float_t *err) const
 Float_t* AliTRDseedV1::GetProbability(Bool_t force)
 {      
   if(!force) return &fProb[0];
-  if(!CookPID()) return 0x0;
+  if(!CookPID()) return NULL;
   return &fProb[0];
 }
 
@@ -558,7 +558,7 @@ Bool_t AliTRDseedV1::CookPID()
 // Parameters
 //
 // Output
-//   returns pointer to the probability array and 0x0 if missing DB access 
+//   returns pointer to the probability array and NULL if missing DB access 
 //
 // Retrieve PID probabilities for e+-, mu+-, K+-, pi+- and p+- from the DB according to tracklet information:
 // - estimated momentum at tracklet reference point 
@@ -575,25 +575,25 @@ Bool_t AliTRDseedV1::CookPID()
     return kFALSE;
   }
 
-  if (!fReconstructor) {
+  if (!fkReconstructor) {
     AliError("Reconstructor not set.");
     return kFALSE;
   }
 
   // Retrieve the CDB container class with the parametric detector response
-  const AliTRDCalPID *pd = calibration->GetPIDObject(fReconstructor->GetPIDMethod());
+  const AliTRDCalPID *pd = calibration->GetPIDObject(fkReconstructor->GetPIDMethod());
   if (!pd) {
     AliError("No access to AliTRDCalPID object");
     return kFALSE;
   }
-  //AliInfo(Form("Method[%d] : %s", fReconstructor->GetRecoParam() ->GetPIDMethod(), pd->IsA()->GetName()));
+  //AliInfo(Form("Method[%d] : %s", fkReconstructor->GetRecoParam() ->GetPIDMethod(), pd->IsA()->GetName()));
 
   // calculate tracklet length TO DO
   Float_t length = (AliTRDgeometry::AmThick() + AliTRDgeometry::DrThick());
   /// TMath::Sqrt((1.0 - fSnp[iPlane]*fSnp[iPlane]) / (1.0 + fTgl[iPlane]*fTgl[iPlane]));
   
   //calculate dE/dx
-  CookdEdx(fReconstructor->GetNdEdxSlices());
+  CookdEdx(fkReconstructor->GetNdEdxSlices());
   
   // Sets the a priori probabilities
   for(int ispec=0; ispec<AliPID::kSPECIES; ispec++)
@@ -671,9 +671,9 @@ void AliTRDseedV1::GetCovAt(Double_t x, Double_t *cov) const
   //GetPadLength()*GetPadLength()/12.;
 
   // insert systematic uncertainties
-  if(fReconstructor){
+  if(fkReconstructor){
     Double_t sys[15]; memset(sys, 0, 15*sizeof(Double_t));
-    fReconstructor->GetRecoParam()->GetSysCovMatrix(sys);
+    fkReconstructor->GetRecoParam()->GetSysCovMatrix(sys);
     sy2 += sys[0];
     sz2 += sys[1];
   }
@@ -688,7 +688,7 @@ void AliTRDseedV1::GetCovAt(Double_t x, Double_t *cov) const
 }
 
 //____________________________________________________________
-Double_t AliTRDseedV1::GetCovSqrt(Double_t *c, Double_t *d)
+Double_t AliTRDseedV1::GetCovSqrt(const Double_t * const c, Double_t *d)
 {
 // Helper function to calculate the square root of the covariance matrix. 
 // The input matrix is stored in the vector c and the result in the vector d. 
@@ -707,38 +707,38 @@ Double_t AliTRDseedV1::GetCovSqrt(Double_t *c, Double_t *d)
 // Author A.Bercuci <A.Bercuci@gsi.de>
 // Date   Mar 19 2009
 
-  Double_t L[2], // eigenvalues
-           V[3]; // eigenvectors
+  Double_t l[2], // eigenvalues
+           v[3]; // eigenvectors
   // the secular equation and its solution :
   // (c[0]-L)(c[2]-L)-c[1]^2 = 0
   // L^2 - L*Tr(c)+DET(c) = 0
   // L12 = [Tr(c) +- sqrt(Tr(c)^2-4*DET(c))]/2
-  Double_t Tr = c[0]+c[2],           // trace
-          DET = c[0]*c[2]-c[1]*c[1]; // determinant
-  if(TMath::Abs(DET)<1.e-20) return -1.;
-  Double_t DD = TMath::Sqrt(Tr*Tr - 4*DET);
-  L[0] = .5*(Tr + DD);
-  L[1] = .5*(Tr - DD);
-  if(L[0]<0. || L[1]<0.) return -1.;
+  Double_t tr = c[0]+c[2],           // trace
+          det = c[0]*c[2]-c[1]*c[1]; // determinant
+  if(TMath::Abs(det)<1.e-20) return -1.;
+  Double_t dd = TMath::Sqrt(tr*tr - 4*det);
+  l[0] = .5*(tr + dd);
+  l[1] = .5*(tr - dd);
+  if(l[0]<0. || l[1]<0.) return -1.;
 
   // the sym V matrix
   // | v00   v10|
   // | v10   v11|
-  Double_t tmp = (L[0]-c[0])/c[1];
-  V[0] = TMath::Sqrt(1./(tmp*tmp+1));
-  V[1] = tmp*V[0];
-  V[2] = V[1]*c[1]/(L[1]-c[2]);
+  Double_t tmp = (l[0]-c[0])/c[1];
+  v[0] = TMath::Sqrt(1./(tmp*tmp+1));
+  v[1] = tmp*v[0];
+  v[2] = v[1]*c[1]/(l[1]-c[2]);
   // the VD^{1/2}V is: 
-  L[0] = TMath::Sqrt(L[0]); L[1] = TMath::Sqrt(L[1]);
-  d[0] = V[0]*V[0]*L[0]+V[1]*V[1]*L[1];
-  d[1] = V[0]*V[1]*L[0]+V[1]*V[2]*L[1];
-  d[2] = V[1]*V[1]*L[0]+V[2]*V[2]*L[1];
+  l[0] = TMath::Sqrt(l[0]); l[1] = TMath::Sqrt(l[1]);
+  d[0] = v[0]*v[0]*l[0]+v[1]*v[1]*l[1];
+  d[1] = v[0]*v[1]*l[0]+v[1]*v[2]*l[1];
+  d[2] = v[1]*v[1]*l[0]+v[2]*v[2]*l[1];
 
   return 1.;
 }
 
 //____________________________________________________________
-Double_t AliTRDseedV1::GetCovInv(Double_t *c, Double_t *d)
+Double_t AliTRDseedV1::GetCovInv(const Double_t * const c, Double_t *d)
 {
 // Helper function to calculate the inverse of the covariance matrix.
 // The input matrix is stored in the vector c and the result in the vector d. 
@@ -748,13 +748,13 @@ Double_t AliTRDseedV1::GetCovInv(Double_t *c, Double_t *d)
 // Author A.Bercuci <A.Bercuci@gsi.de>
 // Date   Mar 19 2009
 
-  Double_t Det = c[0]*c[2] - c[1]*c[1];
-  if(TMath::Abs(Det)<1.e-20) return 0.;
-  Double_t InvDet = 1./Det;
-  d[0] = c[2]*InvDet;
-  d[1] =-c[1]*InvDet;
-  d[2] = c[0]*InvDet;
-  return Det;
+  Double_t det = c[0]*c[2] - c[1]*c[1];
+  if(TMath::Abs(det)<1.e-20) return 0.;
+  Double_t invDet = 1./det;
+  d[0] = c[2]*invDet;
+  d[1] =-c[1]*invDet;
+  d[2] = c[0]*invDet;
+  return det;
 }
 
 //____________________________________________________________________
@@ -859,7 +859,7 @@ void AliTRDseedV1::SetPadPlane(AliTRDpadPlane *p)
 
 
 //____________________________________________________________________
-Bool_t AliTRDseedV1::AttachClusters(AliTRDtrackingChamber *chamber, Bool_t tilt)
+Bool_t AliTRDseedV1::AttachClusters(AliTRDtrackingChamber *const chamber, Bool_t tilt)
 {
 //
 // Projective algorithm to attach clusters to seeding tracklets. The following steps are performed :
@@ -889,28 +889,28 @@ Bool_t    AliTRDseedV1::AttachClusters(AliTRDtrackingChamber *chamber, Bool_t tilt)
 // Debug  : level >3
 
   Bool_t kPRINT = kFALSE;
-  if(!fReconstructor->GetRecoParam() ){
+  if(!fkReconstructor->GetRecoParam() ){
     AliError("Seed can not be used without a valid RecoParam.");
     return kFALSE;
   }
   // Initialize reco params for this tracklet
   // 1. first time bin in the drift region
   Int_t t0 = 14;
-  Int_t kClmin = Int_t(fReconstructor->GetRecoParam() ->GetFindableClusters()*AliTRDtrackerV1::GetNTimeBins());
+  Int_t kClmin = Int_t(fkReconstructor->GetRecoParam() ->GetFindableClusters()*AliTRDtrackerV1::GetNTimeBins());
 
-  Double_t sysCov[5]; fReconstructor->GetRecoParam()->GetSysCovMatrix(sysCov); 
+  Double_t sysCov[5]; fkReconstructor->GetRecoParam()->GetSysCovMatrix(sysCov);        
   Double_t s2yTrk= fRefCov[0], 
            s2yCl = 0., 
            s2zCl = GetPadLength()*GetPadLength()/12., 
            syRef = TMath::Sqrt(s2yTrk),
            t2    = GetTilt()*GetTilt();
   //define roads
-  Double_t kroady = 1., //fReconstructor->GetRecoParam() ->GetRoad1y();
+  Double_t kroady = 1., //fkReconstructor->GetRecoParam() ->GetRoad1y();
            kroadz = GetPadLength() * 1.5 + 1.;
   // define probing cluster (the perfect cluster) and default calibration
   Short_t sig[] = {0, 0, 10, 30, 10, 0,0};
   AliTRDcluster cp(fDet, 6, 75, 0, sig, 0);
-  if(fReconstructor->IsHLT())cp.SetRPhiMethod(AliTRDcluster::kCOG);
+  if(fkReconstructor->IsHLT())cp.SetRPhiMethod(AliTRDcluster::kCOG);
   Calibrate();
 
   if(kPRINT) printf("AttachClusters() sy[%f] road[%f]\n", syRef, kroady);
@@ -926,8 +926,8 @@ Bool_t      AliTRDseedV1::AttachClusters(AliTRDtrackingChamber *chamber, Bool_t tilt)
   memset(clst, 0, kNrows*kNcls*sizeof(AliTRDcluster*));
 
   // Do cluster projection
-  AliTRDcluster *c = 0x0;
-  AliTRDchamberTimeBin *layer = 0x0;
+  AliTRDcluster *c = NULL;
+  AliTRDchamberTimeBin *layer = NULL;
   Bool_t kBUFFER = kFALSE;
   for (Int_t it = 0; it < kNtb; it++) {
     if(!(layer = chamber->GetTB(it))) continue;
@@ -993,8 +993,8 @@ Bool_t      AliTRDseedV1::AttachClusters(AliTRDtrackingChamber *chamber, Bool_t tilt)
       continue;
     } 
 
-    if(fReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 3){
-      TTreeSRedirector &cstreamer = *fReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
+    if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 3){
+      TTreeSRedirector &cstreamer = *fkReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
       TVectorD vdy(ncl[ir], yres[ir]);
       UChar_t stat(0);
       if(IsKink()) SETBIT(stat, 0);
@@ -1016,7 +1016,7 @@ Bool_t    AliTRDseedV1::AttachClusters(AliTRDtrackingChamber *chamber, Bool_t tilt)
     Bool_t kFOUND = kFALSE;
     for(Int_t ic = ncl[ir]; ic--;){
       if(yres[ir][ic] - mean > 3. * syDis){ 
-        clst[ir][ic] = 0x0; continue;
+        clst[ir][ic] = NULL; continue;
       }
       nrow[nr]++; kFOUND = kTRUE;
     }
@@ -1107,7 +1107,7 @@ void AliTRDseedV1::Bootstrap(const AliTRDReconstructor *rec)
 // 
 //   A.Bercuci <A.Bercuci@gsi.de> Oct 30th 2008
 //
-  fReconstructor = rec;
+  fkReconstructor = rec;
   AliTRDgeometry g;
   AliTRDpadPlane *pp = g.GetPadPlane(fDet);
   fPad[0] = pp->GetLengthIPad();
@@ -1244,7 +1244,7 @@ Bool_t AliTRDseedV1::Fit(Bool_t tilt, Bool_t zcorr)
   Double_t qc[kNclusters], xc[kNclusters], yc[kNclusters], zc[kNclusters], sy[kNclusters];
 
   Int_t n = 0;
-  AliTRDcluster *c=0x0, **jc = &fClusters[0];
+  AliTRDcluster *c=NULL, **jc = &fClusters[0];
   for (Int_t ic=0; ic<kNtb; ic++, ++jc) {
     xc[ic]  = -1.;
     yc[ic]  = 999.;
@@ -1274,7 +1274,7 @@ Bool_t AliTRDseedV1::Fit(Bool_t tilt, Bool_t zcorr)
     c->SetSigmaY2(fS2PRF, fDiffT, fExB, xc[n], zcorr?zt:-1., dydx);
     sy[n]  = TMath::Sqrt(c->GetSigmaY2());
 
-    yc[n]   = fReconstructor->UseGAUS() ? 
+    yc[n]   = fkReconstructor->UseGAUS() ? 
       c->GetYloc(y0, sy[n], GetPadWidth()): c->GetY();
     zc[n]   = c->GetZ();
     //optional tilt correction
index 159b11b..9e51e52 100644 (file)
@@ -69,7 +69,7 @@ public:
   AliTRDseedV1(const AliTRDseedV1 &ref);
   AliTRDseedV1& operator=(const AliTRDseedV1 &ref);
 
-  Bool_t    AttachClusters(AliTRDtrackingChamber *chamber, Bool_t tilt = kFALSE);
+  Bool_t    AttachClusters(AliTRDtrackingChamber *const chamber, Bool_t tilt = kFALSE);
   void      Bootstrap(const AliTRDReconstructor *rec);
   void      Calibrate();
   void      CookdEdx(Int_t nslices);
@@ -96,23 +96,23 @@ public:
   void      GetCovAt(Double_t x, Double_t *cov) const;
   void      GetCovXY(Double_t *cov) const { memcpy(cov, &fCov[0], 3*sizeof(Double_t));}
   void      GetCovRef(Double_t *cov) const { memcpy(cov, &fRefCov, 7*sizeof(Double_t));}
-  static Double_t GetCovSqrt(Double_t *c, Double_t *d);
-  static Double_t GetCovInv(Double_t *c, Double_t *d);
+  static Double_t GetCovSqrt(const Double_t * const c, Double_t *d);
+  static Double_t GetCovInv(const Double_t * const c, Double_t *d);
   Float_t   GetdX() const            { return fdX;}
-  Float_t*  GetdEdx()                { return &fdEdx[0];}
-  Float_t   GetdQdl(Int_t ic, Float_t *dx=0x0) const;
+  const Float_t*  GetdEdx() const    { return &fdEdx[0];}
+  Float_t   GetdQdl(Int_t ic, Float_t *dx=NULL) const;
   Float_t   GetdYdX() const          { return fYfit[1]; } 
   Float_t   GetdZdX() const          { return fZref[1]; }
   Int_t     GetdY() const            { return Int_t(GetY()/0.014);}
   Int_t     GetDetector() const      { return fDet;}
   void      GetCalibParam(Float_t &exb, Float_t &vd, Float_t &t0, Float_t &s2, Float_t &dl, Float_t &dt) const    { 
               exb = fExB; vd = fVD; t0 = fT0; s2 = fS2PRF; dl = fDiffL; dt = fDiffT;}
-  AliTRDcluster*  GetClusters(Int_t i) const               { return i<0 || i>=kNclusters ? 0x0 : fClusters[i];}
+  AliTRDcluster*  GetClusters(Int_t i) const               { return i<0 || i>=kNclusters ? NULL: fClusters[i];}
   static TLinearFitter*  GetFitterY();
   static TLinearFitter*  GetFitterZ();
   Int_t     GetIndexes(Int_t i) const{ return i<0 || i>=kNclusters ? -1 : fIndexes[i];}
   Int_t     GetLabels(Int_t i) const { return fLabels[i];}  
-  Float_t   GetMomentum(Float_t *err = 0x0) const;
+  Float_t   GetMomentum(Float_t *err = NULL) const;
   Int_t     GetN() const             { return (Int_t)fN&0x1f;}
   Int_t     GetN2() const            { return GetN();}
   Int_t     GetNUsed() const         { return Int_t((fN>>5)&0x1f);}
@@ -168,7 +168,7 @@ public:
   void      SetTilt(Float_t tilt)    { fPad[2] = tilt; }
   void      SetDetector(Int_t d)     { fDet = d;  }
   void      SetDX(Float_t inDX)      { fdX = inDX;}
-  void      SetReconstructor(const AliTRDReconstructor *rec) {fReconstructor = rec;}
+  void      SetReconstructor(const AliTRDReconstructor *rec) {fkReconstructor = rec;}
   void      SetX0(Float_t x0)        { fX0 = x0; }
   void      SetYref(Int_t i, Float_t y) { fYref[i]     = y;}
   void      SetZref(Int_t i, Float_t z) { fZref[i]     = z;}
@@ -185,7 +185,7 @@ private:
   inline void SetNUsed(Int_t n);
   inline void SetNShared(Int_t n);
 
-  const AliTRDReconstructor *fReconstructor;//! local reconstructor
+  const AliTRDReconstructor *fkReconstructor;//! local reconstructor
   AliTRDcluster  **fClusterIter;            //! clusters iterator
   Int_t            fIndexes[kNclusters];    //! Indexes
   Float_t          fExB;                    //! tg(a_L) @ tracklet location
@@ -218,8 +218,8 @@ private:
   Int_t            fLabels[3];              // most frequent MC labels and total number of different labels
   Double_t         fRefCov[7];              // covariance matrix of the track in the yz plane + the rest of the diagonal elements
   Double_t         fCov[3];                 // covariance matrix of the tracklet in the xy plane
-  static TLinearFitter   *fgFitterY;
-  static TLinearFitter   *fgFitterZ;
+  static TLinearFitter   *fgFitterY;        // Linear Fitter for tracklet fit in xy-plane
+  static TLinearFitter   *fgFitterZ;        // Linear Fitter for tracklet fit in xz-plane
 
   ClassDef(AliTRDseedV1, 7)                 // The offline TRD tracklet 
 };
@@ -268,7 +268,7 @@ inline void AliTRDseedV1::Init(const AliRieman *rieman)
   fZref[1] = rieman->GetDZat(fX0);
   fYref[0] = rieman->GetYat(fX0);
   fYref[1] = rieman->GetDYat(fX0);
-  if(fReconstructor && fReconstructor->IsHLT()){
+  if(fkReconstructor && fkReconstructor->IsHLT()){
     fRefCov[0] = 1;
     fRefCov[2] = 10;
   }else{
@@ -294,7 +294,7 @@ inline AliTRDcluster* AliTRDseedV1::NextCluster()
     }
     return *fClusterIter;
   }
-  return 0x0;
+  return NULL;
 }
 
 //____________________________________________________________
@@ -312,7 +312,7 @@ inline AliTRDcluster* AliTRDseedV1::PrevCluster()
     }
     return *fClusterIter;
   }
-  return 0x0;
+  return NULL;
 }
 
 //____________________________________________________________
index d40b599..d1e9b1e 100644 (file)
@@ -22,8 +22,8 @@
 #include "AliTRDgeometry.h" 
 #include "AliTRDcluster.h" 
 #include "AliTRDtrack.h"
+#include "AliTRDtracklet.h"
 #include "AliTRDcalibDB.h"
-#include "Cal/AliTRDCalPID.h"
 
 ClassImp(AliTRDtrack)
 
@@ -31,6 +31,7 @@ ClassImp(AliTRDtrack)
 //                                                                           //
 //  Represents a reconstructed TRD track                                     //
 //  Local TRD Kalman track                                                   //
+//  Part of the old TRD tracking code                                        //
 //                                                                           //
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -60,7 +61,7 @@ AliTRDtrack::AliTRDtrack()
   //
 
   for (Int_t i = 0; i < kNplane; i++) {
-    for (Int_t j = 0; j < kNslice; j++) {
+    for (Int_t j = 0; j < AliTRDCalPID::kNSlicesLQ; j++) {
       fdEdxPlane[i][j] = 0.0;
     }
     fTimBinPlane[i] = -1;
@@ -139,7 +140,7 @@ AliTRDtrack::AliTRDtrack(AliTRDcluster *c, Int_t index
   fClusters[0] = c;
 
   for (Int_t i = 0; i < kNplane; i++) {
-    for (Int_t j = 0; j < kNslice; j++) {
+    for (Int_t j = 0; j < AliTRDCalPID::kNSlicesLQ; j++) {
       fdEdxPlane[i][j] = 0.0;
     }
     fTimBinPlane[i] = -1;
@@ -199,7 +200,7 @@ AliTRDtrack::AliTRDtrack(const AliTRDtrack &t/*, const Bool_t owner*/)
   //
 
   for (Int_t i = 0; i < kNplane; i++) {
-    for (Int_t j = 0; j < kNslice; j++) {
+    for (Int_t j = 0; j < AliTRDCalPID::kNSlicesLQ; j++) {
       fdEdxPlane[i][j] = t.fdEdxPlane[i][j];
     }
     fTimBinPlane[i] = t.fTimBinPlane[i];
@@ -270,7 +271,7 @@ AliTRDtrack::AliTRDtrack(const AliKalmanTrack &t, Double_t /*alpha*/)
   SetNumberOfClusters(0);
 
   for (Int_t i = 0; i < kNplane; i++) {
-    for (Int_t j = 0; j < kNslice; j++) {
+    for (Int_t j = 0; j < AliTRDCalPID::kNSlicesLQ; j++) {
       fdEdxPlane[i][j] = 0.0;
     }
     fTimBinPlane[i] = -1;
@@ -333,7 +334,7 @@ AliTRDtrack::AliTRDtrack(const AliESDtrack &t)
   }
 
   for (Int_t i = 0; i < kNplane; i++) {
-    for (Int_t j = 0; j < kNslice; j++) {
+    for (Int_t j = 0; j < AliTRDCalPID::kNSlicesLQ; j++) {
       fdEdxPlane[i][j] = t.GetTRDslice(i,j);
     }
     fTimBinPlane[i] = t.GetTRDTimBin(i);
@@ -492,7 +493,7 @@ void AliTRDtrack::CookdEdxTimBin(const Int_t/* tid*/)
   // Max charge in chamber
   Double_t  maxcharge[kNplane]; 
   // Number of clusters attached to track per chamber and slice
-  Int_t     nCluster[kNplane][kNslice];
+  Int_t     nCluster[kNplane][AliTRDCalPID::kNSlicesLQ];
   // Number of time bins in chamber
   Int_t ntb = AliTRDcalibDB::Instance()->GetNumberOfTimeBins();
   Int_t plane;                  // Plane of current cluster
@@ -504,7 +505,7 @@ void AliTRDtrack::CookdEdxTimBin(const Int_t/* tid*/)
   for (Int_t iPlane = 0; iPlane < kNplane; iPlane++) {
     fTimBinPlane[iPlane] = -1;
     maxcharge[iPlane]    =  0.0;
-    for (Int_t iSlice = 0; iSlice < kNslice; iSlice++) {
+    for (Int_t iSlice = 0; iSlice < AliTRDCalPID::kNSlicesLQ; iSlice++) {
       fdEdxPlane[iPlane][iSlice] = 0.0;
       nCluster[iPlane][iSlice]   = 0;
     }
@@ -530,7 +531,7 @@ void AliTRDtrack::CookdEdxTimBin(const Int_t/* tid*/)
       continue;
     }
        
-    slice = tb * kNslice / ntb;
+    slice = tb * AliTRDCalPID::kNSlicesLQ / ntb;
 
     fdEdxPlane[plane][slice] += fdQdl[iClus];
     if (fdQdl[iClus] > maxcharge[plane]) {
@@ -544,7 +545,7 @@ void AliTRDtrack::CookdEdxTimBin(const Int_t/* tid*/)
        
   // Normalize fdEdxPlane to number of clusters and set track segments
   for (Int_t iPlane = 0; iPlane < kNplane; iPlane++) {
-    for (Int_t iSlice = 0; iSlice < kNslice; iSlice++) {
+    for (Int_t iSlice = 0; iSlice < AliTRDCalPID::kNSlicesLQ; iSlice++) {
       if (nCluster[iPlane][iSlice]) {
         fdEdxPlane[iPlane][iSlice] /= nCluster[iPlane][iSlice];
       }
@@ -572,8 +573,8 @@ void AliTRDtrack::CookdEdxNN(Float_t *dedx)
 
   // Reset class and local contors/variables
   for (Int_t iPlane = 0; iPlane < kNplane; iPlane++){
-    for (Int_t iSlice = 0; iSlice < kNMLPslice; iSlice++) {
-      *(dedx + (kNMLPslice * iPlane) + iSlice) = 0.0;
+    for (Int_t iSlice = 0; iSlice < AliTRDCalPID::kNSlicesNN; iSlice++) {
+      *(dedx + (AliTRDCalPID::kNSlicesNN * iPlane) + iSlice) = 0.0;
     }
   }
 
@@ -599,9 +600,9 @@ void AliTRDtrack::CookdEdxNN(Float_t *dedx)
       continue;
     }
 
-    slice   = tb * kNMLPslice / ntb;
+    slice   = tb * AliTRDCalPID::kNSlicesNN / ntb;
          
-    *(dedx+(kNMLPslice * plane) + slice) += fdQdl[iClus]/kMLPscale;
+    *(dedx+(AliTRDCalPID::kNSlicesNN * plane) + slice) += fdQdl[iClus]/kMLPscale;
        
   } // End of loop over cluster
 
@@ -676,7 +677,7 @@ Bool_t AliTRDtrack::CookPID(Int_t &pidQuality)
   }
 
   // Calculate the input for the NN if fPIDmethod is kNN
-  Float_t ldEdxNN[AliTRDgeometry::kNlayer * kNMLPslice], *dedx = 0x0;
+  Float_t ldEdxNN[AliTRDgeometry::kNlayer * AliTRDCalPID::kNSlicesNN], *dedx = 0x0;
   if(fPIDmethod == kNN) {
     CookdEdxNN(&ldEdxNN[0]);
   }
@@ -717,7 +718,7 @@ Bool_t AliTRDtrack::CookPID(Int_t &pidQuality)
        dedx = fdEdxPlane[iPlane];
        break;
       case kNN:
-       dedx = &ldEdxNN[iPlane*kNMLPslice];
+       dedx = &ldEdxNN[iPlane*AliTRDCalPID::kNSlicesNN];
        break;
       }
       fPID[iSpecies] *= pd->GetProbability(iSpecies, fMom[iPlane], dedx, length, iPlane);
@@ -840,7 +841,7 @@ Bool_t AliTRDtrack::PropagateTo(Double_t xk, Double_t xx0, Double_t xrho)
 
 //_____________________________________________________________________________
 Bool_t AliTRDtrack::Update(const AliTRDcluster *c, Double_t chisq
-                         , Int_t index, Double_t h01)
+                         , Int_t index, Double_t h01) 
 {
   //
   // Assignes the found cluster <c> to the track and updates 
index 3d47d63..a14f079 100644 (file)
 //                                                                           //
 ///////////////////////////////////////////////////////////////////////////////
 
+#ifndef ALIESDTRACK_H
 #include "AliESDtrack.h"
+#endif
+
+#ifndef ALIKALMANTRACK_H
 #include "AliKalmanTrack.h"
+#endif
 
-#include "AliTRDtracklet.h"
 
-#ifndef ALITRDSEEDV1_H
-#include "AliTRDseedV1.h"
+#ifndef ALITRDCALPID_H
+#include "Cal/AliTRDCalPID.h"
+#endif
+
+#ifndef ALITRDTRACKLET
+#include "AliTRDtracklet.h"
 #endif
 
 class AliTrackReference;
@@ -33,9 +41,7 @@ class AliTRDtrack : public AliKalmanTrack {
        , kNstacks   =  90
        , kNplane    =   AliESDtrack::kTRDnPlanes
        , kNcham     =   5
-       , kNsect     =  18
-       , kNslice    =   3
-       , kNMLPslice =   8 };
+       , kNsect     =  18 };
   
   enum AliTRDPIDMethod {
          kNN = 0
@@ -75,8 +81,8 @@ class AliTRDtrack : public AliKalmanTrack {
          Int_t           GetPIDTimBin(Int_t i) const                  { return fTimBinPlane[i];              }
          Double_t        GetLikelihoodElectron() const                { return fLhElectron;                  }
          Int_t           GetSeedLabel() const                         { return fSeedLab;                     }
-         Int_t          *GetBackupIndexes()                           { return fIndexBackup;                 }
-         Int_t          *GetIndexes()                                 { return fIndex;                       }
+         const Int_t    *GetBackupIndexes() const                     { return fIndexBackup;                 }
+         const Int_t    *GetIndexes() const                           { return fIndex;                       }
          Int_t           GetProlongation(Double_t xk
                                        , Double_t &y
                                        , Double_t &z);
@@ -90,7 +96,7 @@ class AliTRDtrack : public AliKalmanTrack {
          AliTRDtracklet  GetTracklets(Int_t i) const                  { return fTracklets[i];                }
          Float_t         GetBudget(Int_t i) const                     { return fBudget[i];                   }
          Float_t         GetChi2Last() const                          { return fChi2Last;                    }
-         AliTRDtrack    *GetBackupTrack()                             { return fBackupTrack;                 }
+         AliTRDtrack    *GetBackupTrack() const                       { return fBackupTrack;                 }
          // dummy to bridge the function in AliTRDtrackV1
         //Int_t          GetNumberOfClusters() const                   { printf("AliTRDtrack::GetNumberOfClusters()\n"); 
          //                                                               return AliKalmanTrack::GetNumberOfClusters();   }
@@ -116,14 +122,14 @@ class AliTRDtrack : public AliKalmanTrack {
          void            SetNExpectedLast(Int_t nexp)                 { fNExpectedLast             = nexp;   }
          void            SetChi2Last(Float_t chi2)                    { fChi2Last                  = chi2;   }
          void            SetTracklets(Int_t i, AliTRDtracklet t)      { fTracklets[i]              = t;      }
-        void            SetBudget(Int_t i, Float_t budget)           { fBudget[i]                 = budget; }
+        void            SetBudget(Int_t i, Float_t budget)           { fBudget[i]                 = budget; }
          void            SetPIDMethod(AliTRDPIDMethod method)         { fPIDmethod                 = method; }
 
-         void           SetTrackSegmentDirMom(const Int_t plane);
+         void             SetTrackSegmentDirMom(const Int_t plane);
          void            CookdEdx(Double_t low = 0.05, Double_t up = 0.7);
          void            CookdEdxTimBin(const Int_t tid);
          Bool_t          CookPID(Int_t &pidQuality); 
-         void            SetCluster(AliTRDcluster* cl
+         void            SetCluster(AliTRDcluster * const cl
                                   , Int_t index = -1)                 { fClusters[(index == -1) 
                                                                                   ? GetNumberOfClusters()-1 
                                                                                   : index]         = cl;     }
@@ -160,9 +166,9 @@ class AliTRDtrack : public AliKalmanTrack {
 
  protected:
 
-  AliTRDtrack           &operator=(const AliTRDtrack &t);
+         AliTRDtrack           &operator=(const AliTRDtrack &t);
 
-        void            CookdEdxNN(Float_t *dedx);
+              void                CookdEdxNN(Float_t *dedx);
          Double_t        GetBz() const;
          Bool_t          Update(const AliCluster */*c*/, Double_t /*chi2*/, Int_t /*idx*/) { return 0;   }
          Double_t        GetPredictedChi2(const AliCluster* /*c*/) const                   { return 0.0; }
@@ -172,22 +178,22 @@ class AliTRDtrack : public AliKalmanTrack {
          Int_t    fSeedLab;                           //  Track label taken from seeding  
          Float_t  fdEdx;                              //  dE/dx (truncated mean)
          Float_t  fDE;                                //  Integrated delta energy
-         Float_t  fdEdxPlane[kNplane][kNslice];       //  dE/dx from all 6 planes in 3 slices each
+         Float_t  fdEdxPlane[kNplane][AliTRDCalPID::kNSlicesLQ];  //  dE/dx from all 6 planes in 3 slices each
          Int_t    fTimBinPlane[kNplane];              //  Time bin of Max cluster from all 6 planes
          UChar_t  fPIDquality;                        //  No of planes used for PID calculation        
          Double_t fPID[AliPID::kSPECIES];             //  PID probabilities
-        Float_t  fMom[kNplane];                      //  Track momentum at chamber entrance
-        Float_t  fSnp[kNplane];                      //  Track direction
-        Float_t  fTgl[kNplane];                      //  Track direction
-  AliTRDcluster  *fClusters[kMAXCLUSTERSPERTRACK];    //  List of assigned clusters
+              Float_t  fMom[kNplane];                      //  Track momentum at chamber entrance
+              Float_t  fSnp[kNplane];                      //  Track direction
+              Float_t  fTgl[kNplane];                      //  Track direction
+         AliTRDcluster  *fClusters[kMAXCLUSTERSPERTRACK];    //  List of assigned clusters
          Bool_t   fClusterOwner;                      //  Indicates the track is owner of cluster
-  AliTRDPIDMethod fPIDmethod;                         //  Switch between different PID methods
+         AliTRDPIDMethod fPIDmethod;                  //  Switch between different PID methods
          Bool_t   fStopped;                           //  Track stop indication
          Int_t    fIndex[kMAXCLUSTERSPERTRACK];       //  Global indexes of clusters  
          Int_t    fIndexBackup[kMAXCLUSTERSPERTRACK]; //  Backup indexes of clusters - used in iterations
          Float_t  fdQdl[kMAXCLUSTERSPERTRACK];        //  Cluster amplitudes corrected for track angles    
            
-        Float_t  fLhElectron;                        //  Likelihood to be an electron
+              Float_t  fLhElectron;                        //  Likelihood to be an electron
          Int_t    fNWrong;                            //  Number of wrong clusters
          Int_t    fNRotate;                           //  Number of rotation
          Int_t    fNCross;                            //  Number of the cross materials
@@ -196,12 +202,11 @@ class AliTRDtrack : public AliKalmanTrack {
          Int_t    fNExpectedLast;                     //  Number of expected clusters on last 2 layers
          Int_t    fNdedx;                             //  Number of clusters for dEdx measurment
          Float_t  fChi2Last;                          //  Chi2 in the  last 2 layers
-  AliTRDtracklet  fTracklets[6];                      //  Tracklets
+         AliTRDtracklet  fTracklets[6];               //  Tracklets
          Float_t  fBudget[3];                         //  Integrated material budget
-  AliTRDtrack    *fBackupTrack;                       //! Backup track
+         AliTRDtrack    *fBackupTrack;                //! Backup track
        
-        Int_t    fTrackletIndex[6];                  //  Tracklets index in the tracker list
-  AliTRDseedV1    fTracklet[6];                       //  Tracklets array defining the track
+        Int_t    fTrackletIndex[6];                  //  Tracklets index in the tracker list
 
   ClassDef(AliTRDtrack,9)                             //  TRD reconstructed tracks
 
index 6a20c6f..ca5ee78 100644 (file)
@@ -28,6 +28,7 @@
 #include "TClass.h"
 #include "TH1F.h"
 
+#include "AliESDTrdTrack.h"
 #include "AliLog.h"
 #include "AliTRDgtuParam.h"
 #include "AliTRDtrackGTU.h"
@@ -70,7 +71,7 @@ AliTRDtrackGTU::~AliTRDtrackGTU()
   delete fTracklets;
 }
 
-void AliTRDtrackGTU::AddTracklet(AliTRDtrackletGTU *tracklet, Int_t layer) 
+void AliTRDtrackGTU::AddTracklet(const AliTRDtrackletGTU * const tracklet, Int_t layer) 
 {
 // add a tracklet to this track
 
index d179b27..302aa76 100644 (file)
@@ -14,7 +14,7 @@
 #include "TClonesArray.h"
 
 #include "AliTRDtrackletGTU.h"
-#include "AliESDTrdTrack.h"
+class AliESDTrdTrack;
 
 class AliTRDtrackGTU : public TObject {
  public:
@@ -48,7 +48,7 @@ class AliTRDtrackGTU : public TObject {
   Int_t GetYapprox();
 
 
-  void AddTracklet(AliTRDtrackletGTU *tracklet, Int_t layer);
+  void AddTracklet(const AliTRDtrackletGTU * const tracklet, Int_t layer);
 
   void SetStack(Int_t stack) { fStack = stack; }
   void SetSector(Int_t sector) { fSector = sector; }
index 8e988a1..58dba39 100644 (file)
@@ -42,10 +42,10 @@ ClassImp(AliTRDtrackV1)
 AliTRDtrackV1::AliTRDtrackV1() : AliKalmanTrack()
   ,fStatus(0)
   ,fDE(0.)
-  ,fReconstructor(0x0)
-  ,fBackupTrack(0x0)
-  ,fTrackLow(0x0)
-  ,fTrackHigh(0x0)
+  ,fkReconstructor(NULL)
+  ,fBackupTrack(NULL)
+  ,fTrackLow(NULL)
+  ,fTrackHigh(NULL)
 {
   //
   // Default constructor
@@ -59,7 +59,7 @@ AliTRDtrackV1::AliTRDtrackV1() : AliKalmanTrack()
 
   for(int ip=0; ip<kNplane; ip++){
     fTrackletIndex[ip] = 0xffff;
-    fTracklet[ip]      = 0x0;
+    fTracklet[ip]      = NULL;
   }
 }
 
@@ -67,10 +67,10 @@ AliTRDtrackV1::AliTRDtrackV1() : AliKalmanTrack()
 AliTRDtrackV1::AliTRDtrackV1(const AliTRDtrackV1 &ref) : AliKalmanTrack(ref)
   ,fStatus(ref.fStatus)
   ,fDE(ref.fDE)
-  ,fReconstructor(ref.fReconstructor)
-  ,fBackupTrack(0x0)
-  ,fTrackLow(0x0)
-  ,fTrackHigh(0x0)
+  ,fkReconstructor(ref.fkReconstructor)
+  ,fBackupTrack(NULL)
+  ,fTrackLow(NULL)
+  ,fTrackHigh(NULL)
 {
   //
   // Copy constructor
@@ -96,10 +96,10 @@ AliTRDtrackV1::AliTRDtrackV1(const AliTRDtrackV1 &ref) : AliKalmanTrack(ref)
 AliTRDtrackV1::AliTRDtrackV1(const AliESDtrack &t) : AliKalmanTrack()
   ,fStatus(0)
   ,fDE(0.)
-  ,fReconstructor(0x0)
-  ,fBackupTrack(0x0)
-  ,fTrackLow(0x0)
-  ,fTrackHigh(0x0)
+  ,fkReconstructor(NULL)
+  ,fBackupTrack(NULL)
+  ,fTrackLow(NULL)
+  ,fTrackHigh(NULL)
 {
   //
   // Constructor from AliESDtrack
@@ -113,7 +113,7 @@ AliTRDtrackV1::AliTRDtrackV1(const AliESDtrack &t) : AliKalmanTrack()
   Int_t ti[kNplane]; t.GetTRDtracklets(&ti[0]);
   for(int ip=0; ip<kNplane; ip++){ 
     fTrackletIndex[ip] = ti[ip] < 0 ? 0xffff : ti[ip];
-    fTracklet[ip]      = 0x0;
+    fTracklet[ip]      = NULL;
   }
   for(int i =0; i<3; i++) fBudget[i] = 0.;
   
@@ -143,14 +143,14 @@ AliTRDtrackV1::AliTRDtrackV1(const AliESDtrack &t) : AliKalmanTrack()
 }
 
 //_______________________________________________________________
-AliTRDtrackV1::AliTRDtrackV1(AliTRDseedV1 *trklts, const Double_t p[5], const Double_t cov[15]
+AliTRDtrackV1::AliTRDtrackV1(const AliTRDseedV1 * const trklts, const Double_t p[5], const Double_t cov[15]
              , Double_t x, Double_t alpha) : AliKalmanTrack()
   ,fStatus(0)
   ,fDE(0.)
-  ,fReconstructor(0x0)
-  ,fBackupTrack(0x0)
-  ,fTrackLow(0x0)
-  ,fTrackHigh(0x0)
+  ,fkReconstructor(NULL)
+  ,fBackupTrack(NULL)
+  ,fTrackLow(NULL)
+  ,fTrackHigh(NULL)
 {
   //
   // The stand alone tracking constructor
@@ -191,9 +191,9 @@ AliTRDtrackV1::AliTRDtrackV1(AliTRDseedV1 *trklts, const Double_t p[5], const Do
   Int_t ncls = 0;
        for(int iplane=0; iplane<kNplane; iplane++){
     fTrackletIndex[iplane] = 0xffff;
-               if(!trklts[iplane].IsOK()) fTracklet[iplane] = 0x0;
+               if(!trklts[iplane].IsOK()) fTracklet[iplane] = NULL;
     else{ 
-      fTracklet[iplane] = &trklts[iplane];
+      fTracklet[iplane] = const_cast<AliTRDseedV1 *>(&trklts[iplane]);
       ncls += fTracklet[iplane]->GetN();
     }
        }
@@ -211,14 +211,14 @@ AliTRDtrackV1::~AliTRDtrackV1()
   //AliInfo("");
   //printf("I-AliTRDtrackV1::~AliTRDtrackV1() : Owner[%s]\n", TestBit(kOwner)?"YES":"NO");
 
-  if(fBackupTrack) delete fBackupTrack; fBackupTrack = 0x0;
+  if(fBackupTrack) delete fBackupTrack; fBackupTrack = NULL;
 
-  if(fTrackLow) delete fTrackLow; fTrackLow = 0x0;
-  if(fTrackHigh) delete fTrackHigh; fTrackHigh = 0x0;
+  if(fTrackLow) delete fTrackLow; fTrackLow = NULL;
+  if(fTrackHigh) delete fTrackHigh; fTrackHigh = NULL;
 
   for(Int_t ip=0; ip<kNplane; ip++){
     if(TestBit(kOwner) && fTracklet[ip]) delete fTracklet[ip];
-    fTracklet[ip] = 0x0;
+    fTracklet[ip] = NULL;
     fTrackletIndex[ip] = 0xffff;
   }
 }
@@ -237,7 +237,7 @@ Bool_t AliTRDtrackV1::CookLabel(Float_t wrong)
   
   Bool_t labelAdded;
   Int_t label;
-  AliTRDcluster *c    = 0x0;
+  AliTRDcluster *c    = NULL;
   for (Int_t ip = 0; ip < kNplane; ip++) {
     if(fTrackletIndex[ip] == 0xffff) continue;
     for (Int_t ic = 0; ic < AliTRDseedV1::kNclusters; ic++) {
@@ -322,7 +322,7 @@ UChar_t AliTRDtrackV1::GetNumberOfTrackletsPID() const
 // Retrieve number of tracklets used for PID calculation. 
 
   UChar_t nPID = 0;
-  Float_t *prob = 0x0;
+  Float_t *prob = NULL;
   for(int ip=0; ip<kNplane; ip++){
     if(fTrackletIndex[ip] == 0xffff) continue;
     if(!fTracklet[ip]->IsOK()) continue;
@@ -349,7 +349,7 @@ UChar_t AliTRDtrackV1::SetNumberOfTrackletsPID(Bool_t recalc)
   UChar_t fPIDquality = 0;
   
   // steer PID calculation @ tracklet level
-  Float_t *prob = 0x0;
+  Float_t *prob = NULL;
   for(int ip=0; ip<kNplane; ip++){
     if(fTrackletIndex[ip] == 0xffff) continue;
     if(!fTracklet[ip]->IsOK()) continue;
@@ -371,6 +371,7 @@ UChar_t AliTRDtrackV1::SetNumberOfTrackletsPID(Bool_t recalc)
 //_______________________________________________________________
 AliTRDcluster* AliTRDtrackV1::GetCluster(Int_t id)
 {
+  // Get the cluster at a certain position in the track
   Int_t n = 0;
   for(Int_t ip=0; ip<kNplane; ip++){
     if(!fTracklet[ip]) continue;
@@ -378,7 +379,7 @@ AliTRDcluster* AliTRDtrackV1::GetCluster(Int_t id)
       n+=fTracklet[ip]->GetN();
       continue;
     }
-    AliTRDcluster *c = 0x0;
+    AliTRDcluster *c = NULL;
     for(Int_t ic=AliTRDseedV1::kNclusters; ic--;){
       if(!(c = fTracklet[ip]->GetClusters(ic))) continue;
 
@@ -386,12 +387,13 @@ AliTRDcluster* AliTRDtrackV1::GetCluster(Int_t id)
       return c;
     }
   }
-  return 0x0;
+  return NULL;
 }
 
 //_______________________________________________________________
 Int_t  AliTRDtrackV1::GetClusterIndex(Int_t id) const
 {
+  // Get the cluster index at a certain position in the track
   Int_t n = 0;
   for(Int_t ip=0; ip<kNplane; ip++){
     if(!fTracklet[ip]) continue;
@@ -399,7 +401,7 @@ Int_t  AliTRDtrackV1::GetClusterIndex(Int_t id) const
       n+=fTracklet[ip]->GetN();
       continue;
     }
-    AliTRDcluster *c = 0x0;
+    AliTRDcluster *c = NULL;
     for(Int_t ic=AliTRDseedV1::kNclusters; ic--;){
       if(!(c = fTracklet[ip]->GetClusters(ic))) continue;
 
@@ -437,6 +439,7 @@ Int_t AliTRDtrackV1::GetSector() const
 //_______________________________________________________________
 Bool_t AliTRDtrackV1::IsEqual(const TObject *o) const
 {
+  // Checks whether two tracks are equal
   if (!o) return kFALSE;
   const AliTRDtrackV1 *inTrack = dynamic_cast<const AliTRDtrackV1*>(o);
   if (!inTrack) return kFALSE;
@@ -493,7 +496,7 @@ Bool_t AliTRDtrackV1::IsEqual(const TObject *o) const
 //_______________________________________________________________
 Bool_t AliTRDtrackV1::IsElectron() const
 {
-  if(GetPID(0) > fReconstructor->GetRecoParam()->GetPIDThreshold(GetP())) return kTRUE;
+  if(GetPID(0) > fkReconstructor->GetRecoParam()->GetPIDThreshold(GetP())) return kTRUE;
   return kFALSE;
 }
 
@@ -675,6 +678,7 @@ Int_t   AliTRDtrackV1::PropagateToR(Double_t r,Double_t step)
 //_____________________________________________________________________________
 void AliTRDtrackV1::Print(Option_t *o) const
 {
+  // Print track status
   AliInfo(Form("PID [%4.1f %4.1f %4.1f %4.1f %4.1f]", 1.E2*fPID[0], 1.E2*fPID[1], 1.E2*fPID[2], 1.E2*fPID[3], 1.E2*fPID[4]));
   AliInfo(Form("Material[%5.2f %5.2f %5.2f]", fBudget[0], fBudget[1], fBudget[2]));
 
@@ -749,7 +753,7 @@ void AliTRDtrackV1::SetOwner()
 }
 
 //_______________________________________________________________
-void AliTRDtrackV1::SetTracklet(AliTRDseedV1 *trklt, Int_t index)
+void AliTRDtrackV1::SetTracklet(AliTRDseedV1 *const trklt, Int_t index)
 {
   //
   // Set the tracklets
@@ -779,7 +783,7 @@ void AliTRDtrackV1::UnsetTracklet(Int_t plane)
 {
   if(plane<0 && plane >= kNplane) return;
   fTrackletIndex[plane] = 0xffff;
-  fTracklet[plane] = 0x0;
+  fTracklet[plane] = NULL;
 }
 
 
@@ -804,7 +808,7 @@ void AliTRDtrackV1::UpdateESDtrack(AliESDtrack *track)
   // Update the TRD PID information in the ESD track
   //
 
-  Int_t nslices = fReconstructor->IsEightSlices() ? (Int_t)AliTRDpidUtil::kNNslices : (Int_t)AliTRDpidUtil::kLQslices;
+  Int_t nslices = fkReconstructor->IsEightSlices() ? (Int_t)AliTRDpidUtil::kNNslices : (Int_t)AliTRDpidUtil::kLQslices;
   // number of tracklets used for PID calculation
   UChar_t nPID = GetNumberOfTrackletsPID();
   // number of tracklets attached to the track
@@ -818,7 +822,7 @@ void AliTRDtrackV1::UpdateESDtrack(AliESDtrack *track)
   for (Int_t ip = 0; ip < kNplane; ip++) {
     if(fTrackletIndex[ip] == 0xffff) continue;
     if(!fTracklet[ip]->HasPID()) continue;
-    Float_t *dedx = fTracklet[ip]->GetdEdx();
+    const Float_t *dedx = fTracklet[ip]->GetdEdx();
     for (Int_t js = 0; js < nslices; js++, dedx++) track->SetTRDslice(*dedx, ip, js);
     p = fTracklet[ip]->GetMomentum(&sp); spd = sp;
     track->SetTRDmomentum(p, ip, &spd);
index eafe6fd..f50f7bb 100644 (file)
 //                                                                           //
 ///////////////////////////////////////////////////////////////////////////////
 
-#ifndef ALIKALMANTRACK_H
+//#ifndef ALIKALMANTRACK_H
 #include "AliKalmanTrack.h"
-#endif
-
-#ifndef ALIESDTRACK_H
-#include "AliESDtrack.h"
-#endif
+//#endif
 
-#ifndef ALITRDSEEDV1_H
+//#ifndef ALITRDSEEDV1_H
 #include "AliTRDseedV1.h"
-#endif
+//#endif
 
 class AliTRDcluster;
 class AliESDtrack;
@@ -70,7 +66,7 @@ public:
   };
 
   AliTRDtrackV1();
-  AliTRDtrackV1(AliTRDseedV1 *trklts, const Double_t p[5], const Double_t cov[15], Double_t x, Double_t alpha);
+  AliTRDtrackV1(const AliTRDseedV1 * const trklts, const Double_t p[5], const Double_t cov[15], Double_t x, Double_t alpha);
   AliTRDtrackV1(const AliESDtrack &ref);
   AliTRDtrackV1(const AliTRDtrackV1 &ref);
   virtual ~AliTRDtrackV1();
@@ -94,13 +90,13 @@ public:
   Int_t          GetProlongation(Double_t xk, Double_t &y, Double_t &z);
   inline UChar_t GetStatusTRD(Int_t ly=-1) const;
   Int_t          GetSector() const;
-  AliTRDseedV1*  GetTracklet(Int_t plane) const {return plane >=0 && plane <kNplane ? fTracklet[plane] : 0x0;}
+  AliTRDseedV1*  GetTracklet(Int_t plane) const {return plane >=0 && plane <kNplane ? fTracklet[plane] : NULL;}
   Int_t          GetTrackletIndex(Int_t plane) const          { return (plane>=0 && plane<kNplane) ? fTrackletIndex[plane] : -1;}
   AliExternalTrackParam*
                  GetTrackLow() const  { return fTrackLow;} 
   AliExternalTrackParam*
                  GetTrackHigh() const  { return fTrackHigh;} 
-  UShort_t*      GetTrackletIndexes() { return &fTrackletIndex[0];}
+  const UShort_t* GetTrackletIndexes() const { return &fTrackletIndex[0];}
   
   Bool_t         IsEqual(const TObject *inTrack) const;
   Bool_t         IsKink() const    { return TestBit(kKink);}
@@ -123,17 +119,17 @@ public:
   UChar_t        SetNumberOfTrackletsPID(Bool_t recalc);
   void           SetOwner();
   void           SetPID(Short_t is, Double_t inPID){if (is >=0 && is < AliPID::kSPECIES) fPID[is]=inPID;};
-  void           SetPIDquality(UChar_t /*inPIDquality*/){/*fPIDquality = inPIDquality*/;};
+  void           SetPIDquality(UChar_t /*inPIDquality*/) const {/*fPIDquality = inPIDquality*/;};
   inline void    SetStatus(UChar_t stat, Int_t ly=-1);
   void           SetStopped(Bool_t stop) {SetBit(kStopped, stop);}
-  void           SetTracklet(AliTRDseedV1 *trklt,  Int_t index);
+  void           SetTracklet(AliTRDseedV1 *const trklt,  Int_t index);
   void           SetTrackLow();
-  void           SetTrackHigh(const AliExternalTrackParam *op=0x0);
+  void           SetTrackHigh(const AliExternalTrackParam *op=NULL);
   inline void    SetReconstructor(const AliTRDReconstructor *rec);
   inline Float_t StatusForTOF();
   void           UnsetTracklet(Int_t plane);
   Bool_t         Update(Double_t *p, Double_t *cov, Double_t chi2);
-  Bool_t         Update(const AliCluster *, Double_t, Int_t)                        { return kFALSE; };
+  Bool_t         Update(const AliCluster *, Double_t, Int_t) { return kFALSE; };
   void           UpdateESDtrack(AliESDtrack *t);
 
 private:
@@ -142,7 +138,7 @@ private:
   Double32_t   fPID[AliPID::kSPECIES]; //  PID probabilities
   Double32_t   fBudget[3];             //  Integrated material budget
   Double32_t   fDE;                    //  Integrated delta energy
-  const AliTRDReconstructor *fReconstructor;//! reconstructor link 
+  const AliTRDReconstructor *fkReconstructor;//! reconstructor link 
   AliTRDtrackV1 *fBackupTrack;         //! Backup track
   AliTRDseedV1 *fTracklet[kNplane];    //  Tracklets array defining the track
   AliExternalTrackParam *fTrackLow;    // parameters of the track which enter TRD from below (TPC) 
@@ -206,7 +202,7 @@ inline void AliTRDtrackV1::SetReconstructor(const AliTRDReconstructor *rec)
     if(!fTracklet[ip]) continue;
     fTracklet[ip]->SetReconstructor(rec);
   }
-  fReconstructor = rec;
+  fkReconstructor = rec;
 }
 
 //____________________________________________________
index 918f316..7e82a90 100644 (file)
@@ -36,7 +36,8 @@
 
 #include "AliESDEvent.h"
 #include "AliESDtrack.h"
-#include "AliAlignObj.h"
+//#include "AliAlignObj.h"
+#include "AliGeomManager.h"
 #include "AliRieman.h"
 #include "AliTrackPointArray.h"
 
@@ -75,18 +76,18 @@ AliTRDtracker::AliTRDtracker(AliTRDReconstructor *rec)
   ,fTimeBinsPerPlane(0)
   ,fAddTRDseeds(kFALSE)
   ,fNoTilt(kFALSE)
-  ,fHBackfit(0x0)
-  ,fHClSearch(0x0)
-  ,fHRefit(0x0)
-  ,fHX(0x0)
-  ,fHNCl(0x0)
-  ,fHNClTrack(0x0)
-  ,fHMinYPos(0x0)
-  ,fHMinYNeg(0x0)
-  ,fHMinZ(0x0)
-  ,fHMinD(0x0)
-  ,fHDeltaX(0x0)
-  ,fHXCl(0x0)
+  ,fHBackfit(NULL)
+  ,fHClSearch(NULL)
+  ,fHRefit(NULL)
+  ,fHX(NULL)
+  ,fHNCl(NULL)
+  ,fHNClTrack(NULL)
+  ,fHMinYPos(NULL)
+  ,fHMinYNeg(NULL)
+  ,fHMinZ(NULL)
+  ,fHMinD(NULL)
+  ,fHDeltaX(NULL)
+  ,fHXCl(NULL)
   ,fDebugStreamer(0)
 {
   //
@@ -115,18 +116,18 @@ AliTRDtracker::AliTRDtracker(const AliTRDtracker &t)
   ,fTimeBinsPerPlane(0)
   ,fAddTRDseeds(kFALSE)
   ,fNoTilt(kFALSE)
-  ,fHBackfit(0x0)
-  ,fHClSearch(0x0)
-  ,fHRefit(0x0)
-  ,fHX(0x0)
-  ,fHNCl(0x0)
-  ,fHNClTrack(0x0)
-  ,fHMinYPos(0x0)
-  ,fHMinYNeg(0x0)
-  ,fHMinZ(0x0)
-  ,fHMinD(0x0)
-  ,fHDeltaX(0x0)
-  ,fHXCl(0x0)
+  ,fHBackfit(NULL)
+  ,fHClSearch(NULL)
+  ,fHRefit(NULL)
+  ,fHX(NULL)
+  ,fHNCl(NULL)
+  ,fHNClTrack(NULL)
+  ,fHMinYPos(NULL)
+  ,fHMinYNeg(NULL)
+  ,fHMinZ(NULL)
+  ,fHMinD(NULL)
+  ,fHDeltaX(NULL)
+  ,fHXCl(NULL)
   ,fDebugStreamer(0)
 {
   //
@@ -149,18 +150,18 @@ AliTRDtracker::AliTRDtracker(const TFile */*geomfile*/, AliTRDReconstructor *rec
   ,fTimeBinsPerPlane(0)
   ,fAddTRDseeds(kFALSE)
   ,fNoTilt(kFALSE)
-  ,fHBackfit(0x0)
-  ,fHClSearch(0x0)
-  ,fHRefit(0x0)
-  ,fHX(0x0)
-  ,fHNCl(0x0)
-  ,fHNClTrack(0x0)
-  ,fHMinYPos(0x0)
-  ,fHMinYNeg(0x0)
-  ,fHMinZ(0x0)
-  ,fHMinD(0x0)
-  ,fHDeltaX(0x0)
-  ,fHXCl(0x0)
+  ,fHBackfit(NULL)
+  ,fHClSearch(NULL)
+  ,fHRefit(NULL)
+  ,fHX(NULL)
+  ,fHNCl(NULL)
+  ,fHNClTrack(NULL)
+  ,fHMinYPos(NULL)
+  ,fHMinYNeg(NULL)
+  ,fHMinZ(NULL)
+  ,fHMinD(NULL)
+  ,fHDeltaX(NULL)
+  ,fHXCl(NULL)
   ,fDebugStreamer(0)
 {
   // 
@@ -319,7 +320,7 @@ Int_t  AliTRDtracker::GlobalToLocalID(Int_t gid)
 }
 
 //_____________________________________________________________________________
-Bool_t AliTRDtracker::AdjustSector(AliTRDtrack *track) 
+Bool_t AliTRDtracker::AdjustSector(AliTRDtrack* const track) const 
 {
   //
   // Rotates the track when necessary
@@ -345,7 +346,7 @@ Bool_t AliTRDtracker::AdjustSector(AliTRDtrack *track)
 }
 
 //_____________________________________________________________________________
-AliTRDcluster *AliTRDtracker::GetCluster(AliTRDtrack *track, Int_t plane
+AliTRDcluster *AliTRDtracker::GetCluster(AliTRDtrack * const track, Int_t plane
                                        , Int_t timebin, UInt_t &index)
 {
   //
@@ -353,7 +354,7 @@ AliTRDcluster *AliTRDtracker::GetCluster(AliTRDtrack *track, Int_t plane
   //
 
   AliTRDcluster *cl =0;
-  Int_t *indexes = track->GetBackupIndexes();
+  const Int_t *indexes = track->GetBackupIndexes();
 
   for (UInt_t i = 0; i < kMaxTimeBinIndex; i++) {
     if (indexes[i] == 0) {
@@ -379,14 +380,14 @@ AliTRDcluster *AliTRDtracker::GetCluster(AliTRDtrack *track, Int_t plane
 }
 
 //_____________________________________________________________________________
-Int_t  AliTRDtracker::GetLastPlane(AliTRDtrack *track)
+Int_t  AliTRDtracker::GetLastPlane(AliTRDtrack * const track)
 {
   //
   // Return last updated plane
   //
 
   Int_t  lastplane = 0;
-  Int_t *indexes   = track->GetBackupIndexes();
+  const Int_t *indexes   = track->GetBackupIndexes();
 
   for (UInt_t i = 0; i < kMaxTimeBinIndex; i++) {
     AliTRDcluster *cli = (AliTRDcluster *) fClusters->UncheckedAt(indexes[i]);
@@ -601,9 +602,9 @@ Int_t AliTRDtracker::PropagateBack(AliESDEvent *event)
                                seed->UpdateTrackParams(track,AliESDtrack::kTRDout);
                                fHBackfit->Fill(10);
        
-        seed->SetNumberOfTRDslices(AliTRDtrack::kNslice);
+        seed->SetNumberOfTRDslices(AliTRDCalPID::kNSlicesLQ);
                                for (Int_t i = 0; i < AliTRDtrack::kNplane; i++) {
-                                       for (Int_t j = 0; j < AliTRDtrack::kNslice; j++) {
+                                       for (Int_t j = 0; j < AliTRDCalPID::kNSlicesLQ; j++) {
                                                seed->SetTRDslice(track->GetPIDsignals(i,j),i,j);
                                        }
                                        seed->SetTRDTimBin(track->GetPIDTimBin(i),i);
@@ -625,9 +626,9 @@ Int_t AliTRDtracker::PropagateBack(AliESDEvent *event)
        
                                //seed->SetStatus(AliESDtrack::kTRDStop);
 
-        seed->SetNumberOfTRDslices(AliTRDtrack::kNslice);
+        seed->SetNumberOfTRDslices(AliTRDCalPID::kNSlicesLQ);
                                for (Int_t i = 0; i < AliTRDtrack::kNplane; i++) {
-                                       for (Int_t j = 0; j <AliTRDtrack::kNslice; j++) {
+                                       for (Int_t j = 0; j <AliTRDCalPID::kNSlicesLQ; j++) {
                                                seed->SetTRDslice(track->GetPIDsignals(i,j),i,j);
                                        }
                                        seed->SetTRDTimBin(track->GetPIDTimBin(i),i);
@@ -712,15 +713,15 @@ Int_t AliTRDtracker::RefitInward(AliESDEvent *event)
     seed2.ResetCovariance(50.0); 
 
     AliTRDtrack *pt = new AliTRDtrack(seed2,seed2.GetAlpha());
-    Int_t *indexes2 = seed2.GetIndexes();
+    const Int_t *indexes2 = seed2.GetIndexes();
     for (Int_t l = 0; l < AliTRDtrack::kNplane;++l) {
-      for (Int_t j = 0; j < AliTRDtrack::kNslice;j++) {
+      for (Int_t j = 0; j < AliTRDCalPID::kNSlicesLQ;j++) {
         pt->SetPIDsignals(seed2.GetPIDsignals(l,j),l,j);
       }
       pt->SetPIDTimBin(seed2.GetPIDTimBin(l),l);
     }
 
-    Int_t *indexes3 = pt->GetBackupIndexes();
+    Int_t *indexes3 = const_cast<Int_t *>(pt->GetBackupIndexes());
     for (Int_t l = 0; l < 200;++l) {
       if (indexes2[l] == 0) {
         break;
@@ -748,7 +749,7 @@ Int_t AliTRDtracker::RefitInward(AliESDEvent *event)
       fHRefit->Fill(5);
 
       for (Int_t l = 0; l < AliTRDtrack::kNplane; ++l) {
-        for (Int_t j = 0; j < AliTRDtrack::kNslice; j++) {
+        for (Int_t j = 0; j < AliTRDCalPID::kNSlicesLQ; j++) {
           seed->SetTRDslice(pt->GetPIDsignals(l,j),l,j);
         }
         seed->SetTRDTimBin(pt->GetPIDTimBin(l),l);
@@ -768,7 +769,7 @@ Int_t AliTRDtracker::RefitInward(AliESDEvent *event)
         fHRefit->Fill(6);
 
         for (Int_t l = 0; l < AliTRDtrack::kNplane; ++l) {
-          for (Int_t j = 0; j < AliTRDtrack::kNslice; j++) {
+          for (Int_t j = 0; j < AliTRDCalPID::kNSlicesLQ; j++) {
             seed->SetTRDslice(pt2->GetPIDsignals(l,j),l,j);
           }
           seed->SetTRDTimBin(pt2->GetPIDTimBin(l),l);
@@ -2491,7 +2492,7 @@ Int_t AliTRDtracker::ReadClusters(TObjArray *array, TTree *clusterTree) const
   // Loop through all entries in the tree
   Int_t nEntries   = (Int_t) clusterTree->GetEntries();
   Int_t nbytes     = 0;
-  AliTRDcluster *c = 0x0;
+  AliTRDcluster *c = NULL;
   for (Int_t iEntry = 0; iEntry < nEntries; iEntry++) {    
     
     // Import the tree
@@ -2783,7 +2784,7 @@ AliTRDtracker::AliTRDtrackingSector
     //Double_t xtop    = x0 + dxAmp;
                
                //temporary !! (A.Bercuci)
-    Int_t T0 = (Int_t)fCalibration->GetT0Average(AliTRDgeometry::GetDetector(layer, 2, gs));
+    Int_t t0 = (Int_t)fCalibration->GetT0Average(AliTRDgeometry::GetDetector(layer, 2, gs));
 
     Int_t nTimeBins =  AliTRDcalibDB::Instance()->GetNumberOfTimeBins();    
     for (Int_t iTime = 0; iTime < nTimeBins; iTime++) {
@@ -2797,7 +2798,7 @@ AliTRDtracker::AliTRDtrackingSector
       ppl->SetYmax(ymax,ymaxsensitive);
       ppl->SetZ(zc,zmax,zmaxsensitive);
       ppl->SetHoles(holes);
-      if(iTime == T0) ppl->SetT0();
+      if(iTime == t0) ppl->SetT0();
                        
                        InsertLayer(ppl);      
 
@@ -3781,7 +3782,7 @@ Int_t AliTRDtracker::Freq(Int_t n, const Int_t *inlist
 }
 
 //_____________________________________________________________________________
-AliTRDtrack *AliTRDtracker::RegisterSeed(AliTRDseed *seeds, Double_t *params)
+AliTRDtrack *AliTRDtracker::RegisterSeed(AliTRDseed * const seeds, Double_t *params)
 {
   //
   // Build a TRD track out of tracklet candidates
index e887ad7..8d28170 100644 (file)
@@ -59,13 +59,13 @@ class AliTRDtracker : public AliTracker {
        , kMaxTimeBinIndex      = 216
        , kTrackingSectors      = 18   };
   
-  AliTRDtracker(AliTRDReconstructor *rec = 0x0);
+  AliTRDtracker(AliTRDReconstructor *rec = NULL);
   AliTRDtracker(const AliTRDtracker &t);
-  AliTRDtracker(const TFile *in, AliTRDReconstructor *rec = 0x0);
+  AliTRDtracker(const TFile *in, AliTRDReconstructor *rec = NULL);
   virtual         ~AliTRDtracker(); 
   AliTRDtracker   &operator=(const AliTRDtracker &/*t*/) { return *this;          } 
   
-  void             SetReconstructor(AliTRDReconstructor *rec) {fReconstructor = rec;}
+  void             SetReconstructor(AliTRDReconstructor * const rec) {fReconstructor = rec;}
   void             SetAddTRDseeds()               { fAddTRDseeds = kTRUE;         }
   void             SetNoTilt()                    { fNoTilt      = kTRUE;         }
   
@@ -73,7 +73,7 @@ class AliTRDtracker : public AliTracker {
   Double_t         GetMaxChi2() const             { return fgkMaxChi2;            }
   Float_t          GetLabelFraction() const       { return fgkLabelFraction;      }
   Float_t          GetMinClustersInTrack() const  { return fgkMinClustersInTrack; }
-  Int_t            GetLastPlane(AliTRDtrack *track);
+  Int_t            GetLastPlane(AliTRDtrack *const track);
   Double_t         GetTiltFactor(const AliTRDcluster *c);
   virtual Bool_t   GetTrackPoint(Int_t index, AliTrackPoint& p) const;
   Double_t         GetX(Int_t sec, Int_t plane, Int_t localTB) const;
@@ -100,14 +100,14 @@ class AliTRDtracker : public AliTracker {
   void             UnloadClusters();
   virtual void     UseClusters(const AliKalmanTrack *t, Int_t from = 0) const;  
   Int_t            ReadClusters(TObjArray *array, TTree *in) const;
-  AliTRDcluster   *GetCluster(AliTRDtrack *track, Int_t plane, Int_t timebin, UInt_t &index);
+  AliTRDcluster   *GetCluster(AliTRDtrack * const track, Int_t plane, Int_t timebin, UInt_t &index);
   Int_t            FindClusters(Int_t sector, Int_t t0, Int_t t1, AliTRDtrack *track
                               , Int_t *clusters, AliTRDtracklet &tracklet);  
   
  protected:
 
-  Bool_t           AdjustSector(AliTRDtrack *track); 
-  AliTRDtrack     *RegisterSeed(AliTRDseed *seeds, Double_t *params);
+  Bool_t           AdjustSector(AliTRDtrack *const track) const; 
+  AliTRDtrack     *RegisterSeed(AliTRDseed * const seeds, Double_t *params);
   Int_t            FollowBackProlongation(AliTRDtrack &t);
   //void             MakeSeedsMI(Int_t inner, Int_t outer, AliESDEvent *esd = 0);
   
@@ -131,7 +131,7 @@ class AliTRDtracker : public AliTracker {
     Int_t    GetOuterTimeBin() const;
     Int_t    GetLayerNumber(Int_t tb) const        { return fTimeBinIndex[tb];   }
     Double_t GetX(Int_t pl) const                  { return fLayers[pl]->GetX(); }
-    AliTRDpropagationLayer* GetLayer(Int_t i)      { return fLayers[i];          }
+    AliTRDpropagationLayer* GetLayer(Int_t i) const { return fLayers[i];          }
     Int_t    GetSector() const {return fGeomSector;}   
     
     void     MapTimeBinLayers();
@@ -150,7 +150,7 @@ class AliTRDtracker : public AliTracker {
   };
   
  protected:
-  AliTRDReconstructor     *fReconstructor;
+  AliTRDReconstructor     *fReconstructor;                 // TRD Reconstructor
   AliTRDgeometry          *fGeom;                          // Pointer to TRD geometry
   AliTRDtrackingSector    *fTrSec[kTrackingSectors];       // Array of tracking sectors;    
   Int_t                    fNclusters;                     // Number of clusters in TRD 
index f91ee07..70dd46e 100644 (file)
@@ -25,8 +25,6 @@
 //                                                                           //
 ///////////////////////////////////////////////////////////////////////////////
 
-#include "AliTRDtrackerDebug.h"
-
 #include "TFile.h"
 #include "TTree.h"
 #include "TTreeStream.h"
 #include "TMath.h"
 
 #include "AliLog.h"
+
 #include "AliTRDgeometry.h"
 #include "AliTRDtrackV1.h"
 #include "AliTRDseedV1.h"
-#include "AliTRDseed.h"
 #include "AliTRDcluster.h"
 #include "AliTRDgeometry.h"
 
+#include "AliTRDtrackerDebug.h"
+
 ClassImp(AliTRDtrackerDebug)
 
 Int_t AliTRDtrackerDebug::fgEventNumber = 0;
@@ -51,10 +51,10 @@ Int_t AliTRDtrackerDebug::fgCandidateNumber = 0;
 
 //____________________________________________________
 AliTRDtrackerDebug::AliTRDtrackerDebug() : AliTRDtrackerV1()
-  ,fOutputStreamer(0x0)
-  ,fTree(0x0)
-  ,fTracklet(0x0)
-  ,fTrack(0x0)
+  ,fOutputStreamer(NULL)
+  ,fTree(NULL)
+  ,fTracklet(NULL)
+  ,fTrack(NULL)
   ,fNClusters(0)
   ,fAlpha(0.)
 {
@@ -74,7 +74,7 @@ AliTRDtrackerDebug::~AliTRDtrackerDebug()
 
 
 //____________________________________________________
-void AliTRDtrackerDebug::Draw(Option_t *)
+void AliTRDtrackerDebug::Draw(Option_t *) 
 {
 // steer draw function
 }
@@ -119,7 +119,7 @@ Int_t AliTRDtrackerDebug::Process()
     //printf("Processing track %d [%d] ...\n", it, fNClusters);
     ResidualsTrackletsTrack();
 
-    const AliTRDseedV1 *tracklet = 0x0;
+    const AliTRDseedV1 *tracklet = NULL;
     for(int ip = 5; ip>=0; ip--){
       if(!(tracklet = fTrack->GetTracklet(ip))) continue;
       if(!tracklet->GetN()) continue;
@@ -139,7 +139,7 @@ void AliTRDtrackerDebug::ResidualsClustersTrack(const AliTRDseedV1 *tracklet)
 // Calculate averange distances from clusters to the TRD track 
   
   Double_t x[3]; 
-  AliTRDcluster *c = 0x0;
+  AliTRDcluster *c = NULL;
   for(int ic=0; ic<35/*AliTRDseed:knTimebins*/; ic++){
     if(!(c = tracklet->GetClusters(ic))) continue;
     Double_t xc = c->GetX(), yc = c->GetY(), zc = c->GetZ();
@@ -176,7 +176,7 @@ void AliTRDtrackerDebug::ResidualsClustersTracklet(const AliTRDseedV1 *tracklet)
           //z0 = tracklet->GetZfit(0), 
           //zs = tracklet->GetZfit(1);
   
-  AliTRDcluster *c = 0x0;
+  AliTRDcluster *c = NULL;
   for(int ic=0; ic<35/*AliTRDseed:knTimebins*/; ic++){
     if(!(c = tracklet->GetClusters(ic))) continue;
     Double_t xc = c->GetX(), yc = c->GetY()/*, zc = c->GetZ()*/;
@@ -200,7 +200,7 @@ void AliTRDtrackerDebug::ResidualsClustersParametrisation(const AliTRDseedV1 *tr
   
   // store cluster positions
   Double_t x0 = tracklet->GetX0();
-  AliTRDcluster *c = 0x0;
+  AliTRDcluster *c = NULL;
   
   Double_t x[2]; Int_t ncl, mcl, jc;
   TLinearFitter fitter(3, "hyp2");
@@ -242,8 +242,9 @@ void AliTRDtrackerDebug::ResidualsTrackletsTrack() const
 
   // build a working copy of the tracklets attached to the track 
   // and initialize working variables fX, fY and fZ
-  AliTRDseedV1 tracklet[6] = {0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
-  const AliTRDseedV1 *ctracklet = 0x0;
+  //AliTRDseedV1 tracklet[6] = {NULL, NULL, NULL, NULL, NULL, NULL};
+  AliTRDseedV1 tracklet[6];
+  const AliTRDseedV1 *ctracklet = NULL;
   for(int ip = 0; ip<6; ip++){
     if(!(ctracklet = fTrack->GetTracklet(ip))) continue;
     tracklet[ip] = (*ctracklet); 
@@ -267,7 +268,7 @@ void AliTRDtrackerDebug::ResidualsTrackletsTrack() const
     tracklet[ip].SetX0(x0);
 
     // fit Rieman with tilt correction
-    AliTRDtrackerV1::FitRiemanTilt(0x0, &tracklet[0], kTRUE);
+    AliTRDtrackerV1::FitRiemanTilt(NULL, &tracklet[0], kTRUE);
 
     // make a copy of the fit result
     Double_t 
@@ -340,7 +341,7 @@ void AliTRDtrackerDebug::AnalyseFindable(Char_t *treename){
   
   AliTRDseedV1 *tracklets[kNPlanes];
   for(Int_t iPlane = 0; iPlane < AliTRDtrackerV1::kNPlanes; iPlane++)
-    tracklets[iPlane] = 0x0;
+    tracklets[iPlane] = NULL;
   for(Int_t iPlane = 0; iPlane < kNPlanes; iPlane++)
     fTree->SetBranchAddress(Form("S%d.", iPlane), &tracklets[iPlane]);
   fTree->SetBranchAddress("EventNumber", &fgEventNumber);
@@ -385,7 +386,7 @@ void AliTRDtrackerDebug::AnalyseTiltedRiemanFit(){
   fTree = (TTree *)(debfile->Get("MakeSeeds2"));
   if(!fTree) return;
   Int_t nEntries = fTree->GetEntries();
-  TLinearFitter *tiltedRiemanFitter = 0x0;
+  TLinearFitter *tiltedRiemanFitter = NULL;
   fTree->SetBranchAddress("FitterT.", &tiltedRiemanFitter);
   fTree->SetBranchAddress("EventNumber", &fgEventNumber);
   fTree->SetBranchAddress("CandidateNumber", &fgCandidateNumber);
@@ -459,7 +460,7 @@ Float_t AliTRDtrackerDebug::GetDCA(Float_t a, Float_t b, Float_t c) const {
 //____________________________________________________
 void AliTRDtrackerDebug::AnalyseMinMax()
 {
-//
+  // Development function related to the old tracking code
   TFile *debfile = TFile::Open("TRD.TrackerDebug.root");
   if(!debfile){
     AliError("File TRD.TrackerDebug.root not found!");
@@ -470,8 +471,8 @@ void AliTRDtrackerDebug::AnalyseMinMax()
     AliError("Tree MakeSeeds0 not found in File TRD.TrackerDebug.root.");
     return;
   }
-  AliTRDseedV1 *cseed[4] = {0x0, 0x0, 0x0, 0x0};
-  AliTRDcluster *c[4] = {0x0, 0x0, 0x0, 0x0};
+  AliTRDseedV1 *cseed[4] = {NULL, NULL, NULL, NULL};
+  AliTRDcluster *c[4] = {NULL, NULL, NULL, NULL};
   for(Int_t il = 0; il < 4; il++){
     fTree->SetBranchAddress(Form("Seed%d.", il),       &cseed[il]);
     fTree->SetBranchAddress(Form("c%d.",il), &c[il]);
@@ -514,18 +515,18 @@ TCanvas* AliTRDtrackerDebug::PlotSeedingConfiguration(const Char_t *direction, I
   
   if((strcmp(direction, "y") != 0) && (strcmp(direction, "z") != 0)){
     AliError(Form("Direction %s does not exist. Abborting!", direction));
-    return 0x0;
+    return NULL;
   }
 
   TFile *debfile = TFile::Open("TRD.TrackerDebug.root");
   if(!debfile){
     AliError("File TRD.TrackerDebug.root not found!");
-    return 0x0; 
+    return NULL; 
   }
   fTree = (TTree *)(debfile->Get("MakeSeeds0"));
   if(!fTree){
     AliError("Tree MakeSeeds0 not found in File TRD.TrackerDebug.root.");
-    return 0x0;
+    return NULL;
   }
   
   TGraph *seedcl = new TGraph(4);
@@ -535,8 +536,8 @@ TCanvas* AliTRDtrackerDebug::PlotSeedingConfiguration(const Char_t *direction, I
   seedcl->SetMarkerColor(kRed);
   seedRef->SetMarkerStyle(2);
 
-  AliTRDcluster *c[4] = {0x0, 0x0, 0x0, 0x0};
-  AliRieman *rim = 0x0;
+  AliTRDcluster *c[4] = {NULL, NULL, NULL, NULL};
+  AliRieman *rim = NULL;
   Bool_t found = kFALSE;
   for(Int_t il = 0; il < 4; il++) fTree->SetBranchAddress(Form("c%d.",il), &c[il]);
   fTree->SetBranchAddress("EventNumber", &fgEventNumber);
@@ -595,7 +596,7 @@ TCanvas* AliTRDtrackerDebug::PlotSeedingConfiguration(const Char_t *direction, I
     delete seedcl;
     delete seedRef;
     delete riemanFit;
-    return 0x0;
+    return NULL;
   }
 }
 
@@ -617,15 +618,15 @@ TCanvas* AliTRDtrackerDebug::PlotFullTrackFit(Int_t event, Int_t candidate, Int_
   
   if(strcmp(direction, "y") && strcmp(direction, "z")){
     AliError(Form("Direction %s does not exist. Abborting!", direction));
-    return 0x0;
+    return NULL;
   }
 
   TFile *debfile = TFile::Open("TRD.TrackerDebug.root");
   if(!debfile){
     AliError("File TRD.TrackerDebug.root not found.");
-    return 0x0;
+    return NULL;
   }
-  TString *treename = 0x0;
+  TString *treename = NULL;
   if(iteration > -1)
     treename = new TString("ImproveSeedQuality");
   else
@@ -634,7 +635,7 @@ TCanvas* AliTRDtrackerDebug::PlotFullTrackFit(Int_t event, Int_t candidate, Int_
   if(!fTree){
     AliError(Form("Tree %s not found in File TRD.TrackerDebug.root.", treename->Data()));
     delete treename;
-    return 0x0;
+    return NULL;
   }
   delete treename;
 
@@ -646,8 +647,8 @@ TCanvas* AliTRDtrackerDebug::PlotFullTrackFit(Int_t event, Int_t candidate, Int_
       clp[AliTRDtrackerV1::kNPlanes * AliTRDtrackerV1::kNTimeBins];
   Int_t nLayers = 0, ncls = 0;
   
-  TLinearFitter *fitter = 0x0;
-  AliTRDseedV1 *tracklet[6] = {0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
+  TLinearFitter *fitter = NULL;
+  AliTRDseedV1 *tracklet[6] = {NULL, NULL, NULL, NULL, NULL, NULL};
   for(Int_t iLayer = 0; iLayer < 6; iLayer++)
     fTree->SetBranchAddress(Form("S%d.", iLayer), &tracklet[iLayer]);
   fTree->SetBranchAddress("FitterT.", &fitter);
@@ -774,7 +775,7 @@ TCanvas* AliTRDtrackerDebug::PlotFullTrackFit(Int_t event, Int_t candidate, Int_
   else{
     AliError(Form("Combination consisting of event %d and candidate %d not found", event, candidate));
     delete fitfun;
-    return 0x0;
+    return NULL;
   }
 }
 
index a17ff44..2278e2b 100644 (file)
@@ -17,9 +17,7 @@
 //                                                                        // 
 ////////////////////////////////////////////////////////////////////////////
 
-#ifndef ALITRDTRACKERV1_H
 #include "AliTRDtrackerV1.h"
-#endif
 
 class TTree;
 class TCanvas;
index b4ad87e..55cb7ca 100644 (file)
 //                                                                           //
 ///////////////////////////////////////////////////////////////////////////////
 
-// #include <Riostream.h>
-// #include <stdio.h>
-// #include <string.h>
-
 #include <TBranch.h>
 #include <TDirectory.h>
 #include <TLinearFitter.h>
 #include "AliTRDtrackingChamber.h"
 #include "AliTRDchamberTimeBin.h"
 
-
-
 ClassImp(AliTRDtrackerV1)
 
-
 const  Float_t  AliTRDtrackerV1::fgkMinClustersInTrack =  0.5;  //
 const  Float_t  AliTRDtrackerV1::fgkLabelFraction      =  0.8;  //
 const  Double_t AliTRDtrackerV1::fgkMaxChi2            = 12.0;  //
@@ -78,18 +71,18 @@ Double_t AliTRDtrackerV1::fgTopologicQA[kNConfigs] = {
 const Double_t AliTRDtrackerV1::fgkX0[kNPlanes]    = {
   300.2, 312.8, 325.4, 338.0, 350.6, 363.2};
 Int_t AliTRDtrackerV1::fgNTimeBins = 0;
-AliRieman* AliTRDtrackerV1::fgRieman = 0x0;
-TLinearFitter* AliTRDtrackerV1::fgTiltedRieman = 0x0;
-TLinearFitter* AliTRDtrackerV1::fgTiltedRiemanConstrained = 0x0;
+AliRieman* AliTRDtrackerV1::fgRieman = NULL;
+TLinearFitter* AliTRDtrackerV1::fgTiltedRieman = NULL;
+TLinearFitter* AliTRDtrackerV1::fgTiltedRiemanConstrained = NULL;
 
 //____________________________________________________________________
 AliTRDtrackerV1::AliTRDtrackerV1(AliTRDReconstructor *rec) 
   :AliTracker()
-  ,fReconstructor(0x0)
-  ,fGeom(0x0)
-  ,fClusters(0x0)
-  ,fTracklets(0x0)
-  ,fTracks(0x0)
+  ,fkReconstructor(NULL)
+  ,fGeom(NULL)
+  ,fClusters(NULL)
+  ,fTracklets(NULL)
+  ,fTracks(NULL)
   ,fSieveSeeding(0)
 {
   //
@@ -104,7 +97,7 @@ AliTRDtrackerV1::AliTRDtrackerV1(AliTRDReconstructor *rec)
   }
   fGeom = new AliTRDgeometry();
   fGeom->CreateClusterMatrixArray();
-  TGeoHMatrix *matrix = 0x0;
+  TGeoHMatrix *matrix = NULL;
   Double_t loc[] = {0., 0., 0.};
   Double_t glb[] = {0., 0., 0.};
   for(Int_t ily=kNPlanes; ily--;){
@@ -120,7 +113,7 @@ AliTRDtrackerV1::AliTRDtrackerV1(AliTRDReconstructor *rec)
   }
 
   // initialize calibration values
-  AliTRDcalibDB *trd = 0x0;
+  AliTRDcalibDB *trd = NULL;
   if (!(trd = AliTRDcalibDB::Instance())) {
     AliFatal("Could not get calibration.");
   }
@@ -142,9 +135,9 @@ AliTRDtrackerV1::~AliTRDtrackerV1()
   // Destructor
   //
   
-  if(fgRieman) delete fgRieman; fgRieman = 0x0;
-  if(fgTiltedRieman) delete fgTiltedRieman; fgTiltedRieman = 0x0;
-  if(fgTiltedRiemanConstrained) delete fgTiltedRiemanConstrained; fgTiltedRiemanConstrained = 0x0;
+  if(fgRieman) delete fgRieman; fgRieman = NULL;
+  if(fgTiltedRieman) delete fgTiltedRieman; fgTiltedRieman = NULL;
+  if(fgTiltedRiemanConstrained) delete fgTiltedRiemanConstrained; fgTiltedRiemanConstrained = NULL;
   for(Int_t isl =0; isl<kNSeedPlanes; isl++) if(fSeedTB[isl]) delete fSeedTB[isl];
   if(fTracks) {fTracks->Delete(); delete fTracks;}
   if(fTracklets) {fTracklets->Delete(); delete fTracklets;}
@@ -172,7 +165,7 @@ Int_t AliTRDtrackerV1::Clusters2Tracks(AliESDEvent *esd)
   //    See AliTRDtrackerV1::Clusters2TracksSM() for details.
   //
 
-  if(!fReconstructor->GetRecoParam() ){
+  if(!fkReconstructor->GetRecoParam() ){
     AliError("Reconstruction configuration not initialized. Call first AliTRDReconstructor::SetRecoParam().");
     return 0;
   }
@@ -286,8 +279,8 @@ Int_t AliTRDtrackerV1::PropagateBack(AliESDEvent *event)
         nTPCseeds= 0; // number of TPC seeds
   Float_t foundMin = 20.0;
   
-  Float_t *quality = 0x0;
-  Int_t   *index   = 0x0;
+  Float_t *quality = NULL;
+  Int_t   *index   = NULL;
   nSeeds   = event->GetNumberOfTracks();
   // Sort tracks according to quality 
   // (covariance in the yz plane)
@@ -338,7 +331,7 @@ Int_t AliTRDtrackerV1::PropagateBack(AliESDEvent *event)
     seed->UpdateTrackParams(&track, AliESDtrack::kTRDbackup);
 
     // prepare track and do propagation in the TRD
-    track.SetReconstructor(fReconstructor);
+    track.SetReconstructor(fkReconstructor);
     track.SetKink(Bool_t(seed->GetKinkIndex(0)));
     expectedClr = FollowBackProlongation(track);
     // check if track entered the TRD fiducial volume
@@ -359,7 +352,7 @@ Int_t AliTRDtrackerV1::PropagateBack(AliESDEvent *event)
       // update calibration references using this track
       if(calibra->GetHisto2d()) calibra->UpdateHistogramsV1(&track);
       // save calibration object
-      if (fReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 0){ 
+      if (fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 0){ 
         AliTRDtrackV1 *calibTrack = new AliTRDtrackV1(track);
         calibTrack->SetOwner();
         seed->AddCalibObject(calibTrack);
@@ -422,7 +415,7 @@ Int_t AliTRDtrackerV1::PropagateBack(AliESDEvent *event)
       //(with the help of Annalisa de Caro Mar-17-2009)
       if(gGeoManager){
         gGeoManager->cd(Form("/ALIC_1/B077_1/BSEGMO%d_1/BTOF%d_1", sm, sm));
-        TGeoHMatrix *m = 0x0;
+        TGeoHMatrix *m = NULL;
         Double_t loc[]={0., 0., -.5*29.05}, glob[3];
         
         if((m=gGeoManager->GetCurrentMatrix())){
@@ -455,7 +448,7 @@ Int_t AliTRDtrackerV1::PropagateBack(AliESDEvent *event)
   AliInfo(Form("Number of tracks: TRDout[%d]", nFound));
 
   // run stand alone tracking
-  if (fReconstructor->IsSeeding()) Clusters2Tracks(event);
+  if (fkReconstructor->IsSeeding()) Clusters2Tracks(event);
   
   return 0;
 }
@@ -507,9 +500,9 @@ Int_t AliTRDtrackerV1::RefitInward(AliESDEvent *event)
       }
 
       // Update the friend track
-      if (fReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 0){ 
-        TObject *o = 0x0; Int_t ic = 0;
-        AliTRDtrackV1 *calibTrack = 0x0; 
+      if (fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 0){ 
+        TObject *o = NULL; Int_t ic = 0;
+        AliTRDtrackV1 *calibTrack = NULL; 
         while((o = seed->GetCalibObject(ic++))){
           if(!(calibTrack = dynamic_cast<AliTRDtrackV1*>(o))) continue;
           calibTrack->SetTrackHigh(track.GetTrackHigh());
@@ -615,7 +608,7 @@ Int_t AliTRDtrackerV1::FollowProlongation(AliTRDtrackV1 &t)
     }
   }
 
-  if(fReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 1){
+  if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 1){
     Int_t index;
     for(int iplane=0; iplane<AliTRDgeometry::kNlayer; iplane++){
       AliTRDseedV1 *tracklet = GetTracklet(&t, iplane, index);
@@ -624,7 +617,7 @@ Int_t AliTRDtrackerV1::FollowProlongation(AliTRDtrackV1 &t)
     }
 
     Int_t eventNumber = AliTRDtrackerDebug::GetEventNumber();
-    TTreeSRedirector &cstreamer = *fReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
+    TTreeSRedirector &cstreamer = *fkReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
     AliTRDtrackV1 track(t);
     track.SetOwner();
     cstreamer << "FollowProlongation"
@@ -682,9 +675,9 @@ Int_t AliTRDtrackerV1::FollowBackProlongation(AliTRDtrackV1 &t)
 
   Int_t n = 0;
   Double_t driftLength = .5*AliTRDgeometry::AmThick() + AliTRDgeometry::DrThick();
-  AliTRDtrackingChamber *chamber = 0x0;
+  AliTRDtrackingChamber *chamber = NULL;
   
-  AliTRDseedV1 tracklet, *ptrTracklet = 0x0;
+  AliTRDseedV1 tracklet, *ptrTracklet = NULL;
   // in case of stand alone tracking we store all the pointers to the tracklets in a temporary array
   AliTRDseedV1 *tracklets[kNPlanes];
   memset(tracklets, 0, sizeof(AliTRDseedV1 *) * kNPlanes);
@@ -695,7 +688,7 @@ Int_t AliTRDtrackerV1::FollowBackProlongation(AliTRDtrackV1 &t)
   Bool_t kStoreIn = kTRUE, kPropagateIn = kTRUE;
 
   // Loop through the TRD layers
-  TGeoHMatrix *matrix = 0x0;
+  TGeoHMatrix *matrix = NULL;
   Double_t x, y, z;
   for (Int_t ily=0, sm=-1, stk=-1, det=-1; ily < AliTRDgeometry::kNlayer; ily++) {
     // rough estimate of the entry point
@@ -710,7 +703,7 @@ Int_t AliTRDtrackerV1::FollowBackProlongation(AliTRDtrackV1 &t)
     // TODO cross check with y value !
     stk = fGeom->GetStack(z, ily);
     det = stk>=0 ? AliTRDgeometry::GetDetector(ily, stk, sm) : -1;
-    matrix = det>=0 ? fGeom->GetClusterMatrix(det) : 0x0;
+    matrix = det>=0 ? fGeom->GetClusterMatrix(det) : NULL;
 
     // check if supermodule/chamber is installed
     if( !fGeom->GetSMstatus(sm) ||
@@ -759,16 +752,16 @@ Int_t AliTRDtrackerV1::FollowBackProlongation(AliTRDtrackV1 &t)
       t.SetStatus(AliTRDtrackV1::kSnp);
       break;
     }
-    Bool_t RECALCULATE = kFALSE;
+    Bool_t doRecalculate = kFALSE;
     if(sm != t.GetSector()){
       sm = t.GetSector(); 
-      RECALCULATE = kTRUE;
+      doRecalculate = kTRUE;
     }
     if(stk != fGeom->GetStack(z, ily)){
       stk = fGeom->GetStack(z, ily);
-      RECALCULATE = kTRUE;
+      doRecalculate = kTRUE;
     }
-    if(RECALCULATE){
+    if(doRecalculate){
       det = AliTRDgeometry::GetDetector(ily, stk, sm);
       if(!(matrix = fGeom->GetClusterMatrix(det))){ 
         t.SetStatus(AliTRDtrackV1::kGeometry, ily);
@@ -811,13 +804,13 @@ Int_t AliTRDtrackerV1::FollowBackProlongation(AliTRDtrackV1 &t)
         t.SetStatus(AliTRDtrackV1::kNoClusters, ily);
         continue;
       }
-      if(chamber->GetNClusters() < fgNTimeBins*fReconstructor->GetRecoParam() ->GetFindableClusters()){ 
+      if(chamber->GetNClusters() < fgNTimeBins*fkReconstructor->GetRecoParam() ->GetFindableClusters()){ 
         t.SetStatus(AliTRDtrackV1::kNoClusters, ily);
         continue;
       }      
       // build tracklet
       ptrTracklet = new(&tracklet) AliTRDseedV1(det);
-      ptrTracklet->SetReconstructor(fReconstructor);
+      ptrTracklet->SetReconstructor(fkReconstructor);
       ptrTracklet->SetKink(t.IsKink());
       ptrTracklet->SetPadPlane(fGeom->GetPadPlane(ily, stk));
       ptrTracklet->SetX0(glb[0]+driftLength);
@@ -830,7 +823,7 @@ Int_t AliTRDtrackerV1::FollowBackProlongation(AliTRDtrackV1 &t)
         t.SetStatus(AliTRDtrackV1::kNoAttach, ily);
         continue;
       }
-      if(tracklet.GetN() < fgNTimeBins*fReconstructor->GetRecoParam() ->GetFindableClusters()){
+      if(tracklet.GetN() < fgNTimeBins*fkReconstructor->GetRecoParam() ->GetFindableClusters()){
         t.SetStatus(AliTRDtrackV1::kNoClustersTracklet, ily);
         continue;
       }
@@ -866,7 +859,7 @@ Int_t AliTRDtrackerV1::FollowBackProlongation(AliTRDtrackV1 &t)
     Double_t cov[3]; ptrTracklet->GetCovAt(x, cov);
     Double_t p[2] = { ptrTracklet->GetY(), ptrTracklet->GetZ()};
     Double_t chi2 = ((AliExternalTrackParam)t).GetPredictedChi2(p, cov);
-    if(fReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 2){
+    if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 2){
       Double_t ytrack = ptrTracklet->GetYref(0);
       Double_t ztrack = ptrTracklet->GetZref(0);
       Double_t ytracklet = ptrTracklet->GetYfit(0);
@@ -876,7 +869,7 @@ Int_t AliTRDtrackerV1::FollowBackProlongation(AliTRDtrackV1 &t)
       Double_t thetatrack = ptrTracklet->GetZref(1);
       Double_t thetatracklet = ptrTracklet->GetZfit(1);
    
-      TTreeSRedirector &mystreamer = *fReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
+      TTreeSRedirector &mystreamer = *fkReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
       mystreamer << "FollowBackProlongation1"
         << "il="              << ily
         << "x="               << x
@@ -933,8 +926,8 @@ Int_t AliTRDtrackerV1::FollowBackProlongation(AliTRDtrackV1 &t)
   //printf("clusters[%d] chi2[%f] x[%f] status[%d ", n, t.GetChi2(), t.GetX(), t.GetStatusTRD());
   //for(int i=0; i<6; i++) printf("%d ", t.GetStatusTRD(i)); printf("]\n");
 
-  if(fReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 1){
-    TTreeSRedirector &cstreamer = *fReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
+  if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 1){
+    TTreeSRedirector &cstreamer = *fkReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
     Int_t eventNumber = AliTRDtrackerDebug::GetEventNumber();
     AliTRDtrackV1 track(t);
     track.SetOwner();
@@ -949,7 +942,7 @@ Int_t AliTRDtrackerV1::FollowBackProlongation(AliTRDtrackV1 &t)
 }
 
 //_________________________________________________________________________
-Float_t AliTRDtrackerV1::FitRieman(AliTRDseedV1 *tracklets, Double_t *chi2, Int_t *planes){
+Float_t AliTRDtrackerV1::FitRieman(AliTRDseedV1 *tracklets, Double_t *chi2, Int_t *const planes){
   //
   // Fits a Riemann-circle to the given points without tilting pad correction.
   // The fit is performed using an instance of the class AliRieman (equations 
@@ -1053,7 +1046,7 @@ Float_t AliTRDtrackerV1::FitTiltedRiemanConstraint(AliTRDseedV1 *tracklets, Doub
   TLinearFitter *fitter = GetTiltedRiemanFitterConstraint();
   fitter->StoreData(kTRUE);
   fitter->ClearPoints();
-  AliTRDcluster *cl = 0x0;
+  AliTRDcluster *cl = NULL;
   
   Float_t x, y, z, w, t, error, tilt;
   Double_t uvt[2];
@@ -1089,7 +1082,7 @@ Float_t AliTRDtrackerV1::FitTiltedRiemanConstraint(AliTRDseedV1 *tracklets, Doub
   for(Int_t ip = 0; ip < AliTRDtrackerV1::kNPlanes; ip++)
     tracklets[ip].SetC(curvature);
 
-/*  if(fReconstructor->GetStreamLevel() >= 5){
+/*  if(fkReconstructor->GetStreamLevel() >= 5){
     //Linear Model on z-direction
     Double_t xref = CalculateReferenceX(tracklets);            // Relative to the middle of the stack
     Double_t slope = fitter->GetParameter(2);
@@ -1097,7 +1090,7 @@ Float_t AliTRDtrackerV1::FitTiltedRiemanConstraint(AliTRDseedV1 *tracklets, Doub
     Float_t chi2Z = CalculateChi2Z(tracklets, zref, slope, xref);
     Int_t eventNumber = AliTRDtrackerDebug::GetEventNumber();
     Int_t candidateNumber = AliTRDtrackerDebug::GetCandidateNumber();
-    TTreeSRedirector &treeStreamer = *fReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
+    TTreeSRedirector &treeStreamer = *fkReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
     treeStreamer << "FitTiltedRiemanConstraint"
     << "EventNumber="          << eventNumber
     << "CandidateNumber="      << candidateNumber
@@ -1146,7 +1139,7 @@ Float_t AliTRDtrackerV1::FitTiltedRieman(AliTRDseedV1 *tracklets, Bool_t sigErro
   fitter->StoreData(kTRUE);
   fitter->ClearPoints();
   AliTRDLeastSquare zfitter;
-  AliTRDcluster *cl = 0x0;
+  AliTRDcluster *cl = NULL;
 
   Double_t xref = CalculateReferenceX(tracklets);
   Double_t x, y, z, t, tilt, dx, w, we, erry, errz;
@@ -1309,8 +1302,8 @@ Float_t AliTRDtrackerV1::FitTiltedRieman(AliTRDseedV1 *tracklets, Bool_t sigErro
     tracklets[iLayer].SetChi2(chi2track);
   }
   
-/*  if(fReconstructor->GetStreamLevel() >=5){
-    TTreeSRedirector &cstreamer = *fReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
+/*  if(fkReconstructor->GetStreamLevel() >=5){
+    TTreeSRedirector &cstreamer = *fkReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
     Int_t eventNumber                  = AliTRDtrackerDebug::GetEventNumber();
     Int_t candidateNumber      = AliTRDtrackerDebug::GetCandidateNumber();
     Double_t chi2z = CalculateChi2Z(tracklets, offset, slope, xref);
@@ -1328,10 +1321,15 @@ Float_t AliTRDtrackerV1::FitTiltedRieman(AliTRDseedV1 *tracklets, Bool_t sigErro
 //____________________________________________________________________
 Double_t AliTRDtrackerV1::FitLine(const AliTRDtrackV1 *track, AliTRDseedV1 *tracklets, Bool_t err, Int_t np, AliTrackPoint *points)
 {
+  //
+  // Fit track with a staight line
+  // Fills an AliTrackPoint array with np points
+  // Function should be used to refit tracks when no magnetic field was on
+  //
   AliTRDLeastSquare yfitter, zfitter;
-  AliTRDcluster *cl = 0x0;
+  AliTRDcluster *cl = NULL;
 
-  AliTRDseedV1 work[kNPlanes], *tracklet = 0x0;
+  AliTRDseedV1 work[kNPlanes], *tracklet = NULL;
   if(!tracklets){
     for(Int_t ipl = 0; ipl < kNPlanes; ipl++){
       if(!(tracklet = track->GetTracklet(ipl))) continue;
@@ -1450,9 +1448,9 @@ Double_t AliTRDtrackerV1::FitRiemanTilt(const AliTRDtrackV1 *track, AliTRDseedV1
   fitter->StoreData(kTRUE);
   fitter->ClearPoints();
   AliTRDLeastSquare zfitter;
-  AliTRDcluster *cl = 0x0;
+  AliTRDcluster *cl = NULL;
 
-  AliTRDseedV1 work[kNPlanes], *tracklet = 0x0;
+  AliTRDseedV1 work[kNPlanes], *tracklet = NULL;
   if(!tracklets){
     for(Int_t ipl = 0; ipl < kNPlanes; ipl++){
       if(!(tracklet = track->GetTracklet(ipl))) continue;
@@ -1529,9 +1527,9 @@ Double_t AliTRDtrackerV1::FitRiemanTilt(const AliTRDtrackV1 *track, AliTRDseedV1
   Double_t x0   = -b * y0;
   Double_t tmp  = y0*y0 + x0*x0 - c*y0;
   if(tmp<=0.) return 1.E10;
-  Double_t R    = TMath::Sqrt(tmp);
-  Double_t C    =  1.0 + b*b - c*a;
-  if (C > 0.0) C  =  a / TMath::Sqrt(C);
+  Double_t radius    = TMath::Sqrt(tmp);
+  Double_t curvature    =  1.0 + b*b - c*a;
+  if (curvature > 0.0)  curvature  =  a / TMath::Sqrt(curvature);
 
   // Calculate chi2 of the fit 
   Double_t chi2 = fitter->GetChisquare()/Double_t(nPoints);
@@ -1540,7 +1538,7 @@ Double_t AliTRDtrackerV1::FitRiemanTilt(const AliTRDtrackV1 *track, AliTRDseedV1
   if(!track){
     for(Int_t ip = 0; ip < kNPlanes; ip++) {
       x = tracklets[ip].GetX0();
-      tmp = R*R-(x-x0)*(x-x0);  
+      tmp = radius*radius-(x-x0)*(x-x0);  
       if(tmp <= 0.) continue;
       tmp = TMath::Sqrt(tmp);  
 
@@ -1551,7 +1549,7 @@ Double_t AliTRDtrackerV1::FitRiemanTilt(const AliTRDtrackV1 *track, AliTRDseedV1
       tracklets[ip].SetYref(1, (x - x0) / tmp);
       tracklets[ip].SetZref(0, z0 + dzdx * (x - xref));
       tracklets[ip].SetZref(1, dzdx);
-      tracklets[ip].SetC(C);
+      tracklets[ip].SetC(curvature);
       tracklets[ip].SetChi2(chi2);
     }
   }
@@ -1560,7 +1558,7 @@ Double_t AliTRDtrackerV1::FitRiemanTilt(const AliTRDtrackV1 *track, AliTRDseedV1
     Float_t xyz[3];
     for(int ip=0; ip<np; ip++){
       points[ip].GetXYZ(xyz);
-      xyz[1] = TMath::Abs(xyz[0] - x0) > R ? 100. : y0 - (y0>0.?1.:-1.)*TMath::Sqrt((R-(xyz[0]-x0))*(R+(xyz[0]-x0)));
+      xyz[1] = TMath::Abs(xyz[0] - x0) > radius ? 100. : y0 - (y0>0.?1.:-1.)*TMath::Sqrt((radius-(xyz[0]-x0))*(radius+(xyz[0]-x0)));
       xyz[2] = z0 + dzdx * (xyz[0] - xref);
       points[ip].SetXYZ(xyz);
     }
@@ -1571,7 +1569,7 @@ Double_t AliTRDtrackerV1::FitRiemanTilt(const AliTRDtrackV1 *track, AliTRDseedV1
 
 
 //____________________________________________________________________
-Double_t AliTRDtrackerV1::FitKalman(AliTRDtrackV1 *track, AliTRDseedV1 *tracklets, Bool_t up, Int_t np, AliTrackPoint *points)
+Double_t AliTRDtrackerV1::FitKalman(AliTRDtrackV1 *track, const AliTRDseedV1 * const tracklets, Bool_t up, Int_t np, AliTrackPoint *points)
 {
 //   Kalman filter implementation for the TRD.
 //   It returns the positions of the fit in the array "points"
@@ -1590,17 +1588,17 @@ Double_t AliTRDtrackerV1::FitKalman(AliTRDtrackV1 *track, AliTRDseedV1 *tracklet
   //if(points) printf("First marker point @ x[%d] = %f\n", ip, points[ip].GetX());
 
 
-  AliTRDseedV1 tracklet, *ptrTracklet = 0x0;
+  AliTRDseedV1 tracklet, *ptrTracklet = NULL;
 
   //Loop through the TRD planes
   for (Int_t jplane = 0; jplane < kNPlanes; jplane++) {
     // GET TRACKLET OR BUILT IT                
     Int_t iplane = up ? jplane : kNPlanes - 1 - jplane;
     if(tracklets){ 
-      if(!(ptrTracklet = &tracklets[iplane])) continue;
+      if(!(ptrTracklet = const_cast<AliTRDseedV1 *>(&tracklets[iplane]))) continue;
     }else{
       if(!(ptrTracklet  = track->GetTracklet(iplane))){ 
-      /*AliTRDtrackerV1 *tracker = 0x0;
+      /*AliTRDtrackerV1 *tracker = NULL;
         if(!(tracker = dynamic_cast<AliTRDtrackerV1*>( AliTRDReconstructor::Tracker()))) continue;
         ptrTracklet = new(&tracklet) AliTRDseedV1(iplane);
         if(!tracker->MakeTracklet(ptrTracklet, track)) */
@@ -1796,8 +1794,8 @@ Int_t AliTRDtrackerV1::ReadClusters(TClonesArray* &array, TTree *clusterTree) co
   branch->SetAddress(&clusterArray); 
   
   if(!fClusters){ 
-    Float_t nclusters =  fReconstructor->GetRecoParam()->GetNClusters();
-    if(fReconstructor->IsHLT()) nclusters /= AliTRDgeometry::kNsector;
+    Float_t nclusters =  fkReconstructor->GetRecoParam()->GetNClusters();
+    if(fkReconstructor->IsHLT()) nclusters /= AliTRDgeometry::kNsector;
     array = new TClonesArray("AliTRDcluster", Int_t(nclusters));
     array->SetOwner(kTRUE);
   }
@@ -1806,7 +1804,7 @@ Int_t AliTRDtrackerV1::ReadClusters(TClonesArray* &array, TTree *clusterTree) co
   Int_t nEntries   = (Int_t) clusterTree->GetEntries();
   Int_t nbytes     = 0;
   Int_t ncl        = 0;
-  AliTRDcluster *c = 0x0;
+  AliTRDcluster *c = NULL;
   for (Int_t iEntry = 0; iEntry < nEntries; iEntry++) {
     // Import the tree
     nbytes += clusterTree->GetEvent(iEntry);  
@@ -1832,7 +1830,7 @@ Int_t AliTRDtrackerV1::LoadClusters(TTree *cTree)
   // Fills clusters into TRD tracking sectors
   //
   
-  if(!fReconstructor->IsWritingClusters()){ 
+  if(!fkReconstructor->IsWritingClusters()){ 
     fClusters = AliTRDReconstructor::GetClusters();
   } else {
     if (ReadClusters(fClusters, cTree)) {
@@ -1857,7 +1855,7 @@ Int_t AliTRDtrackerV1::LoadClusters(TTree *cTree)
 }
 
 //_____________________________________________________________________________
-Int_t AliTRDtrackerV1::LoadClusters(TClonesArray *clusters)
+Int_t AliTRDtrackerV1::LoadClusters(TClonesArray * const clusters)
 {
   //
   // Fills clusters into TRD tracking sectors
@@ -1901,7 +1899,7 @@ Int_t AliTRDtrackerV1::BuildTrackingContainers()
   const AliTRDCalDet *cal = AliTRDcalibDB::Instance()->GetT0Det();
   for(int isector =0; isector<AliTRDgeometry::kNsector; isector++){ 
     if(!fTrSec[isector].GetNChambers()) continue;
-    fTrSec[isector].Init(fReconstructor, cal);
+    fTrSec[isector].Init(fkReconstructor, cal);
   }
 
   return nin;
@@ -1919,20 +1917,20 @@ void AliTRDtrackerV1::UnloadClusters()
 
   if(fTracks){ 
     fTracks->Delete(); 
-    if(HasRemoveContainers()){delete fTracks; fTracks = 0x0;}
+    if(HasRemoveContainers()){delete fTracks; fTracks = NULL;}
   }
   if(fTracklets){ 
     fTracklets->Delete();
-    if(HasRemoveContainers()){delete fTracklets; fTracklets = 0x0;}
+    if(HasRemoveContainers()){delete fTracklets; fTracklets = NULL;}
   }
   if(fClusters){ 
     if(IsClustersOwner()) fClusters->Delete();
     
     // save clusters array in the reconstructor for further use.
-    if(!fReconstructor->IsWritingClusters()){
+    if(!fkReconstructor->IsWritingClusters()){
       AliTRDReconstructor::SetClusters(fClusters);
       SetClustersOwner(kFALSE);
-    } else AliTRDReconstructor::SetClusters(0x0);
+    } else AliTRDReconstructor::SetClusters(NULL);
   }
 
   for (int i = 0; i < AliTRDgeometry::kNsector; i++) fTrSec[i].Clear();
@@ -1947,10 +1945,10 @@ void AliTRDtrackerV1::UnloadClusters()
 //   const AliTRDtrackV1 *track = dynamic_cast<const AliTRDtrackV1*>(t);
 //   if(!track) return;
 // 
-//   AliTRDseedV1 *tracklet = 0x0;
+//   AliTRDseedV1 *tracklet = NULL;
 //   for(Int_t ily=AliTRDgeometry::kNlayer; ily--;){
 //     if(!(tracklet = track->GetTracklet(ily))) continue;
-//     AliTRDcluster *c = 0x0;
+//     AliTRDcluster *c = NULL;
 //     for(Int_t ic=AliTRDseed::kNclusters; ic--;){
 //       if(!(c=tracklet->GetClusters(ic))) continue;
 //       c->Use();
@@ -1960,7 +1958,7 @@ void AliTRDtrackerV1::UnloadClusters()
 // 
 
 //_____________________________________________________________________________
-Bool_t AliTRDtrackerV1::AdjustSector(AliTRDtrackV1 *track) 
+Bool_t AliTRDtrackerV1::AdjustSector(AliTRDtrackV1 *const track) 
 {
   //
   // Rotates the track when necessary
@@ -1987,7 +1985,7 @@ Bool_t AliTRDtrackerV1::AdjustSector(AliTRDtrackV1 *track)
 
 
 //____________________________________________________________________
-AliTRDseedV1* AliTRDtrackerV1::GetTracklet(AliTRDtrackV1 *track, Int_t p, Int_t &idx)
+AliTRDseedV1* AliTRDtrackerV1::GetTracklet(AliTRDtrackV1 *const track, Int_t p, Int_t &idx)
 {
   // Find tracklet for TRD track <track>
   // Parameters
@@ -2001,13 +1999,13 @@ AliTRDseedV1* AliTRDtrackerV1::GetTracklet(AliTRDtrackV1 *track, Int_t p, Int_t
   // Detailed description
   //
   idx = track->GetTrackletIndex(p);
-  AliTRDseedV1 *tracklet = (idx==0xffff) ? 0x0 : (AliTRDseedV1*)fTracklets->UncheckedAt(idx);
+  AliTRDseedV1 *tracklet = (idx==0xffff) ? NULL : (AliTRDseedV1*)fTracklets->UncheckedAt(idx);
 
   return tracklet;
 }
 
 //____________________________________________________________________
-AliTRDseedV1* AliTRDtrackerV1::SetTracklet(AliTRDseedV1 *tracklet)
+AliTRDseedV1* AliTRDtrackerV1::SetTracklet(const AliTRDseedV1 * const tracklet)
 {
   // Add this tracklet to the list of tracklets stored in the tracker
   //
@@ -2030,7 +2028,7 @@ AliTRDseedV1* AliTRDtrackerV1::SetTracklet(AliTRDseedV1 *tracklet)
 }
 
 //____________________________________________________________________
-AliTRDtrackV1* AliTRDtrackerV1::SetTrack(AliTRDtrackV1 *track)
+AliTRDtrackV1* AliTRDtrackerV1::SetTrack(const AliTRDtrackV1 * const track)
 {
   // Add this track to the list of tracks stored in the tracker
   //
@@ -2082,13 +2080,13 @@ Int_t AliTRDtrackerV1::Clusters2TracksSM(Int_t sector, AliESDEvent *esd)
   
   Int_t nTracks   = 0;
   Int_t nChambers = 0;
-  AliTRDtrackingChamber **stack = 0x0, *chamber = 0x0;
+  AliTRDtrackingChamber **stack = NULL, *chamber = NULL;
   for(int istack = 0; istack<AliTRDgeometry::kNstack; istack++){
     if(!(stack = fTrSec[sector].GetStack(istack))) continue;
     nChambers = 0;
     for(int ilayer=0; ilayer<AliTRDgeometry::kNlayer; ilayer++){
       if(!(chamber = stack[ilayer])) continue;
-      if(chamber->GetNClusters() < fgNTimeBins * fReconstructor->GetRecoParam() ->GetFindableClusters()) continue;
+      if(chamber->GetNClusters() < fgNTimeBins * fkReconstructor->GetRecoParam() ->GetFindableClusters()) continue;
       nChambers++;
       //AliInfo(Form("sector %d stack %d layer %d clusters %d", sector, istack, ilayer, chamber->GetNClusters()));
     }
@@ -2108,7 +2106,7 @@ Int_t AliTRDtrackerV1::Clusters2TracksSM(Int_t sector, AliESDEvent *esd)
 }
 
 //____________________________________________________________________
-Int_t AliTRDtrackerV1::Clusters2TracksStack(AliTRDtrackingChamber **stack, TClonesArray *esdTrackList)
+Int_t AliTRDtrackerV1::Clusters2TracksStack(AliTRDtrackingChamber **stack, TClonesArray * const esdTrackList)
 {
   //
   // Make tracks in one TRD stack.
@@ -2137,8 +2135,8 @@ Int_t AliTRDtrackerV1::Clusters2TracksStack(AliTRDtrackingChamber **stack, TClon
   //
 
   const AliTRDCalDet *cal = AliTRDcalibDB::Instance()->GetT0Det();
-  AliTRDtrackingChamber *chamber = 0x0;
-  AliTRDtrackingChamber **ci = 0x0;
+  AliTRDtrackingChamber *chamber = NULL;
+  AliTRDtrackingChamber **ci = NULL;
   AliTRDseedV1 sseed[kMaxTracksStack*6]; // to be initialized
   Int_t pars[4]; // MakeSeeds parameters
 
@@ -2155,7 +2153,7 @@ Int_t AliTRDtrackerV1::Clusters2TracksStack(AliTRDtrackingChamber **stack, TClon
 
   // Build initial seeding configurations
   Double_t quality = BuildSeedingConfigs(stack, configs);
-  if(fReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 10){
+  if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 10){
     AliInfo(Form("Plane config %d %d %d Quality %f"
     , configs[0], configs[1], configs[2], quality));
   }
@@ -2184,7 +2182,7 @@ Int_t AliTRDtrackerV1::Clusters2TracksStack(AliTRDtrackingChamber **stack, TClon
       //AliInfo(Form("Number of Tracks after iteration step %d: %d\n", iconf, ntracks));
       if(ntracks == kMaxTracksStack) break;
     }
-    if(fReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 1) AliInfo(Form("Candidate TRD tracks %d in iteration %d.", ntracks, fSieveSeeding));
+    if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 1) AliInfo(Form("Candidate TRD tracks %d in iteration %d.", ntracks, fSieveSeeding));
     
     if(!ntracks) break;
     
@@ -2204,7 +2202,7 @@ Int_t AliTRDtrackerV1::Clusters2TracksStack(AliTRDtrackingChamber **stack, TClon
     
     // Sieve clusters in decreasing order of track quality
     Double_t trackParams[7];
-    //                 AliTRDseedV1 *lseed = 0x0;
+    //                 AliTRDseedV1 *lseed = NULL;
     Int_t jSieve = 0, candidates;
     do{
       //AliInfo(Form("\t\tITER = %i ", jSieve));
@@ -2295,7 +2293,7 @@ Int_t AliTRDtrackerV1::Clusters2TracksStack(AliTRDtrackingChamber **stack, TClon
         Int_t ich = 0; while(!(chamber = stack[ich])) ich++;
         trackParams[6] = fGeom->GetSector(chamber->GetDetector());/* *alpha+shift;     // Supermodule*/
 
-        if(fReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 1){
+        if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 1){
           //AliInfo(Form("Track %d [%d] nlayers %d trackQuality = %e nused %d, yref = %3.3f", itrack, trackIndex, nlayers, fTrackQuality[trackIndex], nused, trackParams[1]));
 
           AliTRDseedV1 *dseed[6];
@@ -2305,7 +2303,7 @@ Int_t AliTRDtrackerV1::Clusters2TracksStack(AliTRDtrackingChamber **stack, TClon
           Int_t eventNumber = AliTRDtrackerDebug::GetEventNumber();
           Int_t trackNumber = AliTRDtrackerDebug::GetTrackNumber();
           Int_t candidateNumber = AliTRDtrackerDebug::GetCandidateNumber();
-          TTreeSRedirector &cstreamer = *fReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
+          TTreeSRedirector &cstreamer = *fkReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
           cstreamer << "Clusters2TracksStack"
               << "EventNumber="                << eventNumber
               << "TrackNumber="                << trackNumber
@@ -2344,7 +2342,7 @@ Int_t AliTRDtrackerV1::Clusters2TracksStack(AliTRDtrackingChamber **stack, TClon
         esdTrack->SetLabel(track->GetLabel());
         track->UpdateESDtrack(esdTrack);
         // write ESD-friends if neccessary
-        if (fReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 0){
+        if (fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 0){
           AliTRDtrackV1 *calibTrack = new AliTRDtrackV1(*track);
           calibTrack->SetOwner();
           esdTrack->AddCalibObject(calibTrack);
@@ -2360,19 +2358,19 @@ Int_t AliTRDtrackerV1::Clusters2TracksStack(AliTRDtrackingChamber **stack, TClon
     // increment counters
     ntracks2 += ntracks1;
 
-    if(fReconstructor->IsHLT()) break;
+    if(fkReconstructor->IsHLT()) break;
     fSieveSeeding++;
 
     // Rebuild plane configurations and indices taking only unused clusters into account
     quality = BuildSeedingConfigs(stack, configs);
-    if(quality < 1.E-7) break; //fReconstructor->GetRecoParam() ->GetPlaneQualityThreshold()) break;
+    if(quality < 1.E-7) break; //fkReconstructor->GetRecoParam() ->GetPlaneQualityThreshold()) break;
     
     for(Int_t ip = 0; ip < kNPlanes; ip++){ 
       if(!(chamber = stack[ip])) continue;
       chamber->Build(fGeom, cal);//Indices(fSieveSeeding);
     }
 
-    if(fReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 10){ 
+    if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 10){ 
       AliInfo(Form("Sieve level %d Plane config %d %d %d Quality %f", fSieveSeeding, configs[0], configs[1], configs[2], quality));
     }
   } while(fSieveSeeding<10); // end stack clusters sieve
@@ -2412,7 +2410,7 @@ Double_t AliTRDtrackerV1::BuildSeedingConfigs(AliTRDtrackingChamber **stack, Int
   // 
 
   Double_t chamberQ[kNPlanes];memset(chamberQ, 0, kNPlanes*sizeof(Double_t));
-  AliTRDtrackingChamber *chamber = 0x0;
+  AliTRDtrackingChamber *chamber = NULL;
   for(int iplane=0; iplane<kNPlanes; iplane++){
     if(!(chamber = stack[iplane])) continue;
     chamberQ[iplane] = (chamber = stack[iplane]) ?  chamber->GetQuality() : 0.;
@@ -2435,7 +2433,7 @@ Double_t AliTRDtrackerV1::BuildSeedingConfigs(AliTRDtrackingChamber **stack, Int
 }
 
 //____________________________________________________________________
-Int_t AliTRDtrackerV1::MakeSeeds(AliTRDtrackingChamber **stack, AliTRDseedV1 *sseed, Int_t *ipar)
+Int_t AliTRDtrackerV1::MakeSeeds(AliTRDtrackingChamber **stack, const AliTRDseedV1 * const sseed, const Int_t * const ipar)
 {
 //
 // Seed tracklets and build candidate TRD tracks. The procedure is used during barrel tracking to account for tracks which are 
@@ -2497,9 +2495,9 @@ Int_t AliTRDtrackerV1::MakeSeeds(AliTRDtrackingChamber **stack, AliTRDseedV1 *ss
 //   Alexandru Bercuci <A.Bercuci@gsi.de>
 //   Markus Fasel <M.Fasel@gsi.de>
 
-  AliTRDtrackingChamber *chamber = 0x0;
-  AliTRDcluster *c[kNSeedPlanes] = {0x0, 0x0, 0x0, 0x0}; // initilize seeding clusters
-  AliTRDseedV1 *cseed = &sseed[0]; // initialize tracklets for first track
+  AliTRDtrackingChamber *chamber = NULL;
+  AliTRDcluster *c[kNSeedPlanes] = {NULL, NULL, NULL, NULL}; // initilize seeding clusters
+  AliTRDseedV1 *cseed = const_cast<AliTRDseedV1 *>(&sseed[0]); // initialize tracklets for first track
   Int_t ncl, mcl; // working variable for looping over clusters
   Int_t index[AliTRDchamberTimeBin::kMaxClustersLayer], jndex[AliTRDchamberTimeBin::kMaxClustersLayer];
   // chi2 storage
@@ -2522,7 +2520,7 @@ Int_t AliTRDtrackerV1::MakeSeeds(AliTRDtrackingChamber **stack, AliTRDseedV1 *ss
   Double_t hL[kNPlanes];       // Tilting angle
   Float_t padlength[kNPlanes]; // pad lenghts
   Float_t padwidth[kNPlanes];  // pad widths
-  AliTRDpadPlane *pp = 0x0;
+  AliTRDpadPlane *pp = NULL;
   for(int iplane=0; iplane<kNPlanes; iplane++){
     pp                = fGeom->GetPadPlane(iplane, istack);
     hL[iplane]        = TMath::Tan(TMath::DegToRad()*pp->GetTiltingAngle());
@@ -2533,7 +2531,7 @@ Int_t AliTRDtrackerV1::MakeSeeds(AliTRDtrackingChamber **stack, AliTRDseedV1 *ss
   // Init anode wire position for chambers
   Double_t x0[kNPlanes],       // anode wire position
            driftLength = .5*AliTRDgeometry::AmThick() - AliTRDgeometry::DrThick(); // drift length
-  TGeoHMatrix *matrix = 0x0;
+  TGeoHMatrix *matrix = NULL;
   Double_t loc[] = {AliTRDgeometry::AnodePos(), 0., 0.};
   Double_t glb[] = {0., 0., 0.};
   AliTRDtrackingChamber **cIter = &stack[0];
@@ -2547,7 +2545,7 @@ Int_t AliTRDtrackerV1::MakeSeeds(AliTRDtrackingChamber **stack, AliTRDseedV1 *ss
     x0[iLayer] = glb[0];
   }
 
-  if(fReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 2){
+  if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 2){
     AliInfo(Form("Making seeds Stack[%d] Config[%d] Tracks[%d]...", istack, config, ntracks));
   }
 
@@ -2556,7 +2554,7 @@ Int_t AliTRDtrackerV1::MakeSeeds(AliTRDtrackingChamber **stack, AliTRDseedV1 *ss
   Int_t nlayers = 0;
   for(int isl=0; isl<kNSeedPlanes; isl++){ 
     if(!(chamber = stack[planes[isl]])) continue;
-    if(!chamber->GetSeedingLayer(fSeedTB[isl], fGeom, fReconstructor)) continue;
+    if(!chamber->GetSeedingLayer(fSeedTB[isl], fGeom, fkReconstructor)) continue;
     nlayers++;
   }
   if(nlayers < kNSeedPlanes) return ntracks;
@@ -2605,14 +2603,14 @@ Int_t AliTRDtrackerV1::MakeSeeds(AliTRDtrackingChamber **stack, AliTRDseedV1 *ss
           tseed->SetTilt(hL[iLayer]);
           tseed->SetPadLength(padlength[iLayer]);
           tseed->SetPadWidth(padwidth[iLayer]);
-          tseed->SetReconstructor(fReconstructor);
+          tseed->SetReconstructor(fkReconstructor);
           tseed->SetX0(det<0 ? fR[iLayer]+driftLength : x0[iLayer]);
           tseed->Init(GetRiemanFitter());
           tseed->SetStandAlone(kTRUE);
         }
       
         Bool_t isFake = kFALSE;
-        if(fReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) >= 2){
+        if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) >= 2){
           if (c[0]->GetLabel(0) != c[3]->GetLabel(0)) isFake = kTRUE;
           if (c[1]->GetLabel(0) != c[3]->GetLabel(0)) isFake = kTRUE;
           if (c[2]->GetLabel(0) != c[3]->GetLabel(0)) isFake = kTRUE;
@@ -2625,7 +2623,7 @@ Int_t AliTRDtrackerV1::MakeSeeds(AliTRDtrackingChamber **stack, AliTRDseedV1 *ss
           Int_t eventNumber = AliTRDtrackerDebug::GetEventNumber();
           Int_t candidateNumber = AliTRDtrackerDebug::GetCandidateNumber();
           AliRieman *rim = GetRiemanFitter();
-          TTreeSRedirector &cs0 = *fReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
+          TTreeSRedirector &cs0 = *fkReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
           cs0 << "MakeSeeds0"
               <<"EventNumber="         << eventNumber
               <<"CandidateNumber="     << candidateNumber
@@ -2655,12 +2653,12 @@ Int_t AliTRDtrackerV1::MakeSeeds(AliTRDtrackingChamber **stack, AliTRDseedV1 *ss
               <<"RiemanFitter.="               << rim
               <<"\n";
         }
-        if(chi2[0] > fReconstructor->GetRecoParam() ->GetChi2Z()/*7./(3. - sLayer)*//*iter*/){
+        if(chi2[0] > fkReconstructor->GetRecoParam() ->GetChi2Z()/*7./(3. - sLayer)*//*iter*/){
           //AliInfo(Form("Failed chi2 filter on chi2Z [%f].", chi2[0]));
           AliTRDtrackerDebug::SetCandidateNumber(AliTRDtrackerDebug::GetCandidateNumber() + 1);
           continue;
         }
-        if(chi2[1] > fReconstructor->GetRecoParam() ->GetChi2Y()/*1./(3. - sLayer)*//*iter*/){
+        if(chi2[1] > fkReconstructor->GetRecoParam() ->GetChi2Y()/*1./(3. - sLayer)*//*iter*/){
           //AliInfo(Form("Failed chi2 filter on chi2Y [%f].", chi2[1]));
           AliTRDtrackerDebug::SetCandidateNumber(AliTRDtrackerDebug::GetCandidateNumber() + 1);
           continue;
@@ -2692,7 +2690,7 @@ Int_t AliTRDtrackerV1::MakeSeeds(AliTRDtrackingChamber **stack, AliTRDseedV1 *ss
         }
 
         // temporary exit door for the HLT
-        if(fReconstructor->IsHLT()){ 
+        if(fkReconstructor->IsHLT()){ 
           // attach clusters to extrapolation chambers
           for(int iLayer=0; iLayer<kNPlanes-kNSeedPlanes; iLayer++){
             Int_t jLayer = planesExt[iLayer];
@@ -2717,7 +2715,7 @@ Int_t AliTRDtrackerV1::MakeSeeds(AliTRDtrackingChamber **stack, AliTRDseedV1 *ss
         }
         Double_t like = CookLikelihood(&cseed[0], planes); // to be checked
       
-        if (TMath::Log(1.E-9 + like) < fReconstructor->GetRecoParam() ->GetTrackLikelihood()){
+        if (TMath::Log(1.E-9 + like) < fkReconstructor->GetRecoParam() ->GetTrackLikelihood()){
           //AliInfo(Form("Failed likelihood %f[%e].", TMath::Log(1.E-9 + like), like));
           AliTRDtrackerDebug::SetCandidateNumber(AliTRDtrackerDebug::GetCandidateNumber() + 1);
           continue;
@@ -2746,8 +2744,8 @@ Int_t AliTRDtrackerV1::MakeSeeds(AliTRDtrackingChamber **stack, AliTRDseedV1 *ss
       
         // AliInfo("Extrapolation done.");
         // Debug Stream containing all the 6 tracklets
-        if(fReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) >= 2){
-          TTreeSRedirector &cstreamer = *fReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
+        if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) >= 2){
+          TTreeSRedirector &cstreamer = *fkReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
           TLinearFitter *tiltedRieman = GetTiltedRiemanFitter();
           Int_t eventNumber            = AliTRDtrackerDebug::GetEventNumber();
           Int_t candidateNumber        = AliTRDtrackerDebug::GetCandidateNumber();
@@ -2764,7 +2762,7 @@ Int_t AliTRDtrackerV1::MakeSeeds(AliTRDtrackingChamber **stack, AliTRDseedV1 *ss
               << "\n";
         }
               
-        if(fReconstructor->HasImproveTracklets() && ImproveSeedQuality(stack, cseed) < 4){
+        if(fkReconstructor->HasImproveTracklets() && ImproveSeedQuality(stack, cseed) < 4){
           AliTRDtrackerDebug::SetCandidateNumber(AliTRDtrackerDebug::GetCandidateNumber() + 1);
           continue;
         }
@@ -2778,7 +2776,7 @@ Int_t AliTRDtrackerV1::MakeSeeds(AliTRDtrackingChamber **stack, AliTRDseedV1 *ss
         // do the final track fitting (Once with vertex constraint and once without vertex constraint)
         Double_t chi2Vals[3];
         chi2Vals[0] = FitTiltedRieman(&cseed[0], kTRUE);
-        if(fReconstructor->HasVertexConstrained())
+        if(fkReconstructor->HasVertexConstrained())
           chi2Vals[1] = FitTiltedRiemanConstraint(&cseed[0], GetZ()); // Do Vertex Constrained fit if desired
         else
           chi2Vals[1] = 1.;
@@ -2788,8 +2786,8 @@ Int_t AliTRDtrackerV1::MakeSeeds(AliTRDtrackingChamber **stack, AliTRDseedV1 *ss
         fTrackQuality[ntracks] = CalculateTrackLikelihood(&cseed[0], &chi2Vals[0]);
         //AliInfo("Hyperplane fit done\n");
                   
-        if(fReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) >= 2){
-          TTreeSRedirector &cstreamer = *fReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
+        if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) >= 2){
+          TTreeSRedirector &cstreamer = *fkReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
           Int_t eventNumber = AliTRDtrackerDebug::GetEventNumber();
           Int_t candidateNumber = AliTRDtrackerDebug::GetCandidateNumber();
           TLinearFitter *fitterTC = GetTiltedRiemanFitterConstraint();
@@ -2832,7 +2830,7 @@ Int_t AliTRDtrackerV1::MakeSeeds(AliTRDtrackingChamber **stack, AliTRDseedV1 *ss
 }
 
 //_____________________________________________________________________________
-AliTRDtrackV1* AliTRDtrackerV1::MakeTrack(AliTRDseedV1 *seeds, Double_t *params)
+AliTRDtrackV1* AliTRDtrackerV1::MakeTrack(const AliTRDseedV1 * const seeds, Double_t *params)
 {
 //
 // Build a TRD track out of tracklet candidates
@@ -2871,13 +2869,13 @@ AliTRDtrackV1* AliTRDtrackerV1::MakeTrack(AliTRDseedV1 *seeds, Double_t *params)
 
   AliTRDtrackV1 track(seeds, &params[1], c, params[0], params[6]*alpha+shift);
   track.PropagateTo(params[0]-5.0);
-  AliTRDseedV1 *ptrTracklet = 0x0;
+  AliTRDseedV1 *ptrTracklet = NULL;
 
   // skip Kalman filter for HLT
-  if(fReconstructor->IsHLT()){ 
+  if(fkReconstructor->IsHLT()){ 
     for (Int_t jLayer = 0; jLayer < AliTRDgeometry::kNlayer; jLayer++) {
       track.UnsetTracklet(jLayer);
-      ptrTracklet = &seeds[jLayer];
+      ptrTracklet = const_cast<AliTRDseedV1 *>(&seeds[jLayer]);
       if(!ptrTracklet->IsOK()) continue;
       if(TMath::Abs(ptrTracklet->GetYref(1) - ptrTracklet->GetYfit(1)) >= .2) continue; // check this condition with Marian
       ptrTracklet = SetTracklet(ptrTracklet);
@@ -2886,18 +2884,18 @@ AliTRDtrackV1* AliTRDtrackerV1::MakeTrack(AliTRDseedV1 *seeds, Double_t *params)
     }
     AliTRDtrackV1 *ptrTrack = SetTrack(&track);
     ptrTrack->CookPID();
-    ptrTrack->SetReconstructor(fReconstructor);
+    ptrTrack->SetReconstructor(fkReconstructor);
     return ptrTrack;
   }
 
   track.ResetCovariance(1);
   Int_t nc = TMath::Abs(FollowBackProlongation(track));
-  if(fReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 5){
+  if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 5){
     Int_t eventNumber          = AliTRDtrackerDebug::GetEventNumber();
     Int_t candidateNumber = AliTRDtrackerDebug::GetCandidateNumber();
     Double_t p[5]; // Track Params for the Debug Stream
     track.GetExternalParameters(params[0], p);
-    TTreeSRedirector &cs = *fReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
+    TTreeSRedirector &cs = *fkReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
     cs << "MakeTrack"
     << "EventNumber="     << eventNumber
     << "CandidateNumber=" << candidateNumber
@@ -2916,10 +2914,10 @@ AliTRDtrackV1* AliTRDtrackerV1::MakeTrack(AliTRDseedV1 *seeds, Double_t *params)
     << "track.=" << &track
     << "\n";
   }
-  if (nc < 30) return 0x0;
+  if (nc < 30) return NULL;
 
   AliTRDtrackV1 *ptrTrack = SetTrack(&track);
-  ptrTrack->SetReconstructor(fReconstructor);
+  ptrTrack->SetReconstructor(fkReconstructor);
   ptrTrack->CookLabel(.9);
   
   // computes PID for track
@@ -2957,7 +2955,7 @@ Int_t AliTRDtrackerV1::ImproveSeedQuality(AliTRDtrackingChamber **stack, AliTRDs
   //
   
   // make a local working copy
-  AliTRDtrackingChamber *chamber = 0x0;
+  AliTRDtrackingChamber *chamber = NULL;
   AliTRDseedV1 bseed[6];
   Int_t nLayers = 0;
   for (Int_t jLayer = 0; jLayer < 6; jLayer++) bseed[jLayer] = cseed[jLayer];
@@ -2992,11 +2990,11 @@ Int_t AliTRDtrackerV1::ImproveSeedQuality(AliTRDtrackingChamber **stack, AliTRDs
     }
 
     chi2 = FitTiltedRieman(bseed, kTRUE);
-    if(fReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) >= 7){
+    if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) >= 7){
       Int_t eventNumber                = AliTRDtrackerDebug::GetEventNumber();
       Int_t candidateNumber = AliTRDtrackerDebug::GetCandidateNumber();
       TLinearFitter *tiltedRieman = GetTiltedRiemanFitter();
-      TTreeSRedirector &cstreamer = *fReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
+      TTreeSRedirector &cstreamer = *fkReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
       cstreamer << "ImproveSeedQuality"
     << "EventNumber="          << eventNumber
     << "CandidateNumber="      << candidateNumber
@@ -3016,7 +3014,7 @@ Int_t AliTRDtrackerV1::ImproveSeedQuality(AliTRDtrackingChamber **stack, AliTRDs
 }
 
 //_________________________________________________________________________
-Double_t AliTRDtrackerV1::CalculateTrackLikelihood(AliTRDseedV1 *tracklets, Double_t *chi2){
+Double_t AliTRDtrackerV1::CalculateTrackLikelihood(const AliTRDseedV1 *const tracklets, Double_t *chi2){
   //
   // Calculates the Track Likelihood value. This parameter serves as main quality criterion for 
   // the track selection
@@ -3044,16 +3042,16 @@ Double_t AliTRDtrackerV1::CalculateTrackLikelihood(AliTRDseedV1 *tracklets, Doub
   chi2phi /= Float_t (nLayers - 2.0);
   
   Double_t likeChi2Z  = TMath::Exp(-chi2[2] * 0.14);                   // Chi2Z 
-  Double_t likeChi2TC = (fReconstructor->HasVertexConstrained()) ? 
+  Double_t likeChi2TC = (fkReconstructor->HasVertexConstrained()) ? 
                                                                                        TMath::Exp(-chi2[1] * 0.677) : 1;                       // Constrained Tilted Riemann
   Double_t likeChi2TR = TMath::Exp(-chi2[0] * 0.0078);                 // Non-constrained Tilted Riemann
   Double_t likeChi2Phi= TMath::Exp(-chi2phi * 3.23);//3.23
   Double_t trackLikelihood     = likeChi2Z * likeChi2TR * likeChi2Phi;
 
-  if(fReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) >= 2){
+  if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) >= 2){
     Int_t eventNumber = AliTRDtrackerDebug::GetEventNumber();
     Int_t candidateNumber = AliTRDtrackerDebug::GetCandidateNumber();
-    TTreeSRedirector &cstreamer = *fReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
+    TTreeSRedirector &cstreamer = *fkReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
     cstreamer << "CalculateTrackLikelihood0"
         << "EventNumber="                      << eventNumber
         << "CandidateNumber="  << candidateNumber
@@ -3096,7 +3094,7 @@ Double_t AliTRDtrackerV1::CookLikelihood(AliTRDseedV1 *cseed, Int_t planes[4])
   //
 
   // ratio of the total number of clusters/track which are expected to be found by the tracker.
-  const AliTRDrecoParam *fRecoPars = fReconstructor->GetRecoParam();
+  const AliTRDrecoParam *fRecoPars = fkReconstructor->GetRecoParam();
   
        Double_t chi2y = GetChi2Y(&cseed[0]);
   Double_t chi2z = GetChi2Z(&cseed[0]);
@@ -3112,23 +3110,23 @@ Double_t AliTRDtrackerV1::CookLikelihood(AliTRDseedV1 *cseed, Int_t planes[4])
 
   Double_t likea     = TMath::Exp(-sumda * fRecoPars->GetPhiSlope());
   Double_t likechi2y  = 0.0000000001;
-  if (fReconstructor->IsCosmic() || chi2y < fRecoPars->GetChi2YCut()) likechi2y += TMath::Exp(-TMath::Sqrt(chi2y) * fRecoPars->GetChi2YSlope());
+  if (fkReconstructor->IsCosmic() || chi2y < fRecoPars->GetChi2YCut()) likechi2y += TMath::Exp(-TMath::Sqrt(chi2y) * fRecoPars->GetChi2YSlope());
   Double_t likechi2z = TMath::Exp(-chi2z * fRecoPars->GetChi2ZSlope());
   Double_t likeN     = TMath::Exp(-(fRecoPars->GetNMeanClusters() - nclusters) / fRecoPars->GetNSigmaClusters());
   Double_t like      = likea * likechi2y * likechi2z * likeN;
 
-  if(fReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) >= 2){
+  if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) >= 2){
     Int_t eventNumber = AliTRDtrackerDebug::GetEventNumber();
     Int_t candidateNumber = AliTRDtrackerDebug::GetCandidateNumber();
-    Int_t nTracklets = 0; Float_t mean_ncls = 0;
+    Int_t nTracklets = 0; Float_t meanNcls = 0;
     for(Int_t iseed=0; iseed < kNPlanes; iseed++){
        if(!cseed[iseed].IsOK()) continue;
        nTracklets++;
-       mean_ncls += cseed[iseed].GetN2();
+       meanNcls += cseed[iseed].GetN2();
     }
-    if(nTracklets) mean_ncls /= nTracklets;
+    if(nTracklets) meanNcls /= nTracklets;
     // The Debug Stream contains the seed 
-    TTreeSRedirector &cstreamer = *fReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
+    TTreeSRedirector &cstreamer = *fkReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
     cstreamer << "CookLikelihood"
         << "EventNumber="                      << eventNumber
         << "CandidateNumber=" << candidateNumber
@@ -3147,7 +3145,7 @@ Double_t AliTRDtrackerV1::CookLikelihood(AliTRDseedV1 *cseed, Int_t planes[4])
         << "nclusters="                                << nclusters
         << "likeN="                                            << likeN
         << "like="                                             << like
-        << "meanncls="        << mean_ncls
+        << "meanncls="        << meanNcls
         << "\n";
   }
 
@@ -3379,21 +3377,21 @@ void AliTRDtrackerV1::GetExtrapolationConfig(Int_t iconfig, Int_t planes[2])
 AliCluster* AliTRDtrackerV1::GetCluster(Int_t idx) const
 {
   Int_t ncls = fClusters->GetEntriesFast();
-  return idx >= 0 && idx < ncls ? (AliCluster*)fClusters->UncheckedAt(idx) : 0x0;
+  return idx >= 0 && idx < ncls ? (AliCluster*)fClusters->UncheckedAt(idx) : NULL;
 }
 
 //____________________________________________________________________
 AliTRDseedV1* AliTRDtrackerV1::GetTracklet(Int_t idx) const
 {
   Int_t ntrklt = fTracklets->GetEntriesFast();
-  return idx >= 0 && idx < ntrklt ? (AliTRDseedV1*)fTracklets->UncheckedAt(idx) : 0x0;
+  return idx >= 0 && idx < ntrklt ? (AliTRDseedV1*)fTracklets->UncheckedAt(idx) : NULL;
 }
 
 //____________________________________________________________________
 AliKalmanTrack* AliTRDtrackerV1::GetTrack(Int_t idx) const
 {
   Int_t ntrk = fTracks->GetEntriesFast();
-  return idx >= 0 && idx < ntrk ? (AliKalmanTrack*)fTracks->UncheckedAt(idx) : 0x0;
+  return idx >= 0 && idx < ntrk ? (AliKalmanTrack*)fTracks->UncheckedAt(idx) : NULL;
 }
 
 
@@ -3472,7 +3470,7 @@ void AliTRDtrackerV1::ResetSeedTB()
 
 
 //_____________________________________________________________________________
-Float_t AliTRDtrackerV1::GetChi2Y(AliTRDseedV1 *tracklets) const
+Float_t AliTRDtrackerV1::GetChi2Y(const AliTRDseedV1 * const tracklets) const
 {
   //   Calculates normalized chi2 in y-direction
   // chi2 = Sum chi2 / n_tracklets
@@ -3487,7 +3485,7 @@ Float_t AliTRDtrackerV1::GetChi2Y(AliTRDseedV1 *tracklets) const
 }
 
 //_____________________________________________________________________________
-Float_t AliTRDtrackerV1::GetChi2Z(AliTRDseedV1 *tracklets) const 
+Float_t AliTRDtrackerV1::GetChi2Z(const AliTRDseedV1 *const tracklets) const 
 {
   //   Calculates normalized chi2 in z-direction
   // chi2 = Sum chi2 / n_tracklets
@@ -3502,7 +3500,7 @@ Float_t AliTRDtrackerV1::GetChi2Z(AliTRDseedV1 *tracklets) const
 }
 
 //____________________________________________________________________
-Float_t AliTRDtrackerV1::CalculateReferenceX(AliTRDseedV1 *tracklets){
+Float_t AliTRDtrackerV1::CalculateReferenceX(const AliTRDseedV1 *const tracklets){
        //
        // Calculates the reference x-position for the tilted Rieman fit defined as middle
        // of the stack (middle between layers 2 and 3). For the calculation all the tracklets
@@ -3556,7 +3554,7 @@ Float_t AliTRDtrackerV1::CalculateReferenceX(AliTRDseedV1 *tracklets){
 }
 
 //_____________________________________________________________________________
-Double_t AliTRDtrackerV1::FitTiltedRiemanV1(AliTRDseedV1 *tracklets){
+Double_t AliTRDtrackerV1::FitTiltedRiemanV1(AliTRDseedV1 *const tracklets){
   //
   // Track Fitter Function using the new class implementation of 
   // the Rieman fit
@@ -3601,13 +3599,13 @@ AliTRDtrackerV1::AliTRDLeastSquare::AliTRDLeastSquare(){
 }
 
 //_____________________________________________________________________________
-void AliTRDtrackerV1::AliTRDLeastSquare::AddPoint(Double_t *x, Double_t y, Double_t sigmaY){
+void AliTRDtrackerV1::AliTRDLeastSquare::AddPoint(const Double_t *const x, Double_t y, Double_t sigmaY){
   //
   // Adding Point to the fitter
   //
   Double_t weight = 1/(sigmaY > 1e-9 ? sigmaY : 1e-9);
   weight *= weight;
-  Double_t &xpt = *x;
+  const Double_t &xpt = *x;
   //   printf("Adding point x = %f, y = %f, sigma = %f\n", xpt, y, sigmaY);
   fSums[0] += weight;
   fSums[1] += weight * xpt;
@@ -3618,14 +3616,14 @@ void AliTRDtrackerV1::AliTRDLeastSquare::AddPoint(Double_t *x, Double_t y, Doubl
 }
 
 //_____________________________________________________________________________
-void AliTRDtrackerV1::AliTRDLeastSquare::RemovePoint(Double_t *x, Double_t y, Double_t sigmaY){
+void AliTRDtrackerV1::AliTRDLeastSquare::RemovePoint(const Double_t *const x, Double_t y, Double_t sigmaY){
   //
   // Remove Point from the sample
   //
   
   Double_t weight = 1/(sigmaY > 1e-9 ? sigmaY : 1e-9);
   weight *= weight;
-  Double_t &xpt = *x; 
+  const Double_t &xpt = *x; 
   fSums[0] -= weight;
   fSums[1] -= weight * xpt;
   fSums[2] -= weight * y;
@@ -3659,7 +3657,7 @@ void AliTRDtrackerV1::AliTRDLeastSquare::Eval(){
 }
 
 //_____________________________________________________________________________
-Double_t AliTRDtrackerV1::AliTRDLeastSquare::GetFunctionValue(Double_t *xpos) const {
+Double_t AliTRDtrackerV1::AliTRDLeastSquare::GetFunctionValue(const Double_t *const xpos) const {
   //
   // Returns the Function value of the fitted function at a given x-position
   //
@@ -3806,7 +3804,7 @@ Double_t AliTRDtrackerV1::AliTRDtrackFitterRieman::Eval(){
 }
 
 //_____________________________________________________________________________
-void AliTRDtrackerV1::AliTRDtrackFitterRieman::UpdateFitters(AliTRDseedV1 *tracklet){
+void AliTRDtrackerV1::AliTRDtrackFitterRieman::UpdateFitters(AliTRDseedV1 * const tracklet){
   //
   // Does the transformations and updates the fitters
   // The following transformation is applied
index 45aad5d..523fa17 100644 (file)
 //                                                                        //
 ////////////////////////////////////////////////////////////////////////////
 
-#ifndef ALITRACKER_H
+//#ifndef ALITRACKER_H
 #include "AliTracker.h"
-#endif
+//#endif
 
-#ifndef ALITRDTRACKINGSECTOR_H
+//#ifndef ALITRDTRACKINGSECTOR_H
 #include "AliTRDtrackingSector.h"
-#endif
+//#endif
 
-#ifndef ROOT_TMatrixDfwd
+//#ifndef ROOT_TMatrixDfwd
 #include <TMatrixDfwd.h>
-#endif
+//#endif
 
 /**************************************************************************
 * Class Status see source file                                           *
@@ -50,6 +50,7 @@ class AliTRDchamberTimeBin;
 class AliTRDtrackerFitter;
 class AliTRDtrackV1;
 class AliTRDReconstructor;
+
 class AliTRDtrackerV1 : public AliTracker
 {
 public:
@@ -67,7 +68,7 @@ public:
     , kMaxTracksStack     = 100
     , kNConfigs           = 15
   };
-  AliTRDtrackerV1(AliTRDReconstructor *rec = 0x0);
+  AliTRDtrackerV1(AliTRDReconstructor *rec = NULL);
   virtual ~AliTRDtrackerV1();
   
   //temporary
@@ -87,30 +88,30 @@ public:
   static TLinearFitter*  GetTiltedRiemanFitterConstraint();
   static AliRieman*      GetRiemanFitter();
   static void     FitRieman(AliTRDcluster **clusters, Double_t chi2[2]);
-  static Float_t  FitRieman(AliTRDseedV1 *tracklets, Double_t *chi2, Int_t *planes = 0x0);
+  static Float_t  FitRieman(AliTRDseedV1 *tracklets, Double_t *chi2, Int_t *const planes = NULL);
   static Float_t  FitTiltedRiemanConstraint(AliTRDseedV1 *tracklets, Double_t zVertex);
   static Float_t  FitTiltedRieman(AliTRDseedV1 *tracklets, Bool_t sigError);
   static Double_t FitTiltedRiemanV1(AliTRDseedV1 *tracklets);
   
-  static Double_t FitRiemanTilt(const AliTRDtrackV1 *trk, AliTRDseedV1 *tracklets = 0x0, Bool_t err=0, Int_t np = 0, AliTrackPoint *points = 0x0);
-  static Double_t FitLine(const AliTRDtrackV1 *trk, AliTRDseedV1 *tracklets = 0x0, Bool_t err=0, Int_t np = 0, AliTrackPoint *points = 0x0);
-  static Double_t FitKalman(AliTRDtrackV1 *trk, AliTRDseedV1 *tracklets = 0x0, Bool_t up=0, Int_t np = 0, AliTrackPoint *points = 0x0);
+  static Double_t FitRiemanTilt(const AliTRDtrackV1 *trk, AliTRDseedV1 *tracklets = NULL, Bool_t err=0, Int_t np = 0, AliTrackPoint *points = NULL);
+  static Double_t FitLine(const AliTRDtrackV1 *trk, AliTRDseedV1 *tracklets = NULL, Bool_t err=0, Int_t np = 0, AliTrackPoint *points = NULL);
+  static Double_t FitKalman(AliTRDtrackV1 *trk, const AliTRDseedV1 * const tracklets = NULL, Bool_t up=0, Int_t np = 0, AliTrackPoint *points = NULL);
 
   Bool_t          IsClustersOwner() const    { return TestBit(kOwner);}
   Bool_t          HasRemoveContainers() const    { return TestBit(kRemoveContainers);}
-  void            SetClustersOwner(Bool_t own=kTRUE) {SetBit(kOwner, own); if(!own) fClusters = 0x0;}
+  void            SetClustersOwner(Bool_t own=kTRUE) {SetBit(kOwner, own); if(!own) fClusters = NULL;}
   void            SetRemoveContainers(Bool_t rm=kTRUE) {SetBit(kRemoveContainers, rm);}
 
   Int_t           FollowBackProlongation(AliTRDtrackV1 &t);
   Int_t           FollowProlongation(AliTRDtrackV1 &t);
   Int_t           LoadClusters(TTree *cTree);
-  Int_t           LoadClusters(TClonesArray *clusters);
+  Int_t           LoadClusters(TClonesArray *const clusters);
   Int_t           PropagateBack(AliESDEvent *event);
   static Int_t    PropagateToX(AliTRDtrackV1 &t, Double_t xToGo, Double_t maxStep);
   Int_t           ReadClusters(TClonesArray* &array, TTree *in) const;
   Int_t           RefitInward(AliESDEvent *event);
   static void     SetNTimeBins(Int_t nTimeBins){fgNTimeBins = nTimeBins; }
-  void            SetReconstructor(const AliTRDReconstructor *rec){ fReconstructor = rec; }
+  void            SetReconstructor(const AliTRDReconstructor *rec){ fkReconstructor = rec; }
   void            UnloadClusters();
 
   class AliTRDLeastSquare{
@@ -118,13 +119,13 @@ public:
     AliTRDLeastSquare();
     ~AliTRDLeastSquare(){};
     
-    void               AddPoint(Double_t *x, Double_t y, Double_t sigmaY);
-    void               RemovePoint(Double_t *x, Double_t y, Double_t sigmaY);
+    void               AddPoint(const Double_t * const x, Double_t y, Double_t sigmaY);
+    void               RemovePoint(const Double_t * const x, Double_t y, Double_t sigmaY);
     void               Eval();
     void    Reset();
     
     Double_t   GetFunctionParameter(Int_t ParNumber) const {return fParams[ParNumber];}
-    Double_t   GetFunctionValue(Double_t *xpos) const;
+    Double_t   GetFunctionValue(const Double_t * const xpos) const;
     void               GetCovarianceMatrix(Double_t *storage) const;
   private:
           AliTRDLeastSquare(const AliTRDLeastSquare &);
@@ -149,13 +150,13 @@ public:
       Double_t GetCurvature() const;
       void GetCovAt(Double_t x, Double_t *cov) const;
 
-      void SetRiemanFitter(TLinearFitter *fitter) { fTrackFitter = fitter; }
-      void SetTracklet(Int_t il, AliTRDseedV1 *tracklet);
+      void SetRiemanFitter(TLinearFitter *const fitter) { fTrackFitter = fitter; }
+      void SetTracklet(Int_t il, AliTRDseedV1 * const tracklet);
       void SetSysClusterError(Double_t err) { fSysClusterError = err; };
     private:
       AliTRDtrackFitterRieman(const AliTRDtrackFitterRieman &);
       AliTRDtrackFitterRieman &operator=(const AliTRDtrackFitterRieman &);
-      void UpdateFitters(AliTRDseedV1 *tracklet);
+      void UpdateFitters(AliTRDseedV1 * const tracklet);
       Bool_t CheckAcceptable(Double_t offset, Double_t slope);
       Double_t CalculateReferenceX();
 
@@ -172,33 +173,33 @@ public:
   };
 
 protected:
-  static Bool_t  AdjustSector(AliTRDtrackV1 *track); 
+  static Bool_t  AdjustSector(AliTRDtrackV1 *const track); 
   Double_t       BuildSeedingConfigs(AliTRDtrackingChamber **stack, Int_t *configs);
   Int_t          BuildTrackingContainers();
   static Float_t CalculateChi2Z(AliTRDseedV1 *tracklets, Double_t offset, Double_t slope, Double_t xref);
   Int_t          Clusters2TracksSM(Int_t sector, AliESDEvent *esd);
-  Int_t          Clusters2TracksStack(AliTRDtrackingChamber **stack, TClonesArray *esdTrackList);
-  AliTRDseedV1*  GetTracklet(AliTRDtrackV1 *trk, Int_t plane, Int_t &idx);
+  Int_t          Clusters2TracksStack(AliTRDtrackingChamber **stack, TClonesArray * const esdTrackList);
+  AliTRDseedV1*  GetTracklet(AliTRDtrackV1 *const trk, Int_t plane, Int_t &idx);
   Bool_t         GetTrackPoint(Int_t index, AliTrackPoint &p) const;   
   Float_t        GetR4Layer(Int_t ly) const { return fR[ly];}
-  Int_t          MakeSeeds(AliTRDtrackingChamber **stack, AliTRDseedV1 *sseed, Int_t *ipar);
-  AliTRDtrackV1* MakeTrack(AliTRDseedV1 *seeds, Double_t *params);
-  AliTRDtrackV1* SetTrack(AliTRDtrackV1 *track);
-  AliTRDseedV1*  SetTracklet(AliTRDseedV1 *tracklet);
+  Int_t          MakeSeeds(AliTRDtrackingChamber **stack, const AliTRDseedV1 * const sseed, const Int_t * const ipar);
+  AliTRDtrackV1* MakeTrack(const AliTRDseedV1 * const seeds, Double_t *params);
+  AliTRDtrackV1* SetTrack(const AliTRDtrackV1 * const track);
+  AliTRDseedV1*  SetTracklet(const AliTRDseedV1 * const tracklet);
 
 private:
   AliTRDtrackerV1(const AliTRDtrackerV1 &tracker);
   AliTRDtrackerV1 &operator=(const AliTRDtrackerV1 &tracker);
   Double_t             CookLikelihood(AliTRDseedV1 *cseed, Int_t planes[4]);
-  Double_t             CalculateTrackLikelihood(AliTRDseedV1 *tracklets, Double_t *chi2);
+  Double_t             CalculateTrackLikelihood(const AliTRDseedV1 *const tracklets, Double_t *chi2);
   Int_t                ImproveSeedQuality(AliTRDtrackingChamber **stack, AliTRDseedV1 *tracklet);
-  static Float_t       CalculateReferenceX(AliTRDseedV1 *tracklets);
+  static Float_t       CalculateReferenceX(const AliTRDseedV1 *const tracklets);
   void        ResetSeedTB();
-  Float_t     GetChi2Y(AliTRDseedV1 *tracklets) const;
-  Float_t     GetChi2Z(AliTRDseedV1 *tracklets) const;
+  Float_t     GetChi2Y(const AliTRDseedV1 *const tracklets) const;
+  Float_t     GetChi2Z(const AliTRDseedV1 *const tracklets) const;
 
 private:
-  const AliTRDReconstructor *fReconstructor;            // reconstructor manager
+  const AliTRDReconstructor *fkReconstructor;            // reconstructor manager
   AliTRDgeometry      *fGeom;                           // Pointer to TRD geometry
   AliTRDtrackingSector fTrSec[kTrackingSectors];        // Array of tracking sectors;    
   TClonesArray        *fClusters;                       // List of clusters
index 86021a0..27bc7ce 100644 (file)
@@ -62,7 +62,7 @@ void AliTRDtrackingChamber::InsertCluster(AliTRDcluster *c, Int_t index)
 }
 
 //_______________________________________________________
-Bool_t AliTRDtrackingChamber::Build(AliTRDgeometry *geo, const AliTRDCalDet *cal, Bool_t hlt)
+Bool_t AliTRDtrackingChamber::Build(AliTRDgeometry *const geo, const AliTRDCalDet *cal, Bool_t hlt)
 {
 // Init chamber and all time bins (AliTRDchamberTimeBin)
 // Calculates radial position of the chamber based on 
@@ -200,7 +200,7 @@ Double_t AliTRDtrackingChamber::GetQuality()
 
 
 //_______________________________________________________
-Bool_t AliTRDtrackingChamber::GetSeedingLayer(AliTRDchamberTimeBin *&fakeLayer, AliTRDgeometry *geo, const AliTRDReconstructor *rec)
+Bool_t AliTRDtrackingChamber::GetSeedingLayer(AliTRDchamberTimeBin *&fakeLayer, AliTRDgeometry * const geo, const AliTRDReconstructor *rec)
 {
   //
   // Creates a seeding layer
@@ -234,7 +234,7 @@ Bool_t AliTRDtrackingChamber::GetSeedingLayer(AliTRDchamberTimeBin *&fakeLayer,
   Int_t hvals[kMaxPads + 1];   memset(hvals, 0, sizeof(Int_t)*kMaxPads);        // one entry in addition for termination flag
   Float_t *sigmas[kMaxRows];
   Float_t svals[kMaxPads];     memset(svals, 0, sizeof(Float_t)*kMaxPads);     
-  AliTRDcluster *c = 0x0;
+  AliTRDcluster *c = NULL;
   for(Int_t irs = 0; irs < kMaxRows; irs++){
     histogram[irs] = &hvals[irs*kMaxCols];
     sigmas[irs] = &svals[irs*kMaxCols];
@@ -379,7 +379,7 @@ Bool_t AliTRDtrackingChamber::GetSeedingLayer(AliTRDchamberTimeBin *&fakeLayer,
       pos[2] = z/n;
       sig[0] = .02;
       sig[1] = sigcands[ican];
-      fakeLayer->InsertCluster(new AliTRDcluster(fDetector, 0., pos, sig, 0x0, 3, signal, col, row, 0, 0, 0., 0), fakeIndex++);
+      fakeLayer->InsertCluster(new AliTRDcluster(fDetector, 0., pos, sig, NULL, 3, signal, col, row, 0, 0, 0., 0), fakeIndex++);
     }
   }
   fakeLayer->BuildIndices();
@@ -409,6 +409,7 @@ Bool_t AliTRDtrackingChamber::GetSeedingLayer(AliTRDchamberTimeBin *&fakeLayer,
 //_______________________________________________________
 void AliTRDtrackingChamber::Print(Option_t *opt) const
 {
+  // Print the chamber status
   if(!GetNClusters()) return;
   AliInfo(Form("fDetector   = %d", fDetector));
   AliInfo(Form("fX0         = %7.3f", fX0));
index 54fb5a3..da6adc3 100644 (file)
@@ -36,17 +36,17 @@ public:
   virtual ~AliTRDtrackingChamber(){}
   
   void     Bootstrap(const AliTRDReconstructor *rec);
-  Bool_t   Build(AliTRDgeometry *geo, const AliTRDCalDet *cal, Bool_t hlt = kFALSE);
-  void     Clear(const Option_t *opt = 0x0);
+  Bool_t   Build(AliTRDgeometry *const geo, const AliTRDCalDet *cal, Bool_t hlt = kFALSE);
+  void     Clear(const Option_t *opt = NULL);
   Int_t    GetDetector() const {return fDetector;}
   Int_t    GetNClusters() const;
   Double_t GetQuality();
-  Bool_t   GetSeedingLayer(AliTRDchamberTimeBin *&layer, AliTRDgeometry *geo, const AliTRDReconstructor *rec);
+  Bool_t   GetSeedingLayer(AliTRDchamberTimeBin *&layer, AliTRDgeometry * const geo, const AliTRDReconstructor *rec);
   Float_t  GetX()        const {return fX0;}
-  AliTRDchamberTimeBin* GetTB(int tb) {return tb >= 0 && tb < AliTRDseedV1::kNtb ? &fTB[tb] : 0x0;}
+  AliTRDchamberTimeBin* GetTB(int tb) {return tb >= 0 && tb < AliTRDseedV1::kNtb ? &fTB[tb] : NULL;}
   void     InsertCluster(AliTRDcluster *c, Int_t index);
   
-  void     Print(Option_t *opt = 0x0) const;
+  void     Print(Option_t *opt = NULL) const;
 
   void     SetDetector(Int_t det) { fDetector = det;}
   void     SetOwner();
index f63de7c..99789dc 100644 (file)
 //                                                                           //\r
 ///////////////////////////////////////////////////////////////////////////////\r
 \r
-#include "AliTRDcalibDB.h"\r
-#include "AliTRDCommonParam.h"\r
-#include "AliTRDReconstructor.h"\r
-#include "AliTRDpadPlane.h"\r
 #include "AliTRDtrackingSector.h"\r
 #include "AliTRDtrackingChamber.h"\r
 \r
@@ -39,7 +35,7 @@ ClassImp(AliTRDtrackingSector)
 AliTRDtrackingSector::AliTRDtrackingSector()\r
   :fSector(-1)\r
   ,fN(0)\r
-  ,fGeom(0x0)\r
+  ,fGeom(NULL)\r
 {\r
   // Default constructor\r
   \r
@@ -71,7 +67,7 @@ void AliTRDtrackingSector::Init(const AliTRDReconstructor *rec, const AliTRDCalD
 //     Propagate radial position information (calibration/alignment aware) from chambers to sector level\r
 //\r
   \r
-  AliTRDchamberTimeBin *tb = 0x0;\r
+  AliTRDchamberTimeBin *tb = NULL;\r
   AliTRDtrackingChamber **tc = &fChamber[0];\r
   for(Int_t ic = 0; (ic<AliTRDgeometry::kNdets) && (*tc); ic++, tc++){\r
     for(Int_t itb=0; itb<AliTRDseedV1::kNtb; itb++){\r
@@ -108,7 +104,7 @@ void AliTRDtrackingSector::Clear(const Option_t *opt)
   AliTRDtrackingChamber **tc = &fChamber[0];\r
   for(Int_t ich=0; ich<fN; ich++, tc++){ \r
     (*tc)->Clear(opt);\r
-    delete (*tc); (*tc) = 0x0;   // I would avoid\r
+    delete (*tc); (*tc) = NULL;   // I would avoid\r
   }    \r
   memset(fIndex, -1, AliTRDgeometry::kNdets*sizeof(Char_t));\r
   fN = 0;\r
@@ -122,7 +118,7 @@ AliTRDtrackingChamber* AliTRDtrackingSector::GetChamber(Int_t stack, Int_t layer
   \r
   Int_t ch = stack*AliTRDgeometry::kNlayer + layer;\r
   if(fIndex[ch] >= 0) return fChamber[Int_t(fIndex[ch])];\r
-  else if(!build) return 0x0;\r
+  else if(!build) return NULL;\r
   \r
   // CHAMBER HAS TO BE BUILD\r
   Int_t rch = ch;do rch--; while(rch>=0 && fIndex[rch]<0);\r
@@ -143,19 +139,19 @@ AliTRDtrackingChamber** AliTRDtrackingSector::GetStack(Int_t stack)
 // Return chamber at position (stack, plane) in current \r
 // sector or build a new one if it is not already created\r
   \r
-  if(stack<0 || stack>=AliTRDgeometry::kNstack) return 0x0;\r
+  if(stack<0 || stack>=AliTRDgeometry::kNstack) return NULL;\r
   \r
   Int_t ich, n = 0;\r
   for(int il=0; il<AliTRDgeometry::kNlayer; il++){\r
     ich = stack*AliTRDgeometry::kNlayer + il;\r
-    if(fIndex[ich] < 0) fStack[il] = 0x0; \r
+    if(fIndex[ich] < 0) fStack[il] = NULL; \r
     else{\r
       fStack[il] = fChamber[Int_t(fIndex[ich])];\r
       n++;\r
     }\r
   }\r
   \r
-  return n ? &fStack[0] : 0x0;\r
+  return n ? &fStack[0] : NULL;\r
 }\r
 \r
 //_____________________________________________________________________________\r
index 5638082..84f56c8 100644 (file)
@@ -32,18 +32,18 @@ public:
   AliTRDtrackingSector(AliTRDgeometry* geo, Int_t gs);
   virtual ~AliTRDtrackingSector(){;}
     
-  void     Clear(const Option_t *opt = 0x0);
+  void     Clear(const Option_t *opt = NULL);
   Int_t    GetNChambers() const             { return fN; }
   Double_t GetX(Int_t pl) const                  { return pl >=0 && pl < AliTRDgeometry::kNlayer ? fX0[pl] : 0.; }
-  AliTRDtrackingChamber* GetChamber(Int_t i) const  { return i>=0 && i < fN ? fChamber[i] : 0x0;  }
+  AliTRDtrackingChamber* GetChamber(Int_t i) const  { return i>=0 && i < fN ? fChamber[i] : NULL;  }
   AliTRDtrackingChamber* GetChamber(Int_t stack, Int_t plane, Bool_t build = kFALSE);
   AliTRDtrackingChamber** GetStack(Int_t stack);
   Int_t    GetSector() const {return fSector;} 
 
   void     Init(const AliTRDReconstructor *rec, const AliTRDCalDet *cal);
-  void     Print(Option_t *opt = 0x0) const;
+  void     Print(Option_t *opt = NULL) const;
   
-  void     SetGeometry(AliTRDgeometry *geo) {fGeom = geo;}
+  void     SetGeometry(AliTRDgeometry *const geo) {fGeom = geo;}
   
 private:
   AliTRDtrackingSector(const AliTRDtrackingSector &/*t*/);
index e7c82d2..1c53ad3 100644 (file)
@@ -25,7 +25,9 @@ class AliTRDCalPID : public TNamed
  public:
 
   enum {
-    kNMom   = 11
+    kNMom   = 11,
+    kNSlicesLQ = 3,
+    kNSlicesNN = 8
   };
 
   AliTRDCalPID();
index e63ad42..2a59ce2 100644 (file)
@@ -29,7 +29,7 @@
 #include <TMultiLayerPerceptron.h>
 
 #include "AliPID.h"
-#include "AliTRDtrack.h"
+#include "AliLog.h"
 
 #include "AliTRDgeometry.h"
 #include "AliTRDCalPIDNN.h"
@@ -162,11 +162,11 @@ Double_t AliTRDCalPIDNN::GetProbability(Int_t spec, Float_t mom
     return 0.;
   }
 
-  Double_t ddedx[AliTRDtrack::kNMLPslice];
+  Double_t ddedx[AliTRDCalPID::kNSlicesNN];
 
-  for (int inode=0; inode<AliTRDtrack::kNMLPslice; inode++) {
+  for (int inode=0; inode<AliTRDCalPID::kNSlicesNN; inode++) {
     ddedx[inode] = (((Double_t) dedx[inode]/kMLPscale)*3)          // Bug fix! Needs new reference data or different calculation of dedx!!!!
-                 / (AliTRDcalibDB::Instance()->GetNumberOfTimeBins()/AliTRDtrack::kNMLPslice);
+                 / (AliTRDcalibDB::Instance()->GetNumberOfTimeBins()/AliTRDCalPID::kNSlicesNN);
   }
 
   lNN1 = nn->Evaluate(spec, ddedx);
index dc076dc..e98b11a 100644 (file)
@@ -55,7 +55,6 @@
 #include "AliTRDCalPID.h"
 #include "AliTRDcalibDB.h"
 #include "AliTRDgeometry.h"
-#include "AliTRDtrack.h"
 
 ClassImp(AliTRDCalPIDRefMaker)
 
@@ -286,11 +285,11 @@ Bool_t AliTRDCalPIDRefMaker::BuildLQReferences(const Char_t *File, const Char_t
                                        
                                        Float_t mom;
                                         //Float_t length;
-                                       Double_t dedx[AliTRDtrack::kNslice], dEdx;
+                                       Double_t dedx[AliTRDCalPID::kNSlicesLQ], dEdx;
                                        Int_t timebin;
                                        for (Int_t iLayer=0; iLayer<AliTRDgeometry::kNlayer; iLayer++){
                                                // read data for track segment
-                                               for(int iSlice=0; iSlice<AliTRDtrack::kNslice; iSlice++)
+                                               for(int iSlice=0; iSlice<AliTRDCalPID::kNSlicesLQ; iSlice++)
                                                        dedx[iSlice] = esdTrack->GetTRDslice(iLayer, iSlice);
                                                dEdx    = esdTrack->GetTRDslice(iLayer, -1);
                                                timebin = esdTrack->GetTRDTimBin(iLayer);
index 516e3f4..adeca4e 100644 (file)
@@ -507,7 +507,7 @@ TH1 *AliTRDcheckPID::PlotdEdxSlice(const AliTRDtrackV1 *track)
     tracklet = cTrack.GetTracklet(iChamb);
     if(!tracklet) continue;
     tracklet -> CookdEdx(AliTRDpidUtil::kLQslices);
-    fdEdx = tracklet->GetdEdx();
+    fdEdx = const_cast<Float_t *>(tracklet->GetdEdx());
     for(Int_t iSlice = 0; iSlice < AliTRDpidUtil::kLQslices; iSlice++){
       hdEdxSlice -> Fill(species * fMomentumAxis->GetNbins() * AliTRDpidUtil::kLQslices + (iMomBin-1) * AliTRDpidUtil::kLQslices + iSlice, fdEdx[iSlice]);
     }
index ba44881..7ec814a 100644 (file)
@@ -221,7 +221,7 @@ void AliTRDpidRefMaker::Exec(Option_t *)
     for(Int_t ily = 0; ily < AliTRDgeometry::kNlayer; ily++){
       if(!(TRDtracklet = TRDtrack -> GetTracklet(ily))) continue;
       TRDtracklet->CookdEdx(AliTRDpidUtil::kNNslices);
-      dedx = TRDtracklet->GetdEdx();
+      dedx = const_cast<Float_t *>(TRDtracklet->GetdEdx());
       for(Int_t iSlice = 0; iSlice < AliTRDpidUtil::kNNslices; iSlice++)
        dedx[iSlice] = dedx[iSlice]/AliTRDCalPIDNN::kMLPscale;
       memcpy(fdEdx, dedx, AliTRDpidUtil::kNNslices*sizeof(Float_t));
@@ -236,7 +236,7 @@ void AliTRDpidRefMaker::Exec(Option_t *)
     for(Int_t ily = 0; ily < AliTRDgeometry::kNlayer; ily++){
       if(!(TRDtracklet = TRDtrack -> GetTracklet(ily))) continue;
       TRDtracklet->CookdEdx(AliTRDpidUtil::kLQslices);
-      dedx = TRDtracklet->GetdEdx();
+      dedx = const_cast<Float_t *>(TRDtracklet->GetdEdx());
       memcpy(fdEdx, dedx, AliTRDpidUtil::kLQslices*sizeof(Float_t));
       if(fDebugLevel>=2) Printf("LayerLQ : %d", ily);
       fLayer = ily;