From: dberzano <dario.berzano@cern.ch>
Date: Thu, 5 Feb 2015 15:37:40 +0000 (+0100)
Subject: doxy: TPC/TPCbase converted
X-Git-Url: http://git.uio.no/git/?p=u%2Fmrichter%2FAliRoot.git;a=commitdiff_plain;h=7d855b04651ce8717e092c35cc00e81a80396a5f

doxy: TPC/TPCbase converted
---

diff --git a/TPC/TPCbase/AliClusters.cxx b/TPC/TPCbase/AliClusters.cxx
index fa30eb6ac5c..0ad8aca6ce8 100644
--- a/TPC/TPCbase/AliClusters.cxx
+++ b/TPC/TPCbase/AliClusters.cxx
@@ -13,17 +13,11 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/* $Id$ */
-
-///////////////////////////////////////////////////////////////////////////////
-//                                                                           //
-//  Time Projection Chamber clusters objects                                //
-//
-//  Origin: Marian Ivanov , GSI Darmstadt
-//                                                                           //
-//                                                                           //
-//                                                                          //
-///////////////////////////////////////////////////////////////////////////////
+/// \class AliClusters
+/// \brief Time Projection Chamber clusters objects
+///
+/// \author Marian Ivanov , GSI Darmstadt
+
 #include "TError.h"
 #include "TClass.h"
 #include  <TROOT.h>
@@ -31,93 +25,79 @@
 #include "AliClusters.h"
 #include "TMarker.h"
 
+const Int_t kDefSize = 1;  ///< defalut size
 
-const Int_t kDefSize = 1;  //defalut size
-
+/// \cond CLASSIMP
+ClassImp(AliClusters)
+/// \endcond
 
-ClassImp(AliClusters) 
-
-//*****************************************************************************
-//
-//_____________________________________________________________________________
 AliClusters::AliClusters()
-            :AliSegmentID(), 
+            :AliSegmentID(),
 	     fClusters(0),
              fNclusters(0),
              fClass(0)
-{  
-  //
-  //default constructor
-  //
-
+{
+  /// default constructor
 }
-//________________________________________________________________________
+
 AliClusters::AliClusters(const AliClusters &param)
-            :AliSegmentID(), 
+            :AliSegmentID(),
 	     fClusters(0),
              fNclusters(0),
              fClass(0)
 {
-  //
-  //  copy constructor - dummy
-  //
+  ///  copy constructor - dummy
+
   fNclusters = param.fNclusters;
 }
 
-//________________________________________________________________________
 AliClusters::AliClusters(const char *classname)
             :AliSegmentID(),
              fClusters(0),
              fNclusters(0),
              fClass(0)
 {
-//
-// Special constructor
-//          
+  /// Special constructor
+
   fClass = gROOT->GetClass(classname);
-  
+
   if (!fClass)
         Error("AliClusters", "%s is not a valid class name", classname);
-  if (!fClass->InheritsFrom(TObject::Class())) 
+  if (!fClass->InheritsFrom(TObject::Class()))
 	Error("AliClusters", "%s does not inherit from TObject", classname);
-                                                 
+
   fClusters = new TClonesArray(fClass->GetName(),100);
 }
 
-//______________________________________________________________________                                                          
 AliClusters & AliClusters::operator =(const AliClusters & param)
 {
-  //
-  // assignment operator - dummy
-  //
+  /// assignment operator - dummy
+
   if (this == &param) return (*this);
   fNclusters=param.fNclusters;
   return (*this);
 }
-//________________________________________________________________________
+
 AliClusters::~AliClusters()
 {
-   //
-   //default destructor
-  //
+  /// default destructor
+
    if (fClusters !=0) fClusters->Delete();
    delete fClusters;
 }
 
-//_________________________________________________________________________
-
 Bool_t AliClusters::SetClass(const Text_t *classname)
 {
-  //
-  //set class of stored object
+  /// set class of stored object
+
   if ( fClass !=0 ) {
     //    delete fClass;
     fClass = 0;
   }
- 
+
   if (!gROOT)
       ::Fatal("AliClusters::SetClass", "ROOT system not initialized");
-   
+
    fClass = gROOT->GetClass(classname);
    if (!fClass) {
       Error("AliClusters", "%s is not a valid class name", classname);
@@ -125,17 +105,15 @@ Bool_t AliClusters::SetClass(const Text_t *classname)
    }
    if (!fClass->InheritsFrom(TObject::Class())) {
       Error("AliClusters", "%s does not inherit from TObject", classname);
-      return kFALSE; 
-   } 
+      return kFALSE;
+   }
    return kTRUE;
 }
 
-//_____________________________________________________________________________
 void AliClusters::SetArray(Int_t length)
 {
-  //
-  // construct Clones array of object
-  //
+  /// construct Clones array of object
+
   if (fClusters!=0) delete fClusters;
   if (fClass==0){
      Error("AliClusters", "cluster type not initialised \n SetClass before!");
@@ -144,67 +122,58 @@ void AliClusters::SetArray(Int_t length)
   fClusters = new TClonesArray(fClass->GetName(),length);
 }
 
-
-
-//_____________________________________________________________________________
 const  TObject* AliClusters::operator[](Int_t i)
 {
-  //
-  // return cluster at internal position i
-  //
+  /// return cluster at internal position i
+
   if (fClusters==0) return 0;
   return fClusters->UncheckedAt(i);
 }
-//_____________________________________________________________________________
+
 void  AliClusters::Sort()
 {
-  // sort cluster 
+  /// sort cluster
+
   if (fClusters!=0) fClusters->Sort();
 }
 
-//_____________________________________________________________________________
-TObject * AliClusters::InsertCluster( const TObject * c) 
-{ 
-  //
-  // Add a simulated cluster copy to the list
-  //
-  if (fClass==0) { 
+TObject * AliClusters::InsertCluster( const TObject * c)
+{
+  /// Add a simulated cluster copy to the list
+
+  if (fClass==0) {
     Error("AliClusters", "class type not specified");
-    return 0; 
+    return 0;
   }
   if(!fClusters) fClusters=new TClonesArray(fClass->GetName(),100);
   TClonesArray &lclusters = *fClusters;
   return new(lclusters[fNclusters++]) AliComplexCluster(*((AliComplexCluster*)c));
 }
 
-//_____________________________________________________________________________
-Int_t AliClusters::Find(Double_t y) const 
+Int_t AliClusters::Find(Double_t y) const
 {
-  //
-  // return index of cluster nearest to given y position
-  //
+  /// return index of cluster nearest to given y position
+
   AliComplexCluster* cl;
   cl=(AliComplexCluster*)fClusters->UncheckedAt(0);
-  if (y <= cl->GetY()) return 0;  
+  if (y <= cl->GetY()) return 0;
   cl=(AliComplexCluster*)fClusters->UncheckedAt(fNclusters-1);
-  if (y > cl->GetY()) return fNclusters; 
+  if (y > cl->GetY()) return fNclusters;
   Int_t b=0, e=fNclusters-1, m=(b+e)/2;
   for (; b<e; m=(b+e)/2) {
     cl = (AliComplexCluster*)fClusters->UncheckedAt(m);
     if (y > cl->GetY()) b=m+1;
-    else e=m; 
+    else e=m;
   }
   return m;
 }
 
 
-//_____________________________________________________________________________
-
-void AliClusters::DrawClusters(Float_t shiftx, Float_t shifty, 
+void AliClusters::DrawClusters(Float_t shiftx, Float_t shifty,
 				  Int_t color, Int_t size, Int_t style)
 {
 
-  if (fClusters==0) return;  
+  if (fClusters==0) return;
   //draw marker for each of cluster
   Int_t ncl=fClusters->GetEntriesFast();
   for (Int_t i=0;i<ncl;i++){
@@ -215,7 +184,6 @@ void AliClusters::DrawClusters(Float_t shiftx, Float_t shifty,
     marker->SetMarkerSize(size);
     marker->SetMarkerStyle(style);
     marker->SetMarkerColor(color);
-    marker->Draw();    
+    marker->Draw();
   }
 }
-
diff --git a/TPC/TPCbase/AliClusters.h b/TPC/TPCbase/AliClusters.h
index e756b7cbd39..c73e2335527 100644
--- a/TPC/TPCbase/AliClusters.h
+++ b/TPC/TPCbase/AliClusters.h
@@ -3,11 +3,9 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-/* $Id$ */
-
-////////////////////////////////////////////////
-//  Manager class for TPC   clusters          //
-////////////////////////////////////////////////
+/// \class AliClusters
+///
+///  Manager class for TPC   clusters
 
 
 #include "AliSegmentID.h"
@@ -32,9 +30,10 @@ public:
   void DrawClusters(Float_t shiftx, Float_t shifty, Int_t color, Int_t size, Int_t style);
   Bool_t SetClass(const Text_t *classname);
 protected:
-  TClonesArray * fClusters; //->array of clusters 
+  /// array of clusters
+  TClonesArray * fClusters; //->
   Int_t  fNclusters;  
-  TClass * fClass; //!type of cluster class 
+  TClass * fClass; //!< type of cluster class
   ClassDef(AliClusters,1) // Cluster manager
 };
 
diff --git a/TPC/TPCbase/AliComplexCluster.cxx b/TPC/TPCbase/AliComplexCluster.cxx
index 68fb8d5745d..2ada85ef6ce 100644
--- a/TPC/TPCbase/AliComplexCluster.cxx
+++ b/TPC/TPCbase/AliComplexCluster.cxx
@@ -13,61 +13,42 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/*
-$Log$
-Revision 1.9  2006/11/06 16:07:15  kowal2
-Eff C++
-
-Revision 1.8  2004/03/30 14:09:22  kowal2
-Changes due to the coding conventions
-
-Revision 1.7  2003/11/24 09:48:28  kowal2
-Changes to obey the coding conventions
-
-Revision 1.6  2003/11/24 09:43:03  kowal2
-Obsolete - removed
-
-Revision 1.5  2003/09/29 11:27:39  kowal2
-new classes added
-
-Revision 1.3  2002/11/15 14:27:45  hristov
-First version of the parallel TPC tracking (M.Ivanov)
-
-Revision 1.2  2001/02/05 14:43:13  hristov
-Compare() declared const
-
-Revision 1.1  2000/10/05 16:17:27  kowal2
-New class replacing AliCluster
-
-
-*/
-
-///////////////////////////////////////////////////////////////////////////////
-//                                                                           //
-//  Time Projection Chamber clusters objects                                //
-//
-//  Origin: Marian Ivanov , GSI Darmstadt
-//                                                                           //
-//Begin_Html
-/*
-<img src="gif/AliTPCCluster.gif">
-*/
-//End_Html
-//                                                                           //
-//                                                                          //
-///////////////////////////////////////////////////////////////////////////////
-// **************
-//aaaaaaaaa
-//aaaaaaaaa
-//aaaaaaaaa
-//aaaaaaaa
-//aaaaaaaaaa
+/// \class AliComplexCluster
+///
+/// Time Projection Chamber clusters objects
+///
+/// \author Marian Ivanov, GSI Darmstadt
+///
+/// * Revision 1.9  2006/11/06 16:07:15  kowal2
+/// Eff C++
+///
+/// * Revision 1.8  2004/03/30 14:09:22  kowal2
+/// Changes due to the coding conventions
+///
+/// * Revision 1.7  2003/11/24 09:48:28  kowal2
+/// Changes to obey the coding conventions
+///
+/// * Revision 1.6  2003/11/24 09:43:03  kowal2
+/// Obsolete - removed
+///
+/// * Revision 1.5  2003/09/29 11:27:39  kowal2
+/// new classes added
+///
+/// * Revision 1.3  2002/11/15 14:27:45  hristov
+/// First version of the parallel TPC tracking (M.Ivanov)
+///
+/// * Revision 1.2  2001/02/05 14:43:13  hristov
+/// Compare() declared const
+///
+/// * Revision 1.1  2000/10/05 16:17:27  kowal2
+/// New class replacing AliCluster
 
 #include "AliComplexCluster.h"
 
-
+/// \cond CLASSIMP
 ClassImp(AliComplexCluster)
-  //__________________________________________________________________
+/// \endcond
+
   AliComplexCluster::AliComplexCluster()
                     :TObject(),
 		     fX(0.),
@@ -79,27 +60,25 @@ ClassImp(AliComplexCluster)
 		     fArea(0.),
 		     fMax(0.)
 {
-  //
-  // default constructor
-  //
+  /// default constructor
    fTracks[0]=fTracks[1]=fTracks[2]=0;
 }
 //_____________________________________________________________________________
 Int_t AliComplexCluster::Compare(const TObject * o) const
 {
-  //
-  // compare two clusters according y coordinata
+  /// compare two clusters according y coordinata
+
   AliComplexCluster *cl= (AliComplexCluster *)o;
   if (fY<cl->fY) return -1;
   if (fY==cl->fY) return 0;
-  return 1;  
+  return 1;
 }
 
 Bool_t AliComplexCluster::IsSortable() const
 {
-  //
-  //make AliComplexCluster sortabale
-  return kTRUE; 
+  /// make AliComplexCluster sortabale
+
+  return kTRUE;
 }
 
 ClassImp(AliTPCExactPoint)
@@ -122,7 +101,7 @@ AliTPCTrackerPoint& AliTPCTrackerPoint::operator=(const AliTPCTrackerPoint& o){
   return *this;
 }
 
+/// \cond CLASSIMP
 ClassImp(AliTPCTrackPoint)
 ClassImp(AliTPCTrackPoint2)
-  //_______________________________________________________________
-
+/// \endcond
diff --git a/TPC/TPCbase/AliComplexCluster.h b/TPC/TPCbase/AliComplexCluster.h
index 097cd54adb9..90fa2e617e0 100644
--- a/TPC/TPCbase/AliComplexCluster.h
+++ b/TPC/TPCbase/AliComplexCluster.h
@@ -3,12 +3,9 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-/* $Id$ */
-//
-// this is a class
-// AliComplexCluster
-// by M. Ivanov
-//
+/// \class AliComplexCluster
+///
+/// \author M. Ivanov
 
 #include "TObject.h"
 #include "TMath.h"
@@ -34,15 +31,15 @@ public:
   Float_t GetArea()const {return fArea;}
   Float_t GetMax()const {return fMax;}
 private:
-  Int_t     fTracks[3];//labels of overlapped tracks
-  Float_t   fX ;       //Y of cluster
-  Float_t   fY ;       //Z of cluster
-  Float_t   fQ ;       //Q of cluster (in ADC counts)
-  Float_t   fSigmaX2;  //Sigma Y square of cluster
-  Float_t   fSigmaY2;  //Sigma Z square of cluster
-  Float_t   fSigmaXY;  //      XY moment 
-  Float_t   fArea;     //area of cluster
-  Float_t   fMax;     //amplitude at maximum 
+  Int_t     fTracks[3];///< labels of overlapped tracks
+  Float_t   fX ;       ///< Y of cluster
+  Float_t   fY ;       ///< Z of cluster
+  Float_t   fQ ;       ///< Q of cluster (in ADC counts)
+  Float_t   fSigmaX2;  ///< Sigma Y square of cluster
+  Float_t   fSigmaY2;  ///< Sigma Z square of cluster
+  Float_t   fSigmaXY;  ///< XY moment
+  Float_t   fArea;     ///< area of cluster
+  Float_t   fMax;     ///< amplitude at maximum
 
   ClassDef(AliComplexCluster,1)
     // Cluster manager
@@ -92,16 +89,16 @@ class AliTPCTrackerPoint  {
 
   //
  private:
-  Short_t   fTX;        // x position of the cluster  in cm - 10 mum prec
-  Short_t   fTZ;        // current prolongation in Z  in cm - 10 mum prec.
-  Short_t   fTY;        // current prolongation in Y  in cm - 10 mum prec.
-  Char_t    fTAngleZ;    // angle 
-  Char_t    fTAngleY;    // angle 
-  UShort_t  fSigmaZ;     // shape  Z - normalised shape - normaliziation 1 - precision 2 percent
-  UShort_t  fSigmaY;     // shape  Y - normalised shape - normaliziation 1 - precision 2 percent
-  UShort_t  fErrZ;       // z error estimate - in  mm - 50 mum precision 
-  UShort_t  fErrY;       // y error estimate - in  mm - 50 mum precision 
-  Char_t   fIsShared;     // indicate sharing of the point between several tracks
+  Short_t   fTX;        ///< x position of the cluster  in cm - 10 mum prec
+  Short_t   fTZ;        ///< current prolongation in Z  in cm - 10 mum prec.
+  Short_t   fTY;        ///< current prolongation in Y  in cm - 10 mum prec.
+  Char_t    fTAngleZ;    ///< angle
+  Char_t    fTAngleY;    ///< angle
+  UShort_t  fSigmaZ;     ///< shape  Z - normalised shape - normaliziation 1 - precision 2 percent
+  UShort_t  fSigmaY;     ///< shape  Y - normalised shape - normaliziation 1 - precision 2 percent
+  UShort_t  fErrZ;       ///< z error estimate - in  mm - 50 mum precision
+  UShort_t  fErrY;       ///< y error estimate - in  mm - 50 mum precision
+  Char_t   fIsShared;     ///< indicate sharing of the point between several tracks
 
   ClassDef(AliTPCTrackerPoint,2)  
 };
@@ -134,13 +131,13 @@ class AliTPCClusterPoint  {
   void     SetMax(Float_t max) {fMax = UShort_t(max);}
   void     SetType(Char_t type) {fCType = type;}
  private:
-  Short_t  fCZ;       // current cluster position Z in cm - 100 mum precision
-  Short_t  fCY;       // current cluster position Y in cm - 100 mum precision
-  UChar_t  fSigmaZ;   // shape  Z - normalised shape - normaliziation 1 - precision 2 percent
-  UChar_t  fSigmaY;   // shape  Y - normalised shape - normaliziation 1 - precision 2 percent
-  UShort_t fQ;        // total charge in cluster 
-  UShort_t fMax;      // charge at maximum  
-  Char_t   fCType;    // type of the cluster
+  Short_t  fCZ;       ///< current cluster position Z in cm - 100 mum precision
+  Short_t  fCY;       ///< current cluster position Y in cm - 100 mum precision
+  UChar_t  fSigmaZ;   ///< shape  Z - normalised shape - normaliziation 1 - precision 2 percent
+  UChar_t  fSigmaY;   ///< shape  Y - normalised shape - normaliziation 1 - precision 2 percent
+  UShort_t fQ;        ///< total charge in cluster
+  UShort_t fMax;      ///< charge at maximum
+  Char_t   fCType;    ///< type of the cluster
 
   //
   ClassDef(AliTPCClusterPoint,1)  
@@ -161,16 +158,16 @@ class AliTPCExactPoint : public TObject{
     fRow(0),
     fSec(0){}
  private:
-  Float_t fEZ;       // current "exact" position according simulation
-  Float_t fEY;       // current "exact" position according simulation
-  Float_t fEX;       // x poistion of the cluster
-  Float_t fEAngleZ;  // angle Z
-  Float_t fEAngleY;  // angle Y
-  Float_t fEAmp;     // total charge deposited in row
-  Float_t fEPrim;    // primary charge deposited in row
-  Int_t   fTrackID;  // id of the track
-  Int_t   fRow;      // row
-  Int_t   fSec;      //sector
+  Float_t fEZ;       ///< current "exact" position according simulation
+  Float_t fEY;       ///< current "exact" position according simulation
+  Float_t fEX;       ///< x poistion of the cluster
+  Float_t fEAngleZ;  ///< angle Z
+  Float_t fEAngleY;  ///< angle Y
+  Float_t fEAmp;     ///< total charge deposited in row
+  Float_t fEPrim;    ///< primary charge deposited in row
+  Int_t   fTrackID;  ///< id of the track
+  Int_t   fRow;      ///< row
+  Int_t   fSec;      ///< sector
   ClassDef(AliTPCExactPoint,1)  
 };
 
@@ -187,9 +184,11 @@ class AliTPCTrackPoint: public TObject{
  private:
   //  AliTPCClusterPoint fCPoint; 
   //Char_t fIsShared;
-  AliTPCTrackerPoint fTPoint;  // track point
-  AliTPCclusterMI    fCPoint;  // cluster point
+  AliTPCTrackerPoint fTPoint;  ///< track point
+  AliTPCclusterMI    fCPoint;  ///< cluster point
+  /// \cond CLASSIMP
   ClassDef(AliTPCTrackPoint,1)  
+  /// \endcond
 };
 
 class AliTPCTrackPoint2: public AliTPCTrackPoint{
@@ -209,25 +208,24 @@ class AliTPCTrackPoint2: public AliTPCTrackPoint{
     fID(0),
     fLab(0){}
  private: 
-  Float_t fGX;    //global poition of the point
-  Float_t fGY;    //global poition of the point
-  Float_t fGZ;    //global poition of the point
+  Float_t fGX;    ///< global poition of the point
+  Float_t fGY;    ///< global poition of the point
+  Float_t fGZ;    ///< global poition of the point
   //
-  Float_t fDY;    //distortion of the clusters from the global helix (3 point interpolation)
-  Float_t fDZ;    //distortion of the clusters from the global helix (3 point interpolation)
+  Float_t fDY;    ///< distortion of the clusters from the global helix (3 point interpolation)
+  Float_t fDZ;    ///< distortion of the clusters from the global helix (3 point interpolation)
   //
-  Float_t fDYU;  //derivation in y up
-  Float_t fDYD;  //distortion of y down
+  Float_t fDYU;  ///< derivation in y up
+  Float_t fDYD;  ///< distortion of y down
   //
-  Float_t fDZU;  //derivation in y up
-  Float_t fDZD;  //distortion of y down
+  Float_t fDZU;  ///< derivation in y up
+  Float_t fDZD;  ///< distortion of y down
   //
-  Float_t fDDY;  //derivation in y,z up-down
-  Float_t fDDZ;  //derivation in y,z up-down
+  Float_t fDDY;  ///< derivation in y,z up-down
+  Float_t fDDZ;  ///< derivation in y,z up-down
   //
-  Int_t   fID;            //id of the corresponding track
-  Int_t   fLab;           //MC label of the track
-  ClassDef(AliTPCTrackPoint2,1)  
+  Int_t   fID;            ///< id of the corresponding track
+  Int_t   fLab;           ///< MC label of the track
 };
 
 
diff --git a/TPC/TPCbase/AliDetectorParam.cxx b/TPC/TPCbase/AliDetectorParam.cxx
index 8b940987bdb..e769a4544c0 100644
--- a/TPC/TPCbase/AliDetectorParam.cxx
+++ b/TPC/TPCbase/AliDetectorParam.cxx
@@ -13,14 +13,11 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/* $Id$ */
-
-///////////////////////////////////////////////////////////////////////
-//  Paramter class for AliDetector                                   //
-//                                                                   //
-//  Origin:  Marian Ivanov, Uni. of Bratislava, ivanov@fmph.uniba.sk // 
-//                                                                   //  
-///////////////////////////////////////////////////////////////////////
+/// \class AliDetectorParam
+///
+/// Paramter class for AliDetector
+///
+/// \author Marian Ivanov, Uni. of Bratislava, ivanov@fmph.uniba.sk
 
 #include <TMath.h>
 #include <TObject.h>
@@ -34,23 +31,22 @@ AliDetectorParam::AliDetectorParam()
                     fNPrimLoss(0.),
                     fNTotalLoss(0.)
 {
-  //
-  //  default constructor
-  //
+  ///  default constructor
+
 }
 
 Float_t * AliDetectorParam::GetAnglesAccMomentum(Float_t *x, Int_t * /*index*/, Float_t *momentum, Float_t *angle)
 {
-  //
-  //calculates deflection angle of particle with longitudinal
-  //longitudinal  momentum[0] and transversal momentum momentum[1]
-  //at position (x,y,z) = (x[0],x[1],x[2]) 
-  //angle[0] - deep angle
-  //angle[1] - magnetic deflection angle 
+  /// calculates deflection angle of particle with longitudinal
+  /// longitudinal  momentum[0] and transversal momentum momentum[1]
+  /// at position (x,y,z) = (x[0],x[1],x[2])
+  /// angle[0] - deep angle
+  /// angle[1] - magnetic deflection angle
+
   if (momentum==0) {
     Float_t rtotal =TMath::Sqrt(x[0]*x[0]+x[1]*x[1]);
     if (rtotal==0) angle[0]=0;
-    else    
+    else
       angle[0] = TMath::ATan(x[2]/rtotal);
     angle[1]=0;
     return angle;
@@ -66,13 +62,9 @@ Float_t * AliDetectorParam::GetAnglesAccMomentum(Float_t *x, Int_t * /*index*/,
   Float_t radius2 = 1000*mtotal/(3*fBField);
   if (radius1<radius2)
     angle[1]= TMath::ASin(radius1/radius2);
-  else 
+  else
     angle[1]=0;
   return angle;
-} 
-
-
-
-
+}
 
-ClassImp(AliDetectorParam)
+ClassImp(AliDetectorParam);
diff --git a/TPC/TPCbase/AliDetectorParam.h b/TPC/TPCbase/AliDetectorParam.h
index 11e61fe35dd..7e95e9d43da 100644
--- a/TPC/TPCbase/AliDetectorParam.h
+++ b/TPC/TPCbase/AliDetectorParam.h
@@ -3,38 +3,35 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-/* $Id$ */
-
-////////////////////////////////////////////////
-//  Manager class for detector parameters          //
-////////////////////////////////////////////////
+/// \class AliDetectorParam
+/// \brief Manager class for detector parameters
 
 #include <TNamed.h>
 class AliDetectorParam : public TNamed {
 public:
   AliDetectorParam();
   virtual Int_t GetNSegmentsTotal() const {return 0;} //get total nuber of segments
-  virtual Bool_t Get1DIndex(Int_t */*index*/, const Int_t * /*arrindex*/) {return kFALSE;} 
+  virtual Bool_t Get1DIndex(Int_t */*index*/, const Int_t * /*arrindex*/) {return kFALSE;}
   //transform multidimensional index to one dimesional
   virtual Bool_t GetNDIndex(const Int_t * /*index1*/, Int_t * /*arrIndex*/) {return kFALSE;}
   //trasnform one dimesional index to multidimesional
   virtual Float_t GetPrimaryLoss(Float_t */*x*/, Int_t */*index*/, Float_t */*angle*/){return 0;}
   virtual Float_t GetTotalLoss(Float_t */*x*/, Int_t */*index*/, Float_t */*angle*/){return 0;}
   virtual void GetClusterSize(Float_t */*x*/, Int_t */*index*/, Float_t */*angle*/, Int_t /*mode*/, Float_t */*sigma*/){;}
-  virtual void GetSpaceResolution(Float_t */*x*/, Int_t */*index*/, Float_t */*angle*/, Float_t /*amplitude*/, Int_t /*mode*/, 
+  virtual void GetSpaceResolution(Float_t */*x*/, Int_t */*index*/, Float_t */*angle*/, Float_t /*amplitude*/, Int_t /*mode*/,
 				  Float_t */*sigma*/){;}
-  virtual Float_t * GetAnglesAccMomentum(Float_t *x, Int_t * index, Float_t* momentum, Float_t *angle); 
+  virtual Float_t * GetAnglesAccMomentum(Float_t *x, Int_t * index, Float_t* momentum, Float_t *angle);
 
-  void  SetBField(Float_t b){fBField=b;} //set magnetic field intensity  
+  void  SetBField(Float_t b){fBField=b;} //set magnetic field intensity
   void  SetNPrimLoss(Float_t loss) {fNPrimLoss = loss;}
   void  SetNTotalLoss(Float_t loss) {fNTotalLoss = loss;}
   Float_t GetBFiled() {return fBField;}
   Float_t GetNPrimLoss() {return fNPrimLoss;}
   Float_t GetNTotalLoss() {return fNTotalLoss;}
 protected:
-  Float_t fBField;  //intensity of magnetic field
-  Float_t fNPrimLoss; //number of produced primary  electrons  per cm
-  Float_t fNTotalLoss; //total  number of produced  electrons  per cm
+  Float_t fBField;  ///< intensity of magnetic field
+  Float_t fNPrimLoss; ///< number of produced primary  electrons  per cm
+  Float_t fNTotalLoss; ///< total  number of produced  electrons  per cm
 
   ClassDef(AliDetectorParam,1)  //parameter  object for set:TPC
 };
diff --git a/TPC/TPCbase/AliDigits.cxx b/TPC/TPCbase/AliDigits.cxx
index bdae6baf7a8..8ea00066f33 100644
--- a/TPC/TPCbase/AliDigits.cxx
+++ b/TPC/TPCbase/AliDigits.cxx
@@ -23,13 +23,9 @@
           -- for Marek -I had it in my code  
 */ 
 
-///////////////////////////////////////////////////////////////////////////////
-//                                                                           //
-//   Alice  digits array  object  AliDigits                                  //
-//                                                                           //
-//                                                                           //
-//                                                                           //
-///////////////////////////////////////////////////////////////////////////////
+/// \class AliDigits
+///
+///   Alice  digits array  object  AliDigits
 
 
 #include "TClass.h"
@@ -46,7 +42,9 @@
 //_____________________________________________________________________________
 //_____________________________________________________________________________
 //_____________________________________________________________________________
+/// \cond CLASSIMP
 ClassImp(AliDigits)
+/// \endcond
 
 
  AliDigits::AliDigits()
@@ -81,9 +79,8 @@ AliDigits::AliDigits(const AliDigits& digits)
             fCurrentCol(0),
             fCurrentIndex(0)
 {
-  //
-  //copy constructor
-  //
+  /// copy constructor
+
   fNrows = digits.fNrows;
   fNcols = digits.fNcols;
   fElements = new TArrayS(*(digits.fElements));
@@ -95,7 +92,8 @@ AliDigits::AliDigits(const AliDigits& digits)
 
 AliDigits & AliDigits::operator =(const AliDigits & digits)
 {
-  //assignment operator
+  /// assignment operator
+
   if (this == &digits) return (*this); 
 
   fNrows = digits.fNrows;
@@ -112,8 +110,8 @@ AliDigits & AliDigits::operator =(const AliDigits & digits)
 
 AliDigits::~AliDigits()
 {
-  //
-  //default destructor
+  /// default destructor
+
   if (fIndex !=0 ) {
     delete fIndex;
   }
@@ -127,7 +125,8 @@ AliDigits::~AliDigits()
 
 Bool_t AliDigits::OutOfBoundsError(const char *where, Int_t row, Int_t column) 
 {
-   // Generate an out-of-bounds error. Always returns false.
+   /// Generate an out-of-bounds error. Always returns false.
+
    ::Error(where, "row %d  col %d out of bounds (size: %d x %d, this: 0x%08lx)", 
 	   row, column, fNrows, fNcols, (ULong_t) this);
    return kFALSE;
@@ -136,8 +135,8 @@ Bool_t AliDigits::OutOfBoundsError(const char *where, Int_t row, Int_t column)
 
 void AliDigits::Invalidate() 
 { 
-  //
-  //set default (invalid parameters)
+  /// set default (invalid parameters)
+
   if (fIndex != 0)  delete  fIndex;
   fIndex = new TArrayI;
   
@@ -153,8 +152,8 @@ void AliDigits::Invalidate()
 
 void AliDigits::Allocate(Int_t rows, Int_t columns)
 {
-  //
-  //construct empty buffer fDigits with size rows x columns
+  /// construct empty buffer fDigits with size rows x columns
+
   Invalidate();
   if (rows <= 0) {
       Error("Allocate", "no of rows has to be positive");
@@ -177,10 +176,10 @@ void AliDigits::Allocate(Int_t rows, Int_t columns)
 
 Int_t AliDigits::GetSize()
 {
-  //
-  //return size of object as represented in the memory
-  //
-  //  Int_t size = sizeof(this);
+  /// return size of object as represented in the memory
+  ///
+  ///  Int_t size = sizeof(this);
+
   Int_t size = 0;   // COVERITY consider the previous statment as bug 
                     // 
   if (fIndex!=0) size+= sizeof(fIndex)+fIndex->GetSize()*sizeof(Int_t);
@@ -190,18 +189,16 @@ Int_t AliDigits::GetSize()
 
 Int_t AliDigits::GetDigitSize() //return total size of pure digit
 {
-  //
-  //return size of PURE DIGITS
-  //
+  /// return size of PURE DIGITS
+
   if (fElements==0) return 0;
   else return sizeof(fElements)+fElements->GetSize()*sizeof(Short_t);
 }
 
 Int_t AliDigits::GetOverTh(Float_t threshold,Float_t x1, Float_t x2, Float_t y1, Float_t y2)
 {
-  //
-  //return number of digits over threshold
-  // 
+  /// return number of digits over threshold
+
  if ( (fElements==0) || (fElements->GetSize()<=0)) return 0;
  
  if (x1<=x2) {
@@ -226,8 +223,8 @@ Int_t AliDigits::GetOverTh(Float_t threshold,Float_t x1, Float_t x2, Float_t y1,
 
 Short_t AliDigits::GetDigit(Int_t row, Int_t column)
 {
-  //
-  // return digit for given row and collumn
+  /// return digit for given row and collumn
+
   if (fBufType ==0) return GetDigitFast(row,column);
   if (fBufType ==1) return GetDigit1(row,column);
 
@@ -237,8 +234,8 @@ Short_t AliDigits::GetDigit(Int_t row, Int_t column)
 
 void AliDigits::ExpandBuffer()
 {  
-  //
-  //expand buffer to two dimensional array
+  /// expand buffer to two dimensional array
+
   if (fBufType<0)  {
     Error("ExpandBuffer", "buffer doesn't exist");
     return;
@@ -253,8 +250,8 @@ void AliDigits::ExpandBuffer()
 
 void AliDigits::CompresBuffer(Int_t bufferType,Int_t threshold)
 {
-  //
-  //compres buffer according buffertype algorithm
+  /// compres buffer according buffertype algorithm
+
   if (fBufType<0)  {
     Error("CompressBuffer", "buffer doesn't exist");
     return;
@@ -273,7 +270,8 @@ void AliDigits::CompresBuffer(Int_t bufferType,Int_t threshold)
 
 Bool_t AliDigits::First()
 {
-  //adjust  first valid current digit
+  /// adjust  first valid current digit
+
   if (fBufType ==0) return First0();
   if (fBufType ==1) return First1();
   return kFALSE;
@@ -281,7 +279,8 @@ Bool_t AliDigits::First()
 
 Bool_t  AliDigits::Next()
 {
-  //addjust next valid current digit
+  /// addjust next valid current digit
+
   if (fBufType ==0) return Next0();
   if (fBufType ==1) return Next1();
   return kFALSE;
@@ -289,9 +288,9 @@ Bool_t  AliDigits::Next()
  
 void AliDigits::AcceptHisto(AliH2F * his)
 {
-  //
-  //make digits buffer with value according histograms values
-  //for testing purpose  
+  /// make digits buffer with value according histograms values
+  /// for testing purpose
+
   Int_t idim =his->GetNbinsX();
   Int_t jdim =his->GetNbinsY();
   if ( (idim<1)|| (jdim<1)) {
@@ -310,8 +309,8 @@ void AliDigits::AcceptHisto(AliH2F * his)
 
 AliH2F *  AliDigits::GenerHisto()
 {
-  //
-  //make digits histo 
+  /// make digits histo
+
   char ch[30];
   snprintf(ch,30, "Segment_%d ",GetID());
   if ( (fNrows<1)|| (fNcols<1)) {
@@ -328,9 +327,8 @@ AliH2F *  AliDigits::GenerHisto()
 
 AliH2F *AliDigits::DrawDigits(const char *option,Float_t x1, Float_t x2, Float_t y1, Float_t y2)
 {
-  //
-  //draw digits in given array
-  //
+  /// draw digits in given array
+
   AliH2F *h2f = GenerHisto();
   if (x1>=0) {
       AliH2F *h2fsub = h2f->GetSubrange2d(x1,x2,y1,y2);
@@ -345,8 +343,8 @@ AliH2F *AliDigits::DrawDigits(const char *option,Float_t x1, Float_t x2, Float_t
 
 void AliDigits::ExpandBuffer1()
 {
-  //
-  //expand buffer of type to twodimensional array
+  /// expand buffer of type to twodimensional array
+
   Int_t i,k;
   fNelems = fNrows*fNcols;
   Short_t * buf = new Short_t[fNelems];
@@ -378,9 +376,8 @@ void AliDigits::ExpandBuffer1()
 
 void AliDigits::CompresBuffer1()
 {
-  //
-  //compres buffer according  algorithm 1
-  //
+  /// compres buffer according  algorithm 1
+
   TArrayS  buf;  //lets have the nearly the "worst case"
   buf.Set(fNelems);
   TArrayI  index;
@@ -430,8 +427,8 @@ void AliDigits::CompresBuffer1()
 
 Bool_t AliDigits::First0()
 {
-  //
-  //first for the buffer type 0
+  /// first for the buffer type 0
+
   fCurrentRow = -1;
   fCurrentCol = -1;
   fCurrentIndex = -1;
@@ -446,9 +443,8 @@ Bool_t AliDigits::First0()
 
 Bool_t AliDigits::Next0()
 {
-  //
-  //next for the buffer type 0
-  //
+  /// next for the buffer type 0
+
   if (fCurrentIndex<0) return kFALSE;  // if we didn't adjust first 
   Int_t i;
   for (i=fCurrentIndex+1; ( (i<fNelems) && (fElements->At(i)<=fThreshold) ) ;i++) {}
@@ -464,8 +460,8 @@ Bool_t AliDigits::Next0()
 
 Bool_t AliDigits::First1()
 {
-  //
-  //first for the buffer type 1
+  /// first for the buffer type 1
+
   fCurrentRow = -1;
   fCurrentCol = 0;
   fCurrentIndex = -1;
@@ -489,8 +485,8 @@ Bool_t AliDigits::First1()
 
 Bool_t AliDigits::Next1()
 {
-  //
-  //next for the buffer type 1
+  /// next for the buffer type 1
+
   if (fCurrentIndex<0) return kFALSE;  // if we didn't adjust first 
   Int_t i;
   for (i=fCurrentIndex+1; i<fNelems;i++){
@@ -512,10 +508,9 @@ Bool_t AliDigits::Next1()
 
 Short_t AliDigits::GetDigit1(Int_t row, Int_t column)
 {
-  //
-  //return digit for given row and column  the buffer type 1
-  //no control performed
-  
+  /// return digit for given row and column  the buffer type 1
+  /// no control performed
+
   Int_t i,n2;
   if ( (column+1)>=fNcols) n2 = fNelems;
   else
diff --git a/TPC/TPCbase/AliDigits.h b/TPC/TPCbase/AliDigits.h
index 4943dce3bef..531bedb9f72 100644
--- a/TPC/TPCbase/AliDigits.h
+++ b/TPC/TPCbase/AliDigits.h
@@ -5,10 +5,10 @@
 
 /* $Id$ */
 
-////////////////////////////////////////////////
-//  Manager class generaol Alice segment digits
-//  segment is for example one pad row in TPC //
-////////////////////////////////////////////////
+/// \class AliDigits
+///
+///  Manager class generaol Alice segment digits
+///  segment is for example one pad row in TPC
 
 #include   <TArrayI.h>
 #include   <TArrayS.h>
@@ -60,26 +60,29 @@ protected:
   Bool_t Next1();//next for the buffer type 1
   Short_t  GetDigit1(Int_t row, Int_t column); //return digit for given row and column
  
-  Int_t     fNrows;   //number of rows in Segment
-  Int_t     fNcols; //number of collumns in Segment 
+  Int_t     fNrows;   ///< number of rows in Segment
+  Int_t     fNcols; ///< number of collumns in Segment
 private:
-  TArrayS *fElements;  //buffer of 2 bytes integers for digits
-  TArrayI *fIndex;  //index position of column
-  Int_t     fBufType; //type of the buffer - define compression algorithm  
-  Int_t     fThreshold; //treshold for zero suppresion
-  Int_t     fNelems;  //total number of elements 
-  Int_t fCurrentRow;   //!current row  iteration
-  Int_t fCurrentCol;   //!current column iteration
-  Int_t fCurrentIndex; //!current index in field
+  TArrayS *fElements;  ///< buffer of 2 bytes integers for digits
+  TArrayI *fIndex;  ///< index position of column
+  Int_t     fBufType; ///< type of the buffer - define compression algorithm
+  Int_t     fThreshold; ///< treshold for zero suppresion
+  Int_t     fNelems;  ///< total number of elements
+  Int_t fCurrentRow;   //!< current row  iteration
+  Int_t fCurrentCol;   //!< current column iteration
+  Int_t fCurrentIndex; //!< current index in field
  
+  /// \cond CLASSIMP
   ClassDef(AliDigits,2) 
+  /// \endcond
 };
  
 
 
 inline Bool_t AliDigits::BoundsOK(const char *where, Int_t row, Int_t col) 
 {
-  //Check If Bound Ok
+  /// Check If Bound Ok
+
   if ( (col>=fNcols) || (col<0) ) return OutOfBoundsError(where,row,col);
   Int_t index =(*fIndex).At(col)+row;
   if ( (index<0) || (index>fNelems)) return OutOfBoundsError(where,row,col);
@@ -88,35 +91,31 @@ inline Bool_t AliDigits::BoundsOK(const char *where, Int_t row, Int_t col)
 
 inline Short_t AliDigits::GetDigitFast(Int_t row, Int_t column)
 {
-  //
-  //return digit from  fDigits array
-  //if out of range return dummy value  ( value at row = 0, collumn = 0)
-  //
+  /// return digit from  fDigits array
+  /// if out of range return dummy value  ( value at row = 0, collumn = 0)
+
   return fElements->At(fIndex->At(column)+row); 
 }
 
 inline Short_t AliDigits::GetDigitUnchecked(Int_t row, Int_t column)
 {
-  //
-  //return digit from  fDigits array
-  //if out of range return dummy value  ( value at row = 0, collumn = 0)
-  //
+  /// return digit from  fDigits array
+  /// if out of range return dummy value  ( value at row = 0, collumn = 0)
+
   return fElements->fArray[fIndex->fArray[column]+row]; 
 }
 
 inline Short_t * AliDigits::GetDigitsColumn(Int_t column){
-  //
-  //return row  pointer to the array digits
-  //
+  /// return row  pointer to the array digits
+
   return &(fElements->fArray[fIndex->fArray[column]]);
 }
 
 
 inline void  AliDigits::SetDigitFast(Short_t value, Int_t row, Int_t column)
 {
-  //
-  //set  digit 
-  //
+  /// set  digit
+
   if ( (row<0) || (row>=fNrows)  || (column<0) || (column>=fNcols) ) 
        Error("AliDigits::SetDigitFast", "row %d  col %d out of bounds (size: %d x %d, this: 0x%08lx)", 
 	     row, column, fNrows, fNcols, (ULong_t)this);
diff --git a/TPC/TPCbase/AliDigitsArray.cxx b/TPC/TPCbase/AliDigitsArray.cxx
index f579aacf7aa..e44534f0944 100644
--- a/TPC/TPCbase/AliDigitsArray.cxx
+++ b/TPC/TPCbase/AliDigitsArray.cxx
@@ -13,16 +13,8 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/* $Id$ */
-
-///////////////////////////////////////////////////////////////////////////////
-//                                                                           //
-//  AliDigitsArray  object                                //
-//
-//  Origin: Marian Ivanov , GSI Darmstadt
-//                                                                           //
-//                                                                          //
-///////////////////////////////////////////////////////////////////////////////
+/// \class AliDigitsArray
+/// \author Marian Ivanov , GSI Darmstadt
 
 #include "TObject.h"
 #include "AliSegmentID.h"
@@ -35,32 +27,29 @@
 
 
 
+/// \cond CLASSIMP
 ClassImp(AliDigitsArray)
-//
+/// \endcond
 
 AliDigitsArray::AliDigitsArray()
                :AliSegmentArray(),
 		fParam(0)
 {
-  //
-  // default constructor
-  //
+  /// default constructor
 }
 AliDigitsArray::AliDigitsArray(const AliDigitsArray &param)
              :AliSegmentArray(),
 	      fParam(0)
 {
-  //
-  // dummy
-  //
+  /// dummy
+
   fParam = param.fParam;
 }
 //
 AliDigitsArray & AliDigitsArray::operator =(const AliDigitsArray & param)
 {
-  //
-  // dummy
-  // 
+  /// dummy
+
  if (this == &param) return (*this); 
  fParam = param.fParam;
  return (*this);
@@ -68,13 +57,14 @@ AliDigitsArray & AliDigitsArray::operator =(const AliDigitsArray & param)
 //
 AliDigitsArray::~AliDigitsArray()
 {
-  // if (fParam != 0) delete fParam;
+  /// if (fParam != 0) delete fParam;
+
 }  
 
 Bool_t AliDigitsArray::Setup(AliDetectorParam *param)
 {
-  //
-  //setup array according parameters
+  /// setup array according parameters
+
   SetParam(param);
   return kTRUE;
 }
diff --git a/TPC/TPCbase/AliDigitsArray.h b/TPC/TPCbase/AliDigitsArray.h
index d0e69fc5a7d..32dd4234267 100644
--- a/TPC/TPCbase/AliDigitsArray.h
+++ b/TPC/TPCbase/AliDigitsArray.h
@@ -5,9 +5,9 @@
 
 /* $Id$ */
 
-////////////////////////////////////////////////
-//  Manager class for AliDigitsArray        //
-////////////////////////////////////////////////
+/// \class AliDigitsArray
+///
+///  Manager class for AliDigitsArray
 
 #include "AliSegmentArray.h"
 class AliDetectorParam;
@@ -22,7 +22,7 @@ public:
   const AliDetectorParam *  GetParam() {return fParam;} 
   virtual Bool_t SetParam(AliDetectorParam * param);
 protected:  
-  AliDetectorParam * fParam;      //pointer to detector parameters 
+  AliDetectorParam * fParam;      ///< pointer to detector parameters
   ClassDef(AliDigitsArray,1) // Digits manager  
 };
   
diff --git a/TPC/TPCbase/AliH2F.cxx b/TPC/TPCbase/AliH2F.cxx
index ec6143ce97f..3ea188878ef 100644
--- a/TPC/TPCbase/AliH2F.cxx
+++ b/TPC/TPCbase/AliH2F.cxx
@@ -15,12 +15,11 @@
 
 /* $Id$ */
 
-//----------------------------------------------------------------------------
-//  Author:   Marian Ivanov
-//
-//  Implementation of class AliH2F
-//
-//-----------------------------------------------------------------------------
+/// \class AliH2F
+///
+///  Implementation of class AliH2F
+///
+/// \author Marian Ivanov
 
 #include <TClonesArray.h>
 #include <TMath.h>
@@ -29,7 +28,9 @@
 #include "AliH2F.h"
 
 
+/// \cond CLASSIMP
 ClassImp(AliH2F)
+/// \endcond
 //***********************************************************************
 //***********************************************************************
 //***********************************************************************
@@ -45,25 +46,27 @@ AliH2F::AliH2F(const Text_t *name,const Text_t *title,
   TH2F(name,title,nbinsx,xlow,xup
        ,nbinsy,ylow,yup)
 {
-  //
-  
+  ///
+
 }
      
 AliH2F::~AliH2F() 
 {
-  //
+  ///
+
 }
 
 AliH2F::AliH2F(const AliH2F &his) :
   TH2F(his)
 {
-  //
-  
+  ///
+
 }
 
 AliH2F & AliH2F::operator = (const AliH2F & /*his*/) 
 {
-  //
+  ///
+
   return *this;
 }
 
@@ -84,7 +87,8 @@ TClonesArray * AliH2F::FindPeaks(Float_t threshold, Float_t noise)
 
 void AliH2F::ClearSpectrum()
 {
-  //clera histogram
+  /// clera histogram
+
   Int_t dimx =  fXaxis.GetNbins();
   Int_t dimy =  fYaxis.GetNbins();
   for (Int_t i = 0 ;i<dimx;i++)
@@ -98,7 +102,8 @@ void AliH2F::ClearSpectrum()
 
 void AliH2F::AddNoise(Float_t sn)
 {
-  // add gauss noise with sigma sn
+  /// add gauss noise with sigma sn
+
   Int_t dimx =  fXaxis.GetNbins();
   Int_t dimy =  fYaxis.GetNbins();
   for (Int_t i = 0 ;i<dimx;i++)
@@ -117,7 +122,8 @@ void AliH2F::AddNoise(Float_t sn)
 void AliH2F::AddGauss(Float_t x, Float_t y, 
 			  Float_t sx, Float_t sy, Float_t max)
 {  
-  //transform to histogram coordinata  
+  /// transform to histogram coordinata
+
   Int_t dimx =  fXaxis.GetNbins();
   Int_t dimy =  fYaxis.GetNbins();
   Float_t dx =(GetXaxis()->GetXmax()-GetXaxis()->GetXmin())/Float_t(dimx);
@@ -144,7 +150,8 @@ void AliH2F::AddGauss(Float_t x, Float_t y,
 
 void AliH2F::ClearUnderTh(Int_t threshold)
 {
-  //clear histogram for bin under threshold
+  /// clear histogram for bin under threshold
+
   Int_t dimx =  fXaxis.GetNbins();
   Int_t dimy =  fYaxis.GetNbins();
   for (Int_t i = 0 ;i<=dimx;i++)
@@ -158,7 +165,8 @@ void AliH2F::ClearUnderTh(Int_t threshold)
 
 void AliH2F::Round()
 {
-  //round float to integer 
+  /// round float to integer
+
   Int_t dimx =  fXaxis.GetNbins();
   Int_t dimy =  fYaxis.GetNbins();
   for (Int_t i = 0 ;i<=dimx;i++)
@@ -175,10 +183,10 @@ void AliH2F::Round()
 AliH2F *AliH2F::GetSubrange2d(Float_t xmin, Float_t xmax, 
 				      Float_t ymin, Float_t ymax)
 {
-  //this function return pointer to the new created 
-  //histogram which is subhistogram of the 
-  //calculate number
-  //subhistogram range must be inside histogram
+  /// this function return pointer to the new created
+  /// histogram which is subhistogram of the
+  /// calculate number
+  /// subhistogram range must be inside histogram
 
   if (xmax<=xmin) {
     xmin=fXaxis.GetXmin();
@@ -223,11 +231,11 @@ AliH2F *AliH2F::GetSubrange2d(Float_t xmin, Float_t xmax,
 TH1F *AliH2F::GetAmplitudes(Float_t zmin, Float_t zmax, Float_t th, Float_t xmin, Float_t xmax, 
 				      Float_t ymin, Float_t ymax)
 {
-  //this function return pointer to the new created 
-  //histogram which is subhistogram of the 
-  //calculate number
-  //subhistogram range must be inside histogram
- 
+  /// this function return pointer to the new created
+  /// histogram which is subhistogram of the
+  /// calculate number
+  /// subhistogram range must be inside histogram
+
   if (xmax<=xmin) {
     xmin=fXaxis.GetXmin();
     xmax=fXaxis.GetXmax();
@@ -266,11 +274,11 @@ TH1F *AliH2F::GetAmplitudes(Float_t zmin, Float_t zmax, Float_t th, Float_t xmin
 Float_t   AliH2F::GetOccupancy(Float_t th , Float_t xmin, Float_t xmax, 
 			     Float_t ymin, Float_t ymax)
 {
-  //this function return pointer to the new created 
-  //histogram which is subhistogram of the 
-  //calculate number
-  //subhistogram range must be inside histogram
- 
+  /// this function return pointer to the new created
+  /// histogram which is subhistogram of the
+  /// calculate number
+  /// subhistogram range must be inside histogram
+
   if (xmax<=xmin) {
     xmin=fXaxis.GetXmin();
     xmax=fXaxis.GetXmax();
diff --git a/TPC/TPCbase/AliH2F.h b/TPC/TPCbase/AliH2F.h
index 552a01159c6..0769db359fc 100644
--- a/TPC/TPCbase/AliH2F.h
+++ b/TPC/TPCbase/AliH2F.h
@@ -5,7 +5,8 @@
 
 /* $Id$ */
 
-// include files and class forward declarations
+/// \class AliH2F
+/// include files and class forward declarations
 
 #include "TH2.h" 
 
@@ -47,7 +48,9 @@ protected:
 
 private:
  
+  /// \cond CLASSIMP
   ClassDef(AliH2F,1)
+  /// \endcond
 };
 
 #endif /*TH2FSMOOTH_H */
diff --git a/TPC/TPCbase/AliSegmentArray.cxx b/TPC/TPCbase/AliSegmentArray.cxx
index 5b7166dad97..5d8b7925849 100644
--- a/TPC/TPCbase/AliSegmentArray.cxx
+++ b/TPC/TPCbase/AliSegmentArray.cxx
@@ -15,11 +15,10 @@
 
 /* $Id$ */
 
-///////////////////////////////////////////////////////////////////////////////
-//                                                                           //
-//  Alice segment manager object                                             //
-//                                                                           //
-///////////////////////////////////////////////////////////////////////////////
+/// \class AliSegmentArray
+///
+///  Alice segment manager object
+
 #include <Riostream.h>
 
 #include <TTree.h>
@@ -40,7 +39,9 @@
 using std::endl;
 using std::cout;
 //_____________________________________________________________________________
+/// \cond CLASSIMP
 ClassImp(AliSegmentArray)
+/// \endcond
   
   AliSegmentArray::AliSegmentArray()
                   :TNamed(),
@@ -68,13 +69,12 @@ AliSegmentArray::AliSegmentArray(const char *classname, Int_t n)
                  fBranch(0),
                  fClass(0) 
 {
-  //
-  //constructor which 
-  // 
-  //  Create an array of objects of classname. The class must inherit from
-  //  AliSegmentID .  The second argument adjust number of entries in 
-  //  the array.
- 
+  /// constructor which
+  ///
+  ///  Create an array of objects of classname. The class must inherit from
+  ///  AliSegmentID .  The second argument adjust number of entries in
+  ///  the array.
+
 
   SetClass(classname);
   if (MakeArray(n)==kFALSE){
@@ -94,22 +94,23 @@ AliSegmentArray::AliSegmentArray(const AliSegmentArray &segment)
                  fClass(0)                                      
                
 {
-  //
-  //copy constructor
-  // to be later implemented
+  /// copy constructor
+  /// to be later implemented
+
 }
 
 AliSegmentArray &AliSegmentArray::operator = (const AliSegmentArray & /*segment*/)
 {
-  //assignment operator
-  //to be later implemented
+  /// assignment operator
+  /// to be later implemented
+
   return (*this);
 }
 
 AliSegmentArray::~AliSegmentArray()
 {
-  //
-  // default destructor
+  /// default destructor
+
   if (fNSegment>0){
     fSegment->Delete();
     delete fSegment;
@@ -125,8 +126,8 @@ AliSegmentArray::~AliSegmentArray()
 
 Bool_t AliSegmentArray::SetClass(const char *classname)
 {
-  //
-  //set class of stored object
+  /// set class of stored object
+
   if ( fClass !=0 ) {
     //delete fClass; not ower of fClass
     fClass = 0;
@@ -164,8 +165,8 @@ Bool_t AliSegmentArray::SetClass(const char *classname)
 
 AliSegmentID * AliSegmentArray::NewSegment()
 {
-  //
-  //create object according class information
+  /// create object according class information
+
   if (fClass==0) return 0;
   AliSegmentID * segment = (AliSegmentID * )fClass->New();
   if (segment == 0) return 0;
@@ -175,9 +176,8 @@ AliSegmentID * AliSegmentArray::NewSegment()
 
 Bool_t AliSegmentArray::AddSegment(AliSegmentID *segment)
 {
-  //
-  // add segment to array
-  //
+  /// add segment to array
+
   if (segment==0) return kFALSE;
   if (fSegment==0) return kFALSE;
   if (fClass==0) return kFALSE;
@@ -193,9 +193,8 @@ Bool_t AliSegmentArray::AddSegment(AliSegmentID *segment)
 
 AliSegmentID * AliSegmentArray::AddSegment(Int_t index)
 {
-  //
-  // add segment to array
-  //
+  /// add segment to array
+
   if (fSegment==0) return 0;
   if (fClass==0) return 0;
   AliSegmentID * segment = NewSegment();
@@ -209,10 +208,10 @@ AliSegmentID * AliSegmentArray::AddSegment(Int_t index)
 
 void AliSegmentArray::ClearSegment(Int_t index)
 {
-  //
-  //remove segment from active memory    
-  //
-  //PH  if ((*fSegment)[index]){
+  /// remove segment from active memory
+  ///
+  /// PH  if ((*fSegment)[index]){
+
   if (fSegment->At(index)){
     //    (*fSegment)[index]->Delete(); //not working for TClonesArray
     //PH    delete (*fSegment)[index]; //because problem with deleting TClonesArray
@@ -224,9 +223,8 @@ void AliSegmentArray::ClearSegment(Int_t index)
 
 Bool_t AliSegmentArray::MakeArray(Int_t n)
 {
-  //
-  //make array of pointers to Segments
-  //
+  /// make array of pointers to Segments
+
   if (fSegment) {
     fSegment->Delete();
     delete fSegment;
@@ -238,7 +236,8 @@ Bool_t AliSegmentArray::MakeArray(Int_t n)
 }
 void AliSegmentArray::MakeTree(TTree* tree)
 {
-             //Make tree with the name
+             /// Make tree with the name
+
   AliSegmentID * psegment = NewSegment();  
   fTree = tree;
   //PH  fBranch = fTree->Branch("Segment",psegment->IsA()->GetName(),&psegment,64000);
@@ -248,7 +247,8 @@ void AliSegmentArray::MakeTree(TTree* tree)
 
 void AliSegmentArray::MakeTree(char *file)
 {
-  //  AliSegmentID  segment;
+  ///  AliSegmentID  segment;
+
   AliSegmentID * psegment = NewSegment();  
   if (fTree) {
     if (fTreeOwner) 
@@ -286,9 +286,8 @@ void AliSegmentArray::MakeTree(char *file)
 
 Bool_t  AliSegmentArray::MakeDictionary(Int_t size)
 {
-  //
-  //create index table for tree
-  //  
+  /// create index table for tree
+
   if (size<1) return kFALSE;
   if (fTreeIndex) delete fTreeIndex;
   fTreeIndex = new TArrayI(); 
@@ -323,7 +322,8 @@ Bool_t AliSegmentArray::ConnectTree(TTree* tree)
 
 Bool_t AliSegmentArray::ConnectTree(const char * treeName)
 {
-  //connect tree from current directory  
+  /// connect tree from current directory
+
   if (fTree){
    if (fTreeOwner) 
     {
@@ -345,10 +345,8 @@ Bool_t AliSegmentArray::ConnectTree(const char * treeName)
 
 AliSegmentID *AliSegmentArray::LoadSegment(Int_t index)
 {
-  //
-  //load segment with index to the memory
-  //
-  //
+  /// load segment with index to the memory
+
   if (fTreeIndex ==0 ) MakeDictionary(3000);
   //firstly try to load dictionary 
   if (fTreeIndex ==0 ) return 0;
@@ -377,10 +375,8 @@ AliSegmentID *AliSegmentArray::LoadSegment(Int_t index)
 }
 AliSegmentID *AliSegmentArray::LoadEntry(Int_t index)
 {
-  //
-  //load segment at position inex in tree  to the memory
-  //
-  //
+  /// load segment at position inex in tree  to the memory
+
   if (fBranch==0) return 0;
   if (index>fTree->GetEntries()) return 0;
   AliSegmentID * s =  NewSegment();
@@ -400,9 +396,8 @@ AliSegmentID *AliSegmentArray::LoadEntry(Int_t index)
 
 void AliSegmentArray::StoreSegment(Int_t index)
 {
-  //
-  //make segment persistent 
-  //
+  /// make segment persistent
+
   const AliSegmentID *  ksegment = (*this)[index];
   if (ksegment == 0 ) return;
   if (fTree==0) MakeTree();
diff --git a/TPC/TPCbase/AliSegmentArray.h b/TPC/TPCbase/AliSegmentArray.h
index dd3957360b4..9f2909c4885 100644
--- a/TPC/TPCbase/AliSegmentArray.h
+++ b/TPC/TPCbase/AliSegmentArray.h
@@ -5,10 +5,10 @@
 
 /* $Id$ */
 
-////////////////////////////////////////////////
-//  Manager class general Alice segment 
-//  segment is for example one pad row in TPC //
-////////////////////////////////////////////////
+/// \class AliSegmentArray
+///
+///  Manager class general Alice segment
+///  segment is for example one pad row in TPC
 
 #include "TNamed.h"
 #include "TError.h"
@@ -52,24 +52,27 @@ public:
 protected:
   AliSegmentArray(const AliSegmentArray &segment); //copy constructor
   AliSegmentArray &operator = (const AliSegmentArray & segment); //assignment operator
-  TObjArray  * fSegment;  //!pointer to array of pointers to segment
-  TArrayI    * fTreeIndex; //!pointers(index) table in tree
-  Int_t      fNSegment; //number of alocated segments   
-  TTree    * fTree;   //!tree with segment objects
-  Bool_t   fTreeOwner;// flag determing the ownership of the fTree
-  TBranch  * fBranch; //!total branch
+  TObjArray  * fSegment;  //!< pointer to array of pointers to segment
+  TArrayI    * fTreeIndex; //!< pointers(index) table in tree
+  Int_t      fNSegment; ///< number of alocated segments
+  TTree    * fTree;   //!< tree with segment objects
+  Bool_t   fTreeOwner;///< flag determing the ownership of the fTree
+  TBranch  * fBranch; //!< total branch
 private: 
-  TClass  *   fClass;    //!class type of included objects 
-  ClassDef(AliSegmentArray,3) 
+  TClass  *   fClass;    //!< class type of included objects
+
+  /// \cond CLASSIMP
+  ClassDef(AliSegmentArray,3)
+  /// \endcond
+
 };
 
 
 
 inline const AliSegmentID*  AliSegmentArray::operator[](Int_t i)
 {
-  //
-  //return segment with given index
-  //
+  /// return segment with given index
+
   if ( (i<0) || (i>=fNSegment)) return 0; 
   return (AliSegmentID *)(fSegment->At(i));
   
@@ -77,9 +80,8 @@ inline const AliSegmentID*  AliSegmentArray::operator[](Int_t i)
 
 inline const AliSegmentID*  AliSegmentArray::At(Int_t i)
 {
-  //
-  //return segment with given index
-  //
+  /// return segment with given index
+
   if ( (i<0) || (i>=fNSegment)) return 0; 
   return (AliSegmentID *)(fSegment->At(i));
 }
diff --git a/TPC/TPCbase/AliSegmentID.cxx b/TPC/TPCbase/AliSegmentID.cxx
index c93259b9b09..f39e81d2f01 100644
--- a/TPC/TPCbase/AliSegmentID.cxx
+++ b/TPC/TPCbase/AliSegmentID.cxx
@@ -15,13 +15,9 @@
 
 /* $Id$ */
 
-///////////////////////////////////////////////////////////////////////////////
-//                                                                           //
-//  Alice  AliSementID   object                                             //
-//                                
-//                                                                           //
-//                                                                          //
-///////////////////////////////////////////////////////////////////////////////
+/// \class AliSegmentID
+///
+///  Alice  AliSementID   object
 
 
 #include "AliSegmentID.h"
diff --git a/TPC/TPCbase/AliSegmentID.h b/TPC/TPCbase/AliSegmentID.h
index 8fd0ea81198..08c3d192101 100644
--- a/TPC/TPCbase/AliSegmentID.h
+++ b/TPC/TPCbase/AliSegmentID.h
@@ -5,10 +5,10 @@
 
 /* $Id$ */
 
-////////////////////////////////////////////////
-//  Manager class generaol Alice segment 
-//  segment is for example one pad row in TPC //
-////////////////////////////////////////////////
+/// \class AliSegmentID
+///
+///  Manager class generaol Alice segment
+///  segment is for example one pad row in TPC
 
 #include "TObject.h"
 
@@ -19,8 +19,9 @@ public:
   Int_t GetID() {return fSegmentID;}
   void  SetID(Int_t index){fSegmentID = index;} 
 protected:
-  Int_t fSegmentID;   //identification number of Segment
-  ClassDef(AliSegmentID,1) 
+  Int_t fSegmentID;   ///< identification number of Segment
+  /// \cond CLASSIMP
+  /// \endcond
 };
    
 #endif //ALISEGMENTID_H
diff --git a/TPC/TPCbase/AliSimDigits.cxx b/TPC/TPCbase/AliSimDigits.cxx
index b51c30415c9..dd3a3559090 100644
--- a/TPC/TPCbase/AliSimDigits.cxx
+++ b/TPC/TPCbase/AliSimDigits.cxx
@@ -13,17 +13,13 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/* $Id$ */
-
-///////////////////////////////////////////////////////////////////////////////
-//                                                                           //
-//  Alice segment manager object                                             //
-//  AliSimDigits object   (derived from AliDigits)                           //
-//  provide additional track information to digit                            //
-//   Origin: Marian Ivanov  GSI Darmstadt                                    //
-//                                                                           //
-//                                                                           //
-///////////////////////////////////////////////////////////////////////////////
+
+/// \class AliSimDigits
+///
+///  Alice segment manager object
+///  AliSimDigits object   (derived from AliDigits)
+///  provide additional track information to digit
+/// \author Marian Ivanov  GSI Darmstadt
 
 #include "TClass.h"
 #include <Riostream.h>
@@ -40,7 +36,9 @@
 //_____________________________________________________________________________
 //_____________________________________________________________________________
 //_____________________________________________________________________________
+/// \cond CLASSIMP
 ClassImp(AliSimDigits)
+/// \endcond
 
 AliSimDigits::AliSimDigits()
              :AliDigits(),
@@ -61,9 +59,8 @@ AliSimDigits::AliSimDigits(const AliSimDigits &param)
 	      fNlevel(0),
 	      fTrBufType(0) 
 {
-  //
-  // dummy
-  //
+  /// dummy
+
   fTrIndex = param.fTrIndex;
 }
 //
@@ -80,9 +77,8 @@ AliSimDigits::~AliSimDigits()
 }
 AliSimDigits & AliSimDigits::operator =(const AliSimDigits & param)
 {
-  //
-  // assignment operator - dummy
-  //
+  /// assignment operator - dummy
+
   if(this!=&param){
     fTrIndex=param.fTrIndex;
   }
@@ -92,8 +88,8 @@ AliSimDigits & AliSimDigits::operator =(const AliSimDigits & param)
 //__________________________________________________________________
 void AliSimDigits::InvalidateTrack() 
 { 
-  //
-  //set default (invalid parameters)
+  /// set default (invalid parameters)
+
   if ( fTracks != 0) delete fTracks;
   fTracks = new TArrayI;
   if ( fTrIndex  != 0) delete fTrIndex;
@@ -107,9 +103,9 @@ void AliSimDigits::InvalidateTrack()
 
 void  AliSimDigits::AllocateTrack(Int_t length)
 {
-  //
-  //construct empty buffer fElements and fTracks with size fNrows x fNcols x
-  //length 
+  /// construct empty buffer fElements and fTracks with size fNrows x fNcols x
+  /// length
+
   InvalidateTrack();
   fNlevel = length;
   fTracks->Set(fNcols*fNrows*fNlevel);
@@ -119,8 +115,8 @@ void  AliSimDigits::AllocateTrack(Int_t length)
 
 Int_t AliSimDigits::GetTrackID(Int_t row, Int_t column, Int_t level) 
 {
-  //
-  //Get track ID 
+  /// Get track ID
+
   if (fTrBufType == 0) return  GetTrackIDFast(row, column,level);
   if (fTrBufType == 1) return  GetTrackID1(row, column,level); 
   if (fTrBufType == 2) return  GetTrackID2(row, column,level); 
@@ -129,8 +125,8 @@ Int_t AliSimDigits::GetTrackID(Int_t row, Int_t column, Int_t level)
 
 void AliSimDigits::ExpandTrackBuffer()
 {  
-  //
-  //expand buffer to two dimensional array 
+  /// expand buffer to two dimensional array
+
   if (fTrBufType<0)  {
     Error("ExpandBuffer", "buffer doesn't exist");
     return;
@@ -143,9 +139,8 @@ void AliSimDigits::ExpandTrackBuffer()
 
 void AliSimDigits::CompresTrackBuffer(Int_t bufType)
 {
-  //
-  //compres buffer according buffertype algorithm
-  //
+  /// compres buffer according buffertype algorithm
+
   if (fTrBufType<0)  {
     Error("CompressBuffer", "buffer doesn't exist");
     return;
@@ -166,7 +161,8 @@ void AliSimDigits::CompresTrackBuffer(Int_t bufType)
 
 Int_t  AliSimDigits::GetTrackID1(Int_t row, Int_t column, Int_t level)
 {
-  //return  track ID of digits - for buffer compresion 2
+  /// return  track ID of digits - for buffer compresion 2
+
   Int_t i,n1,n2;
   i = level*fNcols+column;
   if ( (i+1)>=fTrIndex->fN) n2 = fTracks->fN;
@@ -205,10 +201,9 @@ Int_t  AliSimDigits::GetTrackID1(Int_t row, Int_t column, Int_t level)
 
 void  AliSimDigits::ExpandTrackBuffer1()
 {
-  //
-  //expand  track compressed according algorithm 1 (track id comression independent to the digit compression)
-  // !!in expanded tracks we don't use fTrIndex array
-  //  
+  /// expand  track compressed according algorithm 1 (track id comression independent to the digit compression)
+  /// !!in expanded tracks we don't use fTrIndex array
+
   fTrBufType = 0;
   Int_t i,j;
   Int_t all   = fNrows*fNcols;  //total number of digits
@@ -250,9 +245,8 @@ void  AliSimDigits::ExpandTrackBuffer1()
 
 void  AliSimDigits::CompresTrackBuffer1()
 {
-  //
-  //comress track according algorithm 1 (track id comression independent to the digit compression)
-  //
+  /// comress track according algorithm 1 (track id comression independent to the digit compression)
+
   fTrBufType = 1;  
 
   TArrayI *  buf = new TArrayI;   //create  new buffer 
@@ -344,22 +338,23 @@ void  AliSimDigits::CompresTrackBuffer1()
 
 void  AliSimDigits::ExpandTrackBuffer2()
 {
-  //
-  //comress track according algorithm 2 (track id comression according  digit compression)
+  /// comress track according algorithm 2 (track id comression according  digit compression)
+
   fTrBufType = 0;
 }
 
 void  AliSimDigits::CompresTrackBuffer2()
 {
-  //
-  //comress track according algorithm 2 (track id comression according  digit compression)
+  /// comress track according algorithm 2 (track id comression according  digit compression)
+
   fTrBufType = 2;
 }
 
 
 Int_t  AliSimDigits::GetTrackID2(Int_t /*row*/, Int_t /*column*/, Int_t /*level*/)
 {
-  //returnb track id of digits - for buffer compresion 2
+  /// returnb track id of digits - for buffer compresion 2
+
   return -2;
 }
 
@@ -368,10 +363,10 @@ Int_t  AliSimDigits::GetTrackID2(Int_t /*row*/, Int_t /*column*/, Int_t /*level*
 AliH2F *  AliSimDigits::DrawTracks( const char *option,Int_t level, 
 			      Float_t x1, Float_t x2, Float_t y1, Float_t y2)
 {
-  //
-  //draw digits in given array
-  //  
-  //make digits histo 
+  /// draw digits in given array
+  ///
+  /// make digits histo
+
   char ch[30];
   //sprintf(ch,"Track Segment_%d level %d ",GetID(),level );
   snprintf(ch,30,"Track Segment_%d level %d ",GetID(),level );
@@ -396,10 +391,8 @@ AliH2F *  AliSimDigits::DrawTracks( const char *option,Int_t level,
 }
 
 void AliSimDigits::GlitchFilter(){
-  //
-  //  glitch filter, optionally
-  //
-  
+  ///  glitch filter, optionally
+
   for (Int_t i=0;i<fNcols;i++){ //pads
     for(Int_t j=1;j<fNrows-1;j++){ //time bins
       // first and last time bins are checked separately
diff --git a/TPC/TPCbase/AliSimDigits.h b/TPC/TPCbase/AliSimDigits.h
index 1244b303dd6..6e68994bbb2 100644
--- a/TPC/TPCbase/AliSimDigits.h
+++ b/TPC/TPCbase/AliSimDigits.h
@@ -5,10 +5,11 @@
 
 /* $Id$ */
 
-////////////////////////////////////////////////
-//  Manager class generaol Alice segment digits
-//  segment is for example one pad row in TPC //
-////////////////////////////////////////////////
+/// \class AliSimDigits
+///
+///  Manager class generaol Alice segment digits
+///  segment is for example one pad row in TPC
+
 #include <TError.h>
 #include <TArrayI.h>
 #include <TClonesArray.h>
@@ -45,27 +46,30 @@ private:
   void  ExpandTrackBuffer2(); //comress track according algorithm 2 (track ID comression according  digit compression)
   void  CompresTrackBuffer2(); //comress track according algorithm 2 (track ID comression according  digit compression)
 
-  TArrayI * fTracks;     //buffer of track index 
-  TArrayI * fTrIndex;    //index position of column
-  Int_t       fNlevel;   //number of tracks etries  for one digit
-  Int_t       fTrBufType;  //buffer type of the tracks
+  TArrayI * fTracks;     ///< buffer of track index
+  TArrayI * fTrIndex;    ///< index position of column
+  Int_t       fNlevel;   ///< number of tracks etries  for one digit
+  Int_t       fTrBufType;  ///< buffer type of the tracks
   // Bool_t      ClassError( ); //signalize class error 
+  /// \cond CLASSIMP
   ClassDef(AliSimDigits,3) 
+  /// \endcond
 };
 
 
 
 inline Int_t AliSimDigits::GetTrackIDFast(Int_t row, Int_t column,Int_t level)
 {
-  //
-  //return track ID  at given row and column
-  //  return fTracks[level].At(fTrIndex[level][column]+row); 
+  /// return track ID  at given row and column
+  ///  return fTracks[level].At(fTrIndex[level][column]+row);
+
   return fTracks->At(level*fNrows*fNcols+fNrows*column+row); 
 }
  
 inline void AliSimDigits::SetTrackIDFast(Int_t value,Int_t row, Int_t column,Int_t level)
 {
-  //
+  ///
+
   value+=2;
   //set ID track at given row and collumn
   //  fTracks[level][fTrIndex[level][column]+row]=value; 
diff --git a/TPC/TPCbase/AliTPCAltroMapping.cxx b/TPC/TPCbase/AliTPCAltroMapping.cxx
index 546b3c3c5b0..54b838cc3cc 100644
--- a/TPC/TPCbase/AliTPCAltroMapping.cxx
+++ b/TPC/TPCbase/AliTPCAltroMapping.cxx
@@ -13,9 +13,11 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-// This class handles the mapping of the Altro channels in the TPC
-// The mapping is read from an external mapping files
-// Author: C.Cheshkov
+/// \class AliTPCAltroMapping
+/// This class handles the mapping of the Altro channels in the TPC
+/// The mapping is read from an external mapping files
+///
+/// \author C.Cheshkov
 
 #include "AliTPCAltroMapping.h"
 #include "AliLog.h"
@@ -23,7 +25,9 @@
 //#include <stdlib.h>
 
 
+/// \cond CLASSIMP
 ClassImp(AliTPCAltroMapping)
+/// \endcond
 
 //_____________________________________________________________________________
 AliTPCAltroMapping::AliTPCAltroMapping():
@@ -44,7 +48,8 @@ AliTPCAltroMapping::AliTPCAltroMapping(const char *mappingFile):
   fMaxPad(0),
   fInvMapping(NULL)
 {
-  // Constructor
+  /// Constructor
+
   ReadMapping();
   CloseMappingFile();
 }
@@ -52,16 +57,18 @@ AliTPCAltroMapping::AliTPCAltroMapping(const char *mappingFile):
 //_____________________________________________________________________________
 AliTPCAltroMapping::~AliTPCAltroMapping()
 {
-  // destructor
+  /// destructor
+
   if (fInvMapping) delete [] fInvMapping;
 }
 
 //_____________________________________________________________________________
 Bool_t AliTPCAltroMapping::ReadMapping()
 {
-  // Initalizes the ALTRO mapping from a file
-  // Look at the TPC module for the format of
-  // the mapping file
+  /// Initalizes the ALTRO mapping from a file
+  /// Look at the TPC module for the format of
+  /// the mapping file
+
   if (!fIn) {
     AliFatal("Mapping file has not been opened !");
     return kFALSE;
@@ -106,9 +113,10 @@ Bool_t AliTPCAltroMapping::ReadMapping()
 //_____________________________________________________________________________
 Bool_t AliTPCAltroMapping::CreateInvMapping()
 {
-  // Create the inverse mapping
-  // needed for the simulation of
-  // raw data
+  /// Create the inverse mapping
+  /// needed for the simulation of
+  /// raw data
+
   if (fInvMapping) return kTRUE;
 
   if (!fMapping) {
@@ -138,9 +146,10 @@ Bool_t AliTPCAltroMapping::CreateInvMapping()
 //_____________________________________________________________________________
 Int_t AliTPCAltroMapping::GetHWAddress(Int_t padrow, Int_t pad, Int_t /* sector */)
 {
-  // Get the content of the mapping array
-  // return -1 in case there is no hardware
-  // adress defined for these pad-row and pad
+  /// Get the content of the mapping array
+  /// return -1 in case there is no hardware
+  /// adress defined for these pad-row and pad
+
   if (!fInvMapping) {
     if (!CreateInvMapping()) return -1;
   }
diff --git a/TPC/TPCbase/AliTPCAltroMapping.h b/TPC/TPCbase/AliTPCAltroMapping.h
index c97726b1729..d3be510c319 100644
--- a/TPC/TPCbase/AliTPCAltroMapping.h
+++ b/TPC/TPCbase/AliTPCAltroMapping.h
@@ -3,13 +3,13 @@
 /* Copyright(c) 1998-2003, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-//////////////////////////////////////////////////////////
-// Class used to setup the mapping of hardware adresses //
-// in ALTRO to pad-rows and pad indeces.                //
-// The mapping is defined in an external mapping files  //
-// separately. The class derives from the base altro    //
-// mapping class defined in the RAW package.            //
-//////////////////////////////////////////////////////////
+/// \class AliTPCAltroMapping
+///
+/// Class used to setup the mapping of hardware adresses
+/// in ALTRO to pad-rows and pad indeces.
+/// The mapping is defined in an external mapping files
+/// separately. The class derives from the base altro
+/// mapping class defined in the RAW package.
 
 #include "AliAltroMapping.h"
 
@@ -28,10 +28,10 @@ class AliTPCAltroMapping: public AliAltroMapping {
   virtual Bool_t ReadMapping();
   virtual Bool_t CreateInvMapping();
 
-  Int_t     fMinPadRow;        // Minimum Index of pad-row
-  Int_t     fMaxPadRow;        // Maximum Index of pad-row
-  Int_t     fMaxPad;           // Maximum Index of pad inside row
-  Short_t  *fInvMapping;       //! Inverse of fMapping
+  Int_t     fMinPadRow;        ///< Minimum Index of pad-row
+  Int_t     fMaxPadRow;        ///< Maximum Index of pad-row
+  Int_t     fMaxPad;           ///< Maximum Index of pad inside row
+  Short_t  *fInvMapping;       //!< Inverse of fMapping
 
  private:
 
diff --git a/TPC/TPCbase/AliTPCBoundaryVoltError.cxx b/TPC/TPCbase/AliTPCBoundaryVoltError.cxx
index dfa621ddb00..75d55729af3 100644
--- a/TPC/TPCbase/AliTPCBoundaryVoltError.cxx
+++ b/TPC/TPCbase/AliTPCBoundaryVoltError.cxx
@@ -13,58 +13,35 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-// _________________________________________________________________
-//
-// Begin_Html
-//   <h2> AliTPCBoundaryVoltError class   </h2>       
-//   This class calculates the space point distortions due to residual voltage errors on 
-//   the main boundaries of the TPC. For example, the inner vessel of the TPC is shifted 
-//   by a certain amount, whereas the ROCs on the A side and the C side follow this mechanical 
-//   shift (at the inner vessel) in z direction. This example can be named "conical deformation"
-//   of the TPC field cage (see example below).                    
-//   <p>
-//   The boundary conditions can be set via two arrays (A and C side) which contain the 
-//   residual voltage setting modeling a possible shift or an inhomogeneity on the TPC field 
-//   cage. In order to avoid that the user splits the Central Electrode (CE), the settings for 
-//   the C side is taken from the array on the A side (points: A.6 and A.7). The region betweem
-//    the points is interpolated linearly onto the boundaries.
-//   <p>
-//   The class uses the PoissonRelaxation2D (see AliTPCCorrection) to calculate the resulting 
-//   electrical field inhomogeneities in the (r,z)-plane. Then, the Langevin-integral formalism 
-//   is used to calculate the space point distortions. <br>
-//   Note: This class assumes a homogeneous magnetic field. 
-//   <p>
-//   One has two possibilities when calculating the $dz$ distortions. The resulting distortions 
-//   are purely due to the change of the drift velocity (along with the change of the drift field) 
-//   when the SetROCDisplacement is FALSE. This emulates for example a Gating-Grid Voltage offset 
-//   without moving the ROCs. When the flag is set to TRUE, the ROCs are assumed to be misaligned 
-//   and the corresponding offset in z is added.
-// End_Html
-//
-// Begin_Macro(source)
-//   {
-//   gROOT->SetStyle("Plain"); gStyle->SetPalette(1);
-//   TCanvas *c2 = new TCanvas("cAliTPCBoundaryVoltError","cAliTPCBoundaryVoltError",500,300); 
-//   AliTPCBoundaryVoltError bve;     
-//   Float_t val = 40;// [Volt]; 40V corresponds to 1mm
-//   /* IFC shift, CE follows, ROC follows by factor half */
-//   Float_t boundA[8] = { val, val, val,0,0,0,0,val}; // voltages A-side
-//   Float_t boundC[6] = {-val,-val,-val,0,0,0};       // voltages C-side  
-//   bve.SetBoundariesA(boundA);                                        
-//   bve.SetBoundariesC(boundC);                                        
-//   bve.SetOmegaTauT1T2(-0.32,1,1);
-//   bve.SetROCDisplacement(kTRUE); // include the chamber offset in z when calculating the dz distortions
-//   bve.CreateHistoDRinZR(0)->Draw("surf2"); 
-//   return c2;
-//   } 
-// End_Macro
-//
-// Begin_Html
-//   <p>
-// Date: 01/06/2010 <br>
-// Authors: Jim Thomas, Stefan Rossegger      
-// End_Html 
-// _________________________________________________________________
+/// \class AliTPCBoundaryVoltError
+///
+///   <h2> AliTPCBoundaryVoltError class   </h2>
+///   This class calculates the space point distortions due to residual voltage errors on
+///   the main boundaries of the TPC. For example, the inner vessel of the TPC is shifted
+///   by a certain amount, whereas the ROCs on the A side and the C side follow this mechanical
+///   shift (at the inner vessel) in z direction. This example can be named "conical deformation"
+///   of the TPC field cage (see example below).
+///
+///   The boundary conditions can be set via two arrays (A and C side) which contain the
+///   residual voltage setting modeling a possible shift or an inhomogeneity on the TPC field
+///   cage. In order to avoid that the user splits the Central Electrode (CE), the settings for
+///   the C side is taken from the array on the A side (points: A.6 and A.7). The region betweem
+///    the points is interpolated linearly onto the boundaries.
+///
+///   The class uses the PoissonRelaxation2D (see AliTPCCorrection) to calculate the resulting
+///   electrical field inhomogeneities in the (r,z)-plane. Then, the Langevin-integral formalism
+///   is used to calculate the space point distortions.
+///   Note: This class assumes a homogeneous magnetic field.
+///
+///   One has two possibilities when calculating the $dz$ distortions. The resulting distortions
+///   are purely due to the change of the drift velocity (along with the change of the drift field)
+///   when the SetROCDisplacement is FALSE. This emulates for example a Gating-Grid Voltage offset
+///   without moving the ROCs. When the flag is set to TRUE, the ROCs are assumed to be misaligned
+///   and the corresponding offset in z is added.
+/// ![Picture from ROOT macro](AliTPCBoundaryVoltError_cxx_1511bb7.png)
+///
+/// \author Jim Thomas, Stefan Rossegger
+/// \date 01/06/2010
 
 
 #include "AliMagF.h"
@@ -78,7 +55,9 @@
 #include "AliTPCROC.h"
 #include "AliTPCBoundaryVoltError.h"
 
+/// \cond CLASSIMP
 ClassImp(AliTPCBoundaryVoltError)
+/// \endcond
 
 AliTPCBoundaryVoltError::AliTPCBoundaryVoltError()
   : AliTPCCorrection("BoundaryVoltError","Boundary Voltage Error"),
@@ -96,20 +75,19 @@ AliTPCBoundaryVoltError::AliTPCBoundaryVoltError()
 }
 
 AliTPCBoundaryVoltError::~AliTPCBoundaryVoltError() {
-  //
-  // default destructor
-  //
+  /// default destructor
+
 }
 
 
 
 
 Bool_t AliTPCBoundaryVoltError::AddCorrectionCompact(AliTPCCorrection* corr, Double_t weight){
-  //
-  // Add correction  and make them compact
-  // Assumptions:
-  //  - origin of distortion/correction are additive
-  //  - only correction ot the same type supported ()
+  /// Add correction  and make them compact
+  /// Assumptions:
+  ///  - origin of distortion/correction are additive
+  ///  - only correction ot the same type supported ()
+
   if (corr==NULL) {
     AliError("Zerro pointer - correction");
     return kFALSE;
@@ -135,10 +113,8 @@ Bool_t AliTPCBoundaryVoltError::AddCorrectionCompact(AliTPCCorrection* corr, Dou
 
 
 void AliTPCBoundaryVoltError::Init() {
-  //
-  // Initialization funtion
-  //
-  
+  /// Initialization funtion
+
   AliMagF* magF= (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
   if (!magF) AliError("Magneticd field - not initialized");
   Double_t bzField = magF->SolenoidField()/10.; //field in T
@@ -154,9 +130,8 @@ void AliTPCBoundaryVoltError::Init() {
 }
 
 void AliTPCBoundaryVoltError::Update(const TTimeStamp &/*timeStamp*/) {
-  //
-  // Update function 
-  //
+  /// Update function
+
   AliMagF* magF= (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
   if (!magF) AliError("Magneticd field - not initialized");
   Double_t bzField = magF->SolenoidField()/10.; //field in T
@@ -173,9 +148,7 @@ void AliTPCBoundaryVoltError::Update(const TTimeStamp &/*timeStamp*/) {
 
 
 void AliTPCBoundaryVoltError::GetCorrection(const Float_t x[],const Short_t roc,Float_t dx[]) {
-  //
-  // Calculates the correction due e.g. residual voltage errors on the TPC boundaries
-  //   
+  /// Calculates the correction due e.g. residual voltage errors on the TPC boundaries
 
   if (!fInitLookUp) {
     AliInfo("Lookup table was not initialized!  Perform the inizialisation now ...");
@@ -229,10 +202,8 @@ void AliTPCBoundaryVoltError::GetCorrection(const Float_t x[],const Short_t roc,
 }
 
 void AliTPCBoundaryVoltError::InitBoundaryVoltErrorDistortion() {
-  //
-  // Initialization of the Lookup table which contains the solutions of the 
-  // Dirichlet boundary problem
-  //
+  /// Initialization of the Lookup table which contains the solutions of the
+  /// Dirichlet boundary problem
 
   const Float_t  gridSizeR   =  (fgkOFCRadius-fgkIFCRadius) / (kRows-1) ;
   const Float_t  gridSizeZ   =  fgkTPCZ0 / (kColumns-1) ;
@@ -409,10 +380,8 @@ void AliTPCBoundaryVoltError::InitBoundaryVoltErrorDistortion() {
 }
 
 void AliTPCBoundaryVoltError::Print(const Option_t* option) const {
-  //
-  // Print function to check the settings of the boundary vectors
-  // option=="a" prints the C0 and C1 coefficents for calibration purposes
-  //
+  /// Print function to check the settings of the boundary vectors
+  /// option=="a" prints the C0 and C1 coefficents for calibration purposes
 
   TString opt = option; opt.ToLower();
   printf("%s\n",GetTitle());
@@ -448,18 +417,17 @@ void AliTPCBoundaryVoltError::Print(const Option_t* option) const {
 
 
 void AliTPCBoundaryVoltError::SetBoundariesA(Float_t boundariesA[8]){
-  //
-  // set voltage errors on the TPC boundaries - A side 
-  //
-  // Start at IFC at the Central electrode and work anti-clockwise (clockwise for C side) through 
-  // IFC, ROC, OFC, and CE. The boundary conditions are currently defined to be a linear 
-  // interpolation between pairs of numbers in the Boundary (e.g. fBoundariesA) vector.  
-  // The first pair of numbers represent the beginning and end of the Inner Field cage, etc.
-  // The unit of the error potential vector is [Volt], whereas 1mm shift of the IFC would 
-  // correspond to ~ 40 V
-  // 
-  // Note: The setting for the CE will be passed to the C side!
-  
+  /// set voltage errors on the TPC boundaries - A side
+  ///
+  /// Start at IFC at the Central electrode and work anti-clockwise (clockwise for C side) through
+  /// IFC, ROC, OFC, and CE. The boundary conditions are currently defined to be a linear
+  /// interpolation between pairs of numbers in the Boundary (e.g. fBoundariesA) vector.
+  /// The first pair of numbers represent the beginning and end of the Inner Field cage, etc.
+  /// The unit of the error potential vector is [Volt], whereas 1mm shift of the IFC would
+  /// correspond to ~ 40 V
+  ///
+  /// Note: The setting for the CE will be passed to the C side!
+
   for (Int_t i=0; i<8; i++) {
     fBoundariesA[i]= boundariesA[i];  
     if (i>5) fBoundariesC[i]= -boundariesA[i]; // setting for the CE is passed to C side
@@ -467,17 +435,16 @@ void AliTPCBoundaryVoltError::SetBoundariesA(Float_t boundariesA[8]){
   fInitLookUp=kFALSE;
 }
 void AliTPCBoundaryVoltError::SetBoundariesC(Float_t boundariesC[6]){
-  //
-  // set voltage errors on the TPC boundaries - C side 
-  //
-  // Start at IFC at the Central electrode and work clockwise (for C side) through 
-  // IFC, ROC and OFC. The boundary conditions are currently defined to be a linear 
-  // interpolation between pairs of numbers in the Boundary (e.g. fBoundariesC) vector.  
-  // The first pair of numbers represent the beginning and end of the Inner Field cage, etc.
-  // The unit of the error potential vector is [Volt], whereas 1mm shift of the IFC would 
-  // correspond to ~ 40 V
-  // 
-  // Note: The setting for the CE will be taken from the A side (pos 6 and 7)!
+  /// set voltage errors on the TPC boundaries - C side
+  ///
+  /// Start at IFC at the Central electrode and work clockwise (for C side) through
+  /// IFC, ROC and OFC. The boundary conditions are currently defined to be a linear
+  /// interpolation between pairs of numbers in the Boundary (e.g. fBoundariesC) vector.
+  /// The first pair of numbers represent the beginning and end of the Inner Field cage, etc.
+  /// The unit of the error potential vector is [Volt], whereas 1mm shift of the IFC would
+  /// correspond to ~ 40 V
+  ///
+  /// Note: The setting for the CE will be taken from the A side (pos 6 and 7)!
 
   for (Int_t i=0; i<6; i++) {
     fBoundariesC[i]= boundariesC[i];  
diff --git a/TPC/TPCbase/AliTPCBoundaryVoltError.h b/TPC/TPCbase/AliTPCBoundaryVoltError.h
index b1bf6d33dea..666fb41c1f1 100644
--- a/TPC/TPCbase/AliTPCBoundaryVoltError.h
+++ b/TPC/TPCbase/AliTPCBoundaryVoltError.h
@@ -4,11 +4,12 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-////////////////////////////////////////////////////////////////////////////
-// AliTPCBoundaryVoltError class                                          //
-// date: 01/06/2010                                                       //
-// Authors: Jim Thomas, Stefan Rossegger                                  //
-////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCBoundaryVoltError
+///
+/// AliTPCBoundaryVoltError class
+///
+/// \author Jim Thomas, Stefan Rossegger
+/// \date 01/06/2010
 
 #include "AliTPCCorrection.h"
 
@@ -52,23 +53,25 @@ protected:
   virtual void GetCorrection(const Float_t x[],const Short_t roc,Float_t dx[]);
 
 private:
-  Float_t fC0; // coefficient C0                 (compare Jim Thomas's notes for definitions)
-  Float_t fC1; // coefficient C1                 (compare Jim Thomas's notes for definitions)
-  Float_t  fBoundariesA[8];            // Boundary values on the A side (see Setter function)
-  Float_t  fBoundariesC[8];            // Boundary values on the C side (see Setter function)
+  Float_t fC0; ///< coefficient C0                 (compare Jim Thomas's notes for definitions)
+  Float_t fC1; ///< coefficient C1                 (compare Jim Thomas's notes for definitions)
+  Float_t  fBoundariesA[8];            ///< Boundary values on the A side (see Setter function)
+  Float_t  fBoundariesC[8];            ///< Boundary values on the C side (see Setter function)
 
-  Bool_t fROCdisplacement;      // flag for ROC displacement (important for z distortions)
-  Bool_t fInitLookUp;           // flag to check it the Look Up table was created
+  Bool_t fROCdisplacement;      ///< flag for ROC displacement (important for z distortions)
+  Bool_t fInitLookUp;           ///< flag to check it the Look Up table was created
 
-  Double_t fLookUpErOverEz[kNZ][kNR];  // Array to store electric field integral (int Er/Ez)
-  Double_t fLookUpDeltaEz[kNZ][kNR];   // Array to store electric field integral (int Delta Ez)
+  Double_t fLookUpErOverEz[kNZ][kNR];  ///< Array to store electric field integral (int Er/Ez)
+  Double_t fLookUpDeltaEz[kNZ][kNR];   ///< Array to store electric field integral (int Delta Ez)
 
   // basic numbers for the poisson relaxation //can be set individually in each class
   enum {kRows   =257}; // grid size in r direction used in the poisson relaxation // ( 2**n + 1 ) eg. 65, 129, 257 etc.
   enum {kColumns=257}; // grid size in r direction used in the poisson relaxation // ( 2**m + 1 ) eg. 65, 129, 257 etc.
   enum {kIterations=100}; // Number of iterations within the poisson relaxation 
 
+  /// \cond CLASSIMP
   ClassDef(AliTPCBoundaryVoltError,1); 
+  /// \endcond
 };
 
 #endif
diff --git a/TPC/TPCbase/AliTPCCalPad.cxx b/TPC/TPCbase/AliTPCCalPad.cxx
index 5d478774dde..eec4b609cb2 100644
--- a/TPC/TPCbase/AliTPCCalPad.cxx
+++ b/TPC/TPCbase/AliTPCCalPad.cxx
@@ -15,12 +15,10 @@
 
 /* $Id$ */
 
-///////////////////////////////////////////////////////////////////////////////
-//                                                                           //
-//  TPC calibration class for parameters which are saved per pad             //
-//  Each AliTPCCalPad consists of 72 AliTPCCalROC-objects                    //
-//                                                                           //
-///////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCCalPad
+///
+///  TPC calibration class for parameters which are saved per pad
+///  Each AliTPCCalPad consists of 72 AliTPCCalROC-objects
 
 #include "AliTPCCalPad.h"
 #include "AliTPCCalROC.h"
@@ -47,7 +45,9 @@
 #include <TVirtualPad.h>
 #include "AliTPCPreprocessorOnline.h"
 #include "AliTPCCalibViewer.h"
+/// \cond CLASSIMP
 ClassImp(AliTPCCalPad)
+/// \endcond
 
 //_____________________________________________________________________________
 AliTPCCalPad::AliTPCCalPad():TNamed()
@@ -66,9 +66,8 @@ AliTPCCalPad::AliTPCCalPad():TNamed()
 AliTPCCalPad::AliTPCCalPad(const Text_t *name, const Text_t *title)
                 :TNamed(name,title)
 {
-  //
-  // AliTPCCalPad constructor
-  //
+  /// AliTPCCalPad constructor
+
   for (Int_t isec = 0; isec < kNsec; isec++) {
     fROC[isec] = new AliTPCCalROC(isec);
   }
@@ -78,9 +77,7 @@ AliTPCCalPad::AliTPCCalPad(const Text_t *name, const Text_t *title)
 //_____________________________________________________________________________
 AliTPCCalPad::AliTPCCalPad(const AliTPCCalPad &c):TNamed(c)
 {
-  //
-  // AliTPCCalPad copy constructor
-  //
+  /// AliTPCCalPad copy constructor
 
   for (Int_t isec = 0; isec < kNsec; isec++) {
          fROC[isec] = 0;
@@ -92,9 +89,7 @@ AliTPCCalPad::AliTPCCalPad(const AliTPCCalPad &c):TNamed(c)
 //_____________________________________________________________________________
 AliTPCCalPad::AliTPCCalPad(TObjArray * array):TNamed(array->GetName(),array->GetName())
 {
-  //
-  // AliTPCCalPad default constructor
-  //
+  /// AliTPCCalPad default constructor
 
   for (Int_t isec = 0; isec < kNsec; isec++) {
     fROC[isec] = (AliTPCCalROC *)array->At(isec);
@@ -106,9 +101,7 @@ AliTPCCalPad::AliTPCCalPad(TObjArray * array):TNamed(array->GetName(),array->Get
 ///_____________________________________________________________________________
 AliTPCCalPad::~AliTPCCalPad()
 {
-  //
-  // AliTPCCalPad destructor
-  //
+  /// AliTPCCalPad destructor
 
   for (Int_t isec = 0; isec < kNsec; isec++) {
     if (fROC[isec]) {
@@ -122,9 +115,7 @@ AliTPCCalPad::~AliTPCCalPad()
 //_____________________________________________________________________________
 AliTPCCalPad &AliTPCCalPad::operator=(const AliTPCCalPad &c)
 {
-  //
-  // Assignment operator
-  //
+  /// Assignment operator
 
   if (this != &c) ((AliTPCCalPad &) c).Copy(*this);
   return *this;
@@ -134,9 +125,7 @@ AliTPCCalPad &AliTPCCalPad::operator=(const AliTPCCalPad &c)
 //_____________________________________________________________________________
 void AliTPCCalPad::Copy(TObject &c) const
 {
-  //
-  // Copy function
-  //
+  /// Copy function
 
   for (Int_t isec = 0; isec < kNsec; isec++) {
     if (fROC[isec]) {
@@ -148,11 +137,10 @@ void AliTPCCalPad::Copy(TObject &c) const
 
 
 void AliTPCCalPad::SetCalROC(AliTPCCalROC* roc, Int_t sector){
-   //
-   // Set AliTPCCalROC copies values from 'roc'
-   // if sector == -1 the sector specified in 'roc' is used
-   // else sector specified in 'roc' is ignored and specified sector is filled
-   //
+   /// Set AliTPCCalROC copies values from 'roc'
+   /// if sector == -1 the sector specified in 'roc' is used
+   /// else sector specified in 'roc' is ignored and specified sector is filled
+
    if (sector == -1) sector = roc->GetSector();
    if (!fROC[sector]) fROC[sector] = new AliTPCCalROC(sector);
    for (UInt_t ichannel = 0; ichannel < roc->GetNchannels(); ichannel++) 
@@ -160,9 +148,8 @@ void AliTPCCalPad::SetCalROC(AliTPCCalROC* roc, Int_t sector){
 }
 
 Bool_t  AliTPCCalPad::MedianFilter(Int_t deltaRow, Int_t deltaPad, AliTPCCalPad*outlierPad,  Bool_t doEdge){
-  //
-  // replace constent with median in the neigborhood
-  //
+  /// replace constent with median in the neigborhood
+
   Bool_t isOK=kTRUE;
   for (Int_t isec = 0; isec < kNsec; isec++) {
     AliTPCCalROC *outlierROC=(outlierPad==NULL)?NULL:outlierPad->GetCalROC(isec);
@@ -174,9 +161,8 @@ Bool_t  AliTPCCalPad::MedianFilter(Int_t deltaRow, Int_t deltaPad, AliTPCCalPad*
 }
 
 Bool_t  AliTPCCalPad::LTMFilter(Int_t deltaRow, Int_t deltaPad, Float_t fraction, Int_t type, AliTPCCalPad*outlierPad,  Bool_t doEdge){
-  //
-  // replace constent with LTM statistic  in  neigborhood
-  //
+  /// replace constent with LTM statistic  in  neigborhood
+
   Bool_t isOK=kTRUE;
   for (Int_t isec = 0; isec < kNsec; isec++) {
     AliTPCCalROC *outlierROC=(outlierPad==NULL)?NULL:outlierPad->GetCalROC(isec);
@@ -188,9 +174,8 @@ Bool_t  AliTPCCalPad::LTMFilter(Int_t deltaRow, Int_t deltaPad, Float_t fraction
 }
 
 Bool_t  AliTPCCalPad::Convolute(Double_t sigmaPad, Double_t sigmaRow,  AliTPCCalPad*outlierPad, TF1 *fpad, TF1 *frow){
-  //
-  // replace constent with median in the neigborhood
-  //
+  /// replace constent with median in the neigborhood
+
   Bool_t isOK=kTRUE;
   for (Int_t isec = 0; isec < kNsec; isec++) {
     AliTPCCalROC *outlierROC=(outlierPad==NULL)?NULL:outlierPad->GetCalROC(isec);
@@ -205,9 +190,7 @@ Bool_t  AliTPCCalPad::Convolute(Double_t sigmaPad, Double_t sigmaRow,  AliTPCCal
 //_____________________________________________________________________________
 void AliTPCCalPad::Add(Float_t c1)
 {
-    //
-    // add constant c1 to all channels of all ROCs
-    //
+    /// add constant c1 to all channels of all ROCs
 
     for (Int_t isec = 0; isec < kNsec; isec++) {
 	if (fROC[isec]){
@@ -219,9 +202,8 @@ void AliTPCCalPad::Add(Float_t c1)
 //_____________________________________________________________________________
 void AliTPCCalPad::Multiply(Float_t c1)
 {
-  //
-  // multiply each channel of all ROCs with c1
-  //    
+  /// multiply each channel of all ROCs with c1
+
     for (Int_t isec = 0; isec < kNsec; isec++) {
 	if (fROC[isec]){
 	    fROC[isec]->Multiply(c1);
@@ -232,10 +214,9 @@ void AliTPCCalPad::Multiply(Float_t c1)
 //_____________________________________________________________________________
 void AliTPCCalPad::Add(const AliTPCCalPad * pad, Double_t c1)
 {
-  //
-  // multiply AliTPCCalPad 'pad' by c1 and add each channel to the coresponing channel in all ROCs
-  //  - pad by pad -
-  //
+  /// multiply AliTPCCalPad 'pad' by c1 and add each channel to the coresponing channel in all ROCs
+  ///  - pad by pad -
+
     for (Int_t isec = 0; isec < kNsec; isec++) {
 	if (fROC[isec] && pad->GetCalROC(isec)){
 	    fROC[isec]->Add(pad->GetCalROC(isec),c1);
@@ -246,10 +227,9 @@ void AliTPCCalPad::Add(const AliTPCCalPad * pad, Double_t c1)
 //_____________________________________________________________________________
 void AliTPCCalPad::Multiply(const AliTPCCalPad * pad)
 {
-  //
-  // multiply each channel of all ROCs with the coresponding channel of 'pad'
-  //     - pad by pad -
-  //
+  /// multiply each channel of all ROCs with the coresponding channel of 'pad'
+  ///     - pad by pad -
+
    for (Int_t isec = 0; isec < kNsec; isec++) {
 	if (fROC[isec]){
 	    fROC[isec]->Multiply(pad->GetCalROC(isec));
@@ -260,10 +240,9 @@ void AliTPCCalPad::Multiply(const AliTPCCalPad * pad)
 //_____________________________________________________________________________
 void AliTPCCalPad::Divide(const AliTPCCalPad * pad)
 {
-  //
-  // divide each channel of all ROCs by the coresponding channel of 'pad'
-  //     - pad by pad -
-  //    
+  /// divide each channel of all ROCs by the coresponding channel of 'pad'
+  ///     - pad by pad -
+
     for (Int_t isec = 0; isec < kNsec; isec++) {
 	if (fROC[isec]){
 	    fROC[isec]->Divide(pad->GetCalROC(isec));
@@ -274,9 +253,8 @@ void AliTPCCalPad::Divide(const AliTPCCalPad * pad)
 //_____________________________________________________________________________
 void AliTPCCalPad::Reset()
 {
-  //
-  // Reset all cal Rocs
-  //
+  /// Reset all cal Rocs
+
   for (Int_t isec = 0; isec < kNsec; isec++) {
     if (fROC[isec]){
       fROC[isec]->Reset();
@@ -286,11 +264,10 @@ void AliTPCCalPad::Reset()
 
 //_____________________________________________________________________________
 TGraph  *  AliTPCCalPad::MakeGraph(Int_t type, Float_t ratio){
-  //
-  //   type=1 - mean
-  //        2 - median
-  //        3 - LTM
-  //
+  ///   type=1 - mean
+  ///        2 - median
+  ///        3 - LTM
+
   Int_t npoints = 0;
   for (Int_t i=0;i<72;i++) if (fROC[i]) npoints++;
   TGraph * graph = new TGraph(npoints);
@@ -323,9 +300,8 @@ TGraph  *  AliTPCCalPad::MakeGraph(Int_t type, Float_t ratio){
 //_____________________________________________________________________________
 Double_t AliTPCCalPad::GetMeanRMS(Double_t &rms)
 {
-    //
-    // Calculates mean and RMS of all ROCs
-    //
+    /// Calculates mean and RMS of all ROCs
+
     Double_t sum = 0, sum2 = 0, n=0, val=0;
     for (Int_t isec = 0; isec < kNsec; isec++) {
         AliTPCCalROC *calRoc = fROC[isec];
@@ -351,9 +327,8 @@ Double_t AliTPCCalPad::GetMeanRMS(Double_t &rms)
 //_____________________________________________________________________________
 Double_t AliTPCCalPad::GetMean(AliTPCCalPad* outlierPad)
 {
-    //
-    // return mean of the mean of all ROCs
-    //
+    /// return mean of the mean of all ROCs
+
     Double_t arr[kNsec];
     Int_t n=0;
     for (Int_t isec = 0; isec < kNsec; isec++) {
@@ -371,9 +346,8 @@ Double_t AliTPCCalPad::GetMean(AliTPCCalPad* outlierPad)
 //_____________________________________________________________________________
 Double_t AliTPCCalPad::GetRMS(AliTPCCalPad* outlierPad)
 {
-    //
-    // return mean of the RMS of all ROCs
-    //
+    /// return mean of the RMS of all ROCs
+
     Double_t arr[kNsec];
     Int_t n=0;
     for (Int_t isec = 0; isec < kNsec; isec++) {
@@ -391,9 +365,8 @@ Double_t AliTPCCalPad::GetRMS(AliTPCCalPad* outlierPad)
 //_____________________________________________________________________________
 Double_t AliTPCCalPad::GetMedian(AliTPCCalPad* outlierPad)
 {
-    //
-    // return mean of the median of all ROCs
-    //
+    /// return mean of the median of all ROCs
+
     Double_t arr[kNsec];
     Int_t n=0;
     for (Int_t isec = 0; isec < kNsec; isec++) {
@@ -411,9 +384,8 @@ Double_t AliTPCCalPad::GetMedian(AliTPCCalPad* outlierPad)
 //_____________________________________________________________________________
 Double_t AliTPCCalPad::GetLTM(Double_t *sigma, Double_t fraction, AliTPCCalPad* outlierPad)
 {
-    //
-    // return mean of the LTM and sigma of all ROCs
-    //
+    /// return mean of the LTM and sigma of all ROCs
+
     Double_t arrm[kNsec];
     Double_t arrs[kNsec];
     Double_t *sTemp=0x0;
@@ -435,11 +407,10 @@ Double_t AliTPCCalPad::GetLTM(Double_t *sigma, Double_t fraction, AliTPCCalPad*
 
 //_____________________________________________________________________________
 TH1F * AliTPCCalPad::MakeHisto1D(Float_t min, Float_t max,Int_t type, Int_t side){
-  //
-  // make 1D histo
-  // type -1 = user defined range
-  //       0 = nsigma cut nsigma=min
-  //
+  /// make 1D histo
+  /// type -1 = user defined range
+  ///       0 = nsigma cut nsigma=min
+
   if (type>=0){
     if (type==0){
       // nsigma range
@@ -486,11 +457,10 @@ TH1F * AliTPCCalPad::MakeHisto1D(Float_t min, Float_t max,Int_t type, Int_t side
 
 //_____________________________________________________________________________
 TH2F *AliTPCCalPad::MakeHisto2D(Int_t side){
-  //
-  // Make 2D graph
-  // side  -  specify the side A = 0 C = 1
-  // type  -  used types of determination of boundaries in z
-  //
+  /// Make 2D graph
+  /// side  -  specify the side A = 0 C = 1
+  /// type  -  used types of determination of boundaries in z
+
   Float_t kEpsilon = 0.000000000001;
   TH2F * his = new TH2F(GetName(), GetName(), 250,-250,250,250,-250,250);
   AliTPCROC * roc  = AliTPCROC::Instance(); 
@@ -518,21 +488,19 @@ TH2F *AliTPCCalPad::MakeHisto2D(Int_t side){
 
 
 AliTPCCalPad* AliTPCCalPad::LocalFit(const char* padName, Int_t rowRadius, Int_t padRadius, AliTPCCalPad* PadOutliers, Bool_t robust, Double_t chi2Threshold, Double_t robustFraction, Bool_t printCurrentSector) const {
-   //
-   // Loops over all AliTPCCalROCs and performs a localFit in each ROC
-   // AliTPCCalPad with fit-data is returned
-   // rowRadius and padRadius specifies a window around a given pad in one sector. 
-   // The data of this window are fitted with a parabolic function. 
-   // This function is evaluated at the pad's position.
-   // At the edges the window is shifted, so that the specified pad is not anymore in the center of the window. 
-   // rowRadius  -  radius - rows to be used for smoothing
-   // padradius  -  radius - pads to be used for smoothing
-   // ROCoutlier -  map of outliers - pads not to be used for local smoothing
-   // robust     -  robust method of fitting  - (much slower)
-   // chi2Threshold: Threshold for chi2 when EvalRobust is called
-   // robustFraction: Fraction of data that will be used in EvalRobust
-   //
-   //
+   /// Loops over all AliTPCCalROCs and performs a localFit in each ROC
+   /// AliTPCCalPad with fit-data is returned
+   /// rowRadius and padRadius specifies a window around a given pad in one sector.
+   /// The data of this window are fitted with a parabolic function.
+   /// This function is evaluated at the pad's position.
+   /// At the edges the window is shifted, so that the specified pad is not anymore in the center of the window.
+   /// rowRadius  -  radius - rows to be used for smoothing
+   /// padradius  -  radius - pads to be used for smoothing
+   /// ROCoutlier -  map of outliers - pads not to be used for local smoothing
+   /// robust     -  robust method of fitting  - (much slower)
+   /// chi2Threshold: Threshold for chi2 when EvalRobust is called
+   /// robustFraction: Fraction of data that will be used in EvalRobust
+
    AliTPCCalPad* pad = new AliTPCCalPad(padName, padName);
    for (Int_t isec = 0; isec < 72; isec++){
       if (printCurrentSector) std::cout << "LocalFit in sector " << isec << "\r" << std::flush;
@@ -546,16 +514,15 @@ AliTPCCalPad* AliTPCCalPad::LocalFit(const char* padName, Int_t rowRadius, Int_t
 
 
 AliTPCCalPad* AliTPCCalPad::GlobalFit(const char* padName, AliTPCCalPad* PadOutliers, Bool_t robust, Int_t fitType, Double_t chi2Threshold, Double_t robustFraction, Double_t err, TObjArray *fitParArr, TObjArray *fitCovArr){
-   //
-   // Loops over all AliTPCCalROCs and performs a globalFit in each ROC
-   // AliTPCCalPad with fit-data is returned
-   // chi2Threshold: Threshold for chi2 when EvalRobust is called
-   // robustFraction: Fraction of data that will be used in EvalRobust
-   // chi2Threshold: Threshold for chi2 when EvalRobust is called
-   // robustFraction: Fraction of data that will be used in EvalRobust
-   // err: error of the data points
-   // if fitParArr and/or fitCovArr is given, write fitParameters and/or covariance Matrices into the array
-   //
+   /// Loops over all AliTPCCalROCs and performs a globalFit in each ROC
+   /// AliTPCCalPad with fit-data is returned
+   /// chi2Threshold: Threshold for chi2 when EvalRobust is called
+   /// robustFraction: Fraction of data that will be used in EvalRobust
+   /// chi2Threshold: Threshold for chi2 when EvalRobust is called
+   /// robustFraction: Fraction of data that will be used in EvalRobust
+   /// err: error of the data points
+   /// if fitParArr and/or fitCovArr is given, write fitParameters and/or covariance Matrices into the array
+
    AliTPCCalPad* pad = new AliTPCCalPad(padName, padName);
    TVectorD fitParam(0);
    TMatrixD covMatrix(0,0);
@@ -577,9 +544,7 @@ AliTPCCalPad* AliTPCCalPad::GlobalFit(const char* padName, AliTPCCalPad* PadOutl
 //_____________________________________________________________________________
 TObjArray* AliTPCCalPad::CreateFormulaArray(const char *fitFormula)
 {
-  //
-  // create an array of TFormulas for the each parameter of the fit function
-  //
+  /// create an array of TFormulas for the each parameter of the fit function
 
   // split fit string in single parameters
   // find dimension of the fit:
@@ -608,9 +573,8 @@ TObjArray* AliTPCCalPad::CreateFormulaArray(const char *fitFormula)
 void AliTPCCalPad::EvalFormulaArray(const TObjArray &arrFitFormulas, TVectorD &results,
                                     const Int_t sec, const Int_t row, const Int_t pad)
 {
-  //
-  // evaluate the fit formulas
-  //
+  /// evaluate the fit formulas
+
   Int_t ndim=arrFitFormulas.GetEntries();
   results.ResizeTo(ndim);
   
@@ -628,17 +592,15 @@ void AliTPCCalPad::EvalFormulaArray(const TObjArray &arrFitFormulas, TVectorD &r
 }
 //_____________________________________________________________________________
 void AliTPCCalPad::GlobalSidesFit(const AliTPCCalPad* PadOutliers, const char* fitFormula, TVectorD &fitParamSideA, TVectorD &fitParamSideC,TMatrixD &covMatrixSideA, TMatrixD &covMatrixSideC, Float_t & chi2SideA, Float_t & chi2SideC, AliTPCCalPad *pointError, Bool_t robust, Double_t robustFraction){
-  //
-  // Performs a fit on both sides.
-  // Valid information for the fitFormula are the variables
-  // - gx, gy, lx ,ly: meaning global x, global y, local x, local y value of the padName
-  // - sector:         the sector number.
-  //  eg. a formula might look 'gy' or '(sector<36) ++ gy' or 'gx ++ gy' or 'gx ++ gy ++ lx ++ lx^2' and so on
-  //
-  // PadOutliers - pads with value !=0 are not used in fitting procedure
-  // chi2Threshold: Threshold for chi2 when EvalRobust is called
-  // robustFraction: Fraction of data that will be used in EvalRobust
-  //
+  /// Performs a fit on both sides.
+  /// Valid information for the fitFormula are the variables
+  /// - gx, gy, lx ,ly: meaning global x, global y, local x, local y value of the padName
+  /// - sector:         the sector number.
+  ///  eg. a formula might look 'gy' or '(sector<36) ++ gy' or 'gx ++ gy' or 'gx ++ gy ++ lx ++ lx^2' and so on
+  ///
+  /// PadOutliers - pads with value !=0 are not used in fitting procedure
+  /// chi2Threshold: Threshold for chi2 when EvalRobust is called
+  /// robustFraction: Fraction of data that will be used in EvalRobust
 
   TObjArray* arrFitFormulas=CreateFormulaArray(fitFormula);
   Int_t ndim = arrFitFormulas->GetEntries();
@@ -707,9 +669,8 @@ void AliTPCCalPad::GlobalSidesFit(const AliTPCCalPad* PadOutliers, const char* f
 //
 AliTPCCalPad *AliTPCCalPad::CreateCalPadFit(const char* fitFormula, const TVectorD &fitParamSideA, const TVectorD &fitParamSideC)
 {
-  //
-  //
-  //
+  ///
+
   TObjArray *arrFitFormulas=CreateFormulaArray(fitFormula);
   Int_t ndim = arrFitFormulas->GetEntries();
   //check if dimension of fit formula and fit parameters agree
@@ -745,10 +706,9 @@ AliTPCCalPad *AliTPCCalPad::CreateCalPadFit(const char* fitFormula, const TVecto
 
 
 TCanvas * AliTPCCalPad::MakeReportPadSector(TTree *chain, const char* varName, const char*varTitle, const char *axisTitle, Float_t min, Float_t max, const char *cutUser){
-  //
-  // Make a report - cal pads per sector
-  // mean valeus per sector and local X
-  //
+  /// Make a report - cal pads per sector
+  /// mean valeus per sector and local X
+
   TH1* his=0; 
   TLegend *legend = 0;
   TCanvas *canvas = new TCanvas(Form("Sector: %s",varTitle),Form("Sector: %s",varTitle),1500,1100);
@@ -816,11 +776,10 @@ TCanvas * AliTPCCalPad::MakeReportPadSector(TTree *chain, const char* varName, c
 
 
 TCanvas * AliTPCCalPad::MakeReportPadSector2D(TTree *chain, const char* varName, const char*varTitle, const char *axisTitle, Float_t min, Float_t max, const char *cutUser){
-  //
-  // Make a report - cal pads per sector
-  // 2D view
-  // Input tree should be created using AliPreprocesorOnline before
-  // 
+  /// Make a report - cal pads per sector
+  /// 2D view
+  /// Input tree should be created using AliPreprocesorOnline before
+
   TH1* his=0; 
   TCanvas *canvas = new TCanvas(Form("%s2D",varTitle),Form("%s2D",varTitle),1500,1100);
   canvas->Divide(2);
@@ -864,9 +823,8 @@ TCanvas * AliTPCCalPad::MakeReportPadSector2D(TTree *chain, const char* varName,
 }
 
 void  AliTPCCalPad::Draw(Option_t* option){
-  // 
-  // Draw function - standard 2D view
-  //
+  /// Draw function - standard 2D view
+
   TH1* his=0; 
   TCanvas *canvas = new TCanvas(Form("%s2D",GetTitle()),Form("%s2D",GetTitle()),900,900);
   canvas->Divide(2,2);
@@ -914,9 +872,8 @@ void  AliTPCCalPad::Draw(Option_t* option){
 
 
 AliTPCCalPad * AliTPCCalPad::MakeCalPadFromHistoRPHI(TH2 * hisA, TH2* hisC){
-  //
-  // Make cal pad from r-phi histograms
-  //
+  /// Make cal pad from r-phi histograms
+
   AliTPCROC *proc= AliTPCROC::Instance();
   AliTPCCalPad *calPad = new AliTPCCalPad("his","his");
   Float_t globalPos[3];
@@ -940,9 +897,8 @@ AliTPCCalPad * AliTPCCalPad::MakeCalPadFromHistoRPHI(TH2 * hisA, TH2* hisC){
 }
 
 AliTPCCalPad *AliTPCCalPad::MakePadFromTree(TTree * treePad, const char *query, const char* name, Bool_t doFast){
-  //
-  // make cal pad from the tree 
-  //
+  /// make cal pad from the tree
+
   if (!treePad){
     ::Error("AliTPCCalPad::MakePadFromTree(TTree * treePad, const char *query, const char* name)","Input tree is missing");
     return 0;
@@ -979,9 +935,8 @@ AliTPCCalPad *AliTPCCalPad::MakePadFromTree(TTree * treePad, const char *query,
 }
 
 void AliTPCCalPad::AddFriend(TTree * treePad, const char *friendName, const char *fname){
-  //
-  //
-  //
+  ///
+
   TObjArray *fArray = new TObjArray(1);
   fArray->AddLast(this);
   this->SetName(friendName);
diff --git a/TPC/TPCbase/AliTPCCalPad.h b/TPC/TPCbase/AliTPCCalPad.h
index af89f284eac..4391fd271f0 100644
--- a/TPC/TPCbase/AliTPCCalPad.h
+++ b/TPC/TPCbase/AliTPCCalPad.h
@@ -5,11 +5,9 @@
 
 /* $Id$ */
 
-///////////////////////////////////////////////////////////////////////////////
-//                                                                           //
-//  TPC calibration class for parameters which are saved per pad                 //
-//                                                                           //
-///////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCCalPad
+///
+///  TPC calibration class for parameters which are saved per pad
 
 #include "TNamed.h"
 //#include <TMath.h>
@@ -87,8 +85,10 @@ class AliTPCCalPad : public TNamed {
   static TCanvas * MakeReportPadSector2D(TTree *chain, const char* varName, const char*varTitle, const char *axisTitle, Float_t min, Float_t max, const char *cutUser="");
   static AliTPCCalPad *MakeCalPadFromHistoRPHI(TH2 * hisA, TH2* hisC);
  protected:
-  AliTPCCalROC *fROC[kNsec];                    //  Array of ROC objects which contain the values per pad
+  AliTPCCalROC *fROC[kNsec];                    ///< Array of ROC objects which contain the values per pad
+  /// \cond CLASSIMP
   ClassDef(AliTPCCalPad,1)                      //  TPC calibration class for parameters which are saved per pad
+  /// \endcond
 };
 
 #endif
diff --git a/TPC/TPCbase/AliTPCCalROC.cxx b/TPC/TPCbase/AliTPCCalROC.cxx
index 6c70e40ff97..22960a339e3 100644
--- a/TPC/TPCbase/AliTPCCalROC.cxx
+++ b/TPC/TPCbase/AliTPCCalROC.cxx
@@ -14,17 +14,14 @@
  **************************************************************************/
 
 
-///////////////////////////////////////////////////////////////////////////////
-//                                                                           //
-//     Calibration base class for a single ROC                               //
-//     Contains one float value per pad                                      //
-//     mapping of the pads taken form AliTPCROC                              //
-//                                                                           //
-///////////////////////////////////////////////////////////////////////////////
-
-//
-// ROOT includes 
-//
+/// \class AliTPCCalROC
+///
+///     Calibration base class for a single ROC
+///     Contains one float value per pad
+///     mapping of the pads taken form AliTPCROC
+///
+
+// ROOT includes
 #include "TMath.h"
 #include "TClass.h"
 #include "TFile.h"
@@ -39,7 +36,9 @@
 
 #include "TRandom3.h"      // only needed by the AliTPCCalROCTest() method
 
+/// \cond CLASSIMP
 ClassImp(AliTPCCalROC)
+/// \endcond
 
 
 //_____________________________________________________________________________
@@ -66,9 +65,8 @@ AliTPCCalROC::AliTPCCalROC(UInt_t  sector)
 	      fkIndexes(0),
 	      fData(0)
 {
-  //
-  // Constructor that initializes a given sector
-  //
+  /// Constructor that initializes a given sector
+
   fSector = sector;
   fNChannels    =  AliTPCROC::Instance()->GetNChannels(fSector);
   fNRows        =  AliTPCROC::Instance()->GetNRows(fSector);
@@ -87,9 +85,8 @@ AliTPCCalROC::AliTPCCalROC(const AliTPCCalROC &c)
 	      fkIndexes(0),
 	      fData(0)
 {
-  //
-  // AliTPCCalROC copy constructor
-  //
+  /// AliTPCCalROC copy constructor
+
   fSector = c.fSector;
   fNChannels    =  AliTPCROC::Instance()->GetNChannels(fSector);
   fNRows        =  AliTPCROC::Instance()->GetNRows(fSector);
@@ -101,9 +98,8 @@ AliTPCCalROC::AliTPCCalROC(const AliTPCCalROC &c)
 //____________________________________________________________________________
 AliTPCCalROC & AliTPCCalROC::operator =(const AliTPCCalROC & param)
 {
-  //
-  // assignment operator - dummy
-  //
+  /// assignment operator - dummy
+
   if (this == &param) return (*this);
   fSector       = param.fSector;
   fNChannels    =  AliTPCROC::Instance()->GetNChannels(fSector);
@@ -120,9 +116,8 @@ AliTPCCalROC & AliTPCCalROC::operator =(const AliTPCCalROC & param)
 //_____________________________________________________________________________
 AliTPCCalROC::~AliTPCCalROC()
 {
-  //
-  // AliTPCCalROC destructor
-  //
+  /// AliTPCCalROC destructor
+
   if (fData) {
     delete [] fData;
     fData = 0;
@@ -133,9 +128,8 @@ AliTPCCalROC::~AliTPCCalROC()
 
 void AliTPCCalROC::Streamer(TBuffer &R__b)
 {
-   //
-   // Stream an object of class AliTPCCalROC.
-   //
+   /// Stream an object of class AliTPCCalROC.
+
    if (R__b.IsReading()) {
       AliTPCCalROC::Class()->ReadBuffer(R__b, this);
       fkIndexes =  AliTPCROC::Instance()->GetRowIndexes(fSector);
@@ -148,10 +142,8 @@ void AliTPCCalROC::Streamer(TBuffer &R__b)
 //
 
 Bool_t AliTPCCalROC::MedianFilter(Int_t deltaRow, Int_t deltaPad, AliTPCCalROC* outlierROC,  Bool_t doEdge){
-  //){
-  //
-  //   Modify content of the object - raplace value by median in neighorhood
-  //
+  ///   Modify content of the object - raplace value by median in neighorhood
+
   Float_t *newBuffer=new Float_t[fNChannels] ;
   Double_t *cacheBuffer=new Double_t[fNChannels];
   //
@@ -202,12 +194,9 @@ Bool_t AliTPCCalROC::MedianFilter(Int_t deltaRow, Int_t deltaPad, AliTPCCalROC*
 
 
 Bool_t AliTPCCalROC::LTMFilter(Int_t deltaRow, Int_t deltaPad, Float_t fraction, Int_t type, AliTPCCalROC* outlierROC,  Bool_t doEdge){
-  //){
-  //
-  //
-  // //
-  //   Modify content of the class
-  //   write LTM mean or median
+  ///   Modify content of the class
+  ///   write LTM mean or median
+
   if (fraction<0 || fraction>1) return kFALSE;
   Float_t *newBuffer=new Float_t[fNChannels] ;
   Double_t *cacheBuffer=new Double_t[fNChannels];
@@ -259,9 +248,8 @@ Bool_t AliTPCCalROC::LTMFilter(Int_t deltaRow, Int_t deltaPad, Float_t fraction,
 }
 
 Bool_t  AliTPCCalROC::Convolute(Double_t sigmaPad, Double_t sigmaRow,  AliTPCCalROC*outlierROC, TF1 */*fpad*/, TF1 */*frow*/){
-  //
-  // convolute the calibration with function fpad,frow
-  // in range +-4 sigma
+  /// convolute the calibration with function fpad,frow
+  /// in range +-4 sigma
 
   Float_t *newBuffer=new Float_t[fNChannels] ;
   //
@@ -307,26 +295,23 @@ Bool_t  AliTPCCalROC::Convolute(Double_t sigmaPad, Double_t sigmaRow,  AliTPCCal
 // algebra fuctions:
 
 void AliTPCCalROC::Add(Float_t c1){
-  //
-  // add c1 to each channel of the ROC  
-  //
+  /// add c1 to each channel of the ROC
+
   for (UInt_t  idata = 0; idata< fNChannels; idata++) fData[idata]+=c1;
 }
 
 
 void AliTPCCalROC::Multiply(Float_t c1){
-  //
-  // multiply each channel of the ROC with c1
-  //
+  /// multiply each channel of the ROC with c1
+
   for (UInt_t  idata = 0; idata< fNChannels; idata++) fData[idata]*=c1;
 }
 
 
 void AliTPCCalROC::Add(const AliTPCCalROC * roc, Double_t c1){
-  //
-  // multiply AliTPCCalROC roc by c1 and add each channel to the coresponing channel in the ROC
-  //  - pad by pad 
-  //
+  /// multiply AliTPCCalROC roc by c1 and add each channel to the coresponing channel in the ROC
+  ///  - pad by pad
+
   if (!roc) return;
   for (UInt_t  idata = 0; idata< fNChannels; idata++){
     fData[idata]+=roc->fData[idata]*c1;
@@ -335,10 +320,9 @@ void AliTPCCalROC::Add(const AliTPCCalROC * roc, Double_t c1){
 
 
 void AliTPCCalROC::Multiply(const AliTPCCalROC*  roc) {
-  //
-  // multiply each channel of the ROC with the coresponding channel of 'roc'
-  //     - pad by pad -
-  //
+  /// multiply each channel of the ROC with the coresponding channel of 'roc'
+  ///     - pad by pad -
+
   if (!roc) return;
   for (UInt_t  idata = 0; idata< fNChannels; idata++){
     fData[idata]*=roc->fData[idata];
@@ -347,10 +331,9 @@ void AliTPCCalROC::Multiply(const AliTPCCalROC*  roc) {
 
 
 void AliTPCCalROC::Divide(const AliTPCCalROC*  roc) {
-  //
-  // divide each channel of the ROC by the coresponding channel of 'roc'
-  //     - pad by pad -
-  //
+  /// divide each channel of the ROC by the coresponding channel of 'roc'
+  ///     - pad by pad -
+
   if (!roc) return;
   Float_t kEpsilon=0.00000000000000001;
   for (UInt_t  idata = 0; idata< fNChannels; idata++){
@@ -361,18 +344,16 @@ void AliTPCCalROC::Divide(const AliTPCCalROC*  roc) {
 
 void AliTPCCalROC::Reset()
 {
-  //
-  // reset to ZERO
-  //
+  /// reset to ZERO
+
   memset(fData,0,sizeof(Float_t)*fNChannels); // set all values to 0
 }
 
 Double_t AliTPCCalROC::GetMean(AliTPCCalROC *const outlierROC) const {
-   //
-   //  returns the mean value of the ROC
-   //  pads with value != 0 in outlierROC are not used for the calculation
-   //  return 0 if no data is accepted by the outlier cuts 
-   //
+   ///  returns the mean value of the ROC
+   ///  pads with value != 0 in outlierROC are not used for the calculation
+   ///  return 0 if no data is accepted by the outlier cuts
+
    if (!outlierROC) return TMath::Mean(fNChannels, fData);
    Double_t *ddata = new Double_t[fNChannels];
    Int_t nPoints = 0;
@@ -390,11 +371,10 @@ Double_t AliTPCCalROC::GetMean(AliTPCCalROC *const outlierROC) const {
 }
 
 Double_t AliTPCCalROC::GetMedian(AliTPCCalROC *const outlierROC) const {
-   //
-   //  returns the median value of the ROC
-   //  pads with value != 0 in outlierROC are not used for the calculation
-   //  return 0 if no data is accepted by the outlier cuts 
-   //
+   ///  returns the median value of the ROC
+   ///  pads with value != 0 in outlierROC are not used for the calculation
+   ///  return 0 if no data is accepted by the outlier cuts
+
    if (!outlierROC) return TMath::Median(fNChannels, fData);
    Double_t *ddata = new Double_t[fNChannels];
    Int_t nPoints = 0;
@@ -412,11 +392,10 @@ Double_t AliTPCCalROC::GetMedian(AliTPCCalROC *const outlierROC) const {
 }
 
 Double_t AliTPCCalROC::GetRMS(AliTPCCalROC *const outlierROC) const {
-   //
-   //  returns the RMS value of the ROC
-   //  pads with value != 0 in outlierROC are not used for the calculation
-   //  return 0 if no data is accepted by the outlier cuts 
-   //
+   ///  returns the RMS value of the ROC
+   ///  pads with value != 0 in outlierROC are not used for the calculation
+   ///  return 0 if no data is accepted by the outlier cuts
+
    if (!outlierROC) return TMath::RMS(fNChannels, fData);
    Double_t *ddata = new Double_t[fNChannels];
    Int_t nPoints = 0;
@@ -434,11 +413,10 @@ Double_t AliTPCCalROC::GetRMS(AliTPCCalROC *const outlierROC) const {
 }
 
 Double_t AliTPCCalROC::GetLTM(Double_t *const sigma, Double_t fraction, AliTPCCalROC *const outlierROC){
-  //
-  //  returns the LTM and sigma
-  //  pads with value != 0 in outlierROC are not used for the calculation
-   //  return 0 if no data is accepted by the outlier cuts 
-  //
+  ///  returns the LTM and sigma
+  ///  pads with value != 0 in outlierROC are not used for the calculation
+  ///  return 0 if no data is accepted by the outlier cuts
+
   Double_t *ddata = new Double_t[fNChannels];
   UInt_t nPoints = 0;
   for (UInt_t i=0;i<fNChannels;i++) {
@@ -460,12 +438,11 @@ Double_t AliTPCCalROC::GetLTM(Double_t *const sigma, Double_t fraction, AliTPCCa
 }
 
 TH1F * AliTPCCalROC::MakeHisto1D(Float_t min, Float_t max,Int_t type){
-  //
-  // make 1D histo
-  // type -1 = user defined range
-  //       0 = nsigma cut nsigma=min
-  //       1 = delta cut around median delta=min
-  //
+  /// make 1D histo
+  /// type -1 = user defined range
+  ///       0 = nsigma cut nsigma=min
+  ///       1 = delta cut around median delta=min
+
   if (type>=0){
     if (type==0){
       // nsigma range
@@ -507,12 +484,11 @@ TH1F * AliTPCCalROC::MakeHisto1D(Float_t min, Float_t max,Int_t type){
 
 
 TH2F * AliTPCCalROC::MakeHisto2D(Float_t min, Float_t max,Int_t type){
-  //
-  // make 2D histo
-  // type -1 = user defined range
-  //       0 = nsigma cut nsigma=min
-  //       1 = delta cut around median delta=min
-  //
+  /// make 2D histo
+  /// type -1 = user defined range
+  ///       0 = nsigma cut nsigma=min
+  ///       1 = delta cut around median delta=min
+
   if (type>=0){
     if (type==0){
       // nsigma range
@@ -557,14 +533,13 @@ TH2F * AliTPCCalROC::MakeHisto2D(Float_t min, Float_t max,Int_t type){
 }
 
 TH2F * AliTPCCalROC::MakeHistoOutliers(Float_t delta, Float_t fraction, Int_t type){
-  //
-  // Make Histogram with outliers
-  // mode = 0 - sigma cut used
-  // mode = 1 - absolute cut used
-  // fraction - fraction of values used to define sigma
-  // delta - in mode 0 - nsigma cut
-  //            mode 1 - delta cut
-  //
+  /// Make Histogram with outliers
+  /// mode = 0 - sigma cut used
+  /// mode = 1 - absolute cut used
+  /// fraction - fraction of values used to define sigma
+  /// delta - in mode 0 - nsigma cut
+  ///            mode 1 - delta cut
+
   Double_t sigma;
   Float_t mean  = GetLTM(&sigma,fraction);  
   if (type==0) delta*=sigma; 
@@ -588,9 +563,8 @@ TH2F * AliTPCCalROC::MakeHistoOutliers(Float_t delta, Float_t fraction, Int_t ty
 
 
 void AliTPCCalROC::Draw(Option_t* opt){
-  //
-  // create histogram with values and draw it
-  //
+  /// create histogram with values and draw it
+
   TH1 * his=0; 
   TString option=opt;
   option.ToUpper();
@@ -608,9 +582,7 @@ void AliTPCCalROC::Draw(Option_t* opt){
 
 
 void AliTPCCalROC::Test() {
-  //
-  // example function to show functionality and test AliTPCCalROC
-  //
+  /// example function to show functionality and test AliTPCCalROC
 
   Float_t kEpsilon=0.00001;
   
@@ -744,20 +716,19 @@ void AliTPCCalROC::Test() {
 
 
 AliTPCCalROC * AliTPCCalROC::LocalFit(Int_t rowRadius, Int_t padRadius, AliTPCCalROC* ROCoutliers, Bool_t robust, Double_t chi2Threshold, Double_t robustFraction) {
-  //
-  // MakeLocalFit - smoothing
-  // returns a AliTPCCalROC with smoothed data
-  // rowRadius and padRadius specifies a window around a given pad. 
-  // The data of this window are fitted with a parabolic function. 
-  // This function is evaluated at the pad's position.
-  // At the edges the window is shifted, so that the specified pad is not anymore in the center of the window. 
-  // rowRadius  -  radius - rows to be used for smoothing
-  // padradius  -  radius - pads to be used for smoothing
-  // ROCoutlier -  map of outliers - pads not to be used for local smoothing
-  // robust     -  robust method of fitting  - (much slower)
-  // chi2Threshold: Threshold for chi2 when EvalRobust is called
-  // robustFraction: Fraction of data that will be used in EvalRobust
-  //
+  /// MakeLocalFit - smoothing
+  /// returns a AliTPCCalROC with smoothed data
+  /// rowRadius and padRadius specifies a window around a given pad.
+  /// The data of this window are fitted with a parabolic function.
+  /// This function is evaluated at the pad's position.
+  /// At the edges the window is shifted, so that the specified pad is not anymore in the center of the window.
+  /// rowRadius  -  radius - rows to be used for smoothing
+  /// padradius  -  radius - pads to be used for smoothing
+  /// ROCoutlier -  map of outliers - pads not to be used for local smoothing
+  /// robust     -  robust method of fitting  - (much slower)
+  /// chi2Threshold: Threshold for chi2 when EvalRobust is called
+  /// robustFraction: Fraction of data that will be used in EvalRobust
+
   AliTPCCalROC * xROCfitted = new AliTPCCalROC(fSector);
   TLinearFitter fitterQ(6,"hyp5");
    // TLinearFitter fitterQ(6,"x0++x1++x2++x3++x4++x5");
@@ -772,10 +743,8 @@ AliTPCCalROC * AliTPCCalROC::LocalFit(Int_t rowRadius, Int_t padRadius, AliTPCCa
 
 
 Double_t AliTPCCalROC::GetNeighbourhoodValue(TLinearFitter* fitterQ, Int_t row, Int_t pad, Int_t rRadius, Int_t pRadius, AliTPCCalROC *const ROCoutliers, Bool_t robust, Double_t chi2Threshold, Double_t robustFraction) {
-  //
-  // AliTPCCalROC::GetNeighbourhoodValue - smoothing - PRIVATE
-  // in this function the fit for LocalFit is done
-  //
+  /// AliTPCCalROC::GetNeighbourhoodValue - smoothing - PRIVATE
+  /// in this function the fit for LocalFit is done
 
   fitterQ->ClearPoints();
   TVectorD fitParam(6);
@@ -842,10 +811,9 @@ Double_t AliTPCCalROC::GetNeighbourhoodValue(TLinearFitter* fitterQ, Int_t row,
 
 
 void AliTPCCalROC::GetNeighbourhood(TArrayI* &rowArray, TArrayI* &padArray, Int_t row, Int_t pad, Int_t rRadius, Int_t pRadius) {
-  //
-  // AliTPCCalROC::GetNeighbourhood - PRIVATE
-  // in this function the window for LocalFit is determined
-  //
+  /// AliTPCCalROC::GetNeighbourhood - PRIVATE
+  /// in this function the window for LocalFit is determined
+
   rowArray = new TArrayI((2*rRadius+1)*(2*pRadius+1));
   padArray = new TArrayI((2*rRadius+1)*(2*pRadius+1));
   
@@ -895,16 +863,15 @@ void AliTPCCalROC::GetNeighbourhood(TArrayI* &rowArray, TArrayI* &padArray, Int_
 
 
 void AliTPCCalROC::GlobalFit(const AliTPCCalROC* ROCoutliers, Bool_t robust, TVectorD &fitParam, TMatrixD &covMatrix, Float_t & chi2, Int_t fitType, Double_t chi2Threshold, Double_t robustFraction, Double_t err){
-  //
-  // Makes a  GlobalFit for the given secotr and return fit-parameters, covariance and chi2
-  // The origin of the fit function is the center of the ROC!
-  // fitType == 0: fit plane function
-  // fitType == 1: fit parabolic function
-  // ROCoutliers - pads with value !=0 are not used in fitting procedure
-  // chi2Threshold: Threshold for chi2 when EvalRobust is called
-  // robustFraction: Fraction of data that will be used in EvalRobust
-  // err: error of the data points
-  //
+  /// Makes a  GlobalFit for the given secotr and return fit-parameters, covariance and chi2
+  /// The origin of the fit function is the center of the ROC!
+  /// fitType == 0: fit plane function
+  /// fitType == 1: fit parabolic function
+  /// ROCoutliers - pads with value !=0 are not used in fitting procedure
+  /// chi2Threshold: Threshold for chi2 when EvalRobust is called
+  /// robustFraction: Fraction of data that will be used in EvalRobust
+  /// err: error of the data points
+
   TLinearFitter* fitterG = 0;
   Double_t xx[6];
   
@@ -973,11 +940,10 @@ void AliTPCCalROC::GlobalFit(const AliTPCCalROC* ROCoutliers, Bool_t robust, TVe
 
 
 AliTPCCalROC* AliTPCCalROC::CreateGlobalFitCalROC(TVectorD &fitParam, Int_t sector){
-  //
-  // Create ROC with global fit parameters
-  // The origin of the fit function is the center of the ROC!
-  // loop over all channels, write fit values into new ROC and return it
-  //
+  /// Create ROC with global fit parameters
+  /// The origin of the fit function is the center of the ROC!
+  /// loop over all channels, write fit values into new ROC and return it
+
   Float_t dlx, dly;
   Float_t centerPad[3] = {0};
   Float_t localXY[3] = {0};
diff --git a/TPC/TPCbase/AliTPCCalROC.h b/TPC/TPCbase/AliTPCCalROC.h
index 361b291b8ad..64f5b57101b 100644
--- a/TPC/TPCbase/AliTPCCalROC.h
+++ b/TPC/TPCbase/AliTPCCalROC.h
@@ -5,11 +5,10 @@
 
 /* $Id: AliTPCCalROC.h -1   */
 
-//////////////////////////////////////////////////
-//                                              //
-//  TPC calibration base class for one ROC      //
-//                                              //
-//////////////////////////////////////////////////
+/// \class AliTPCCalROC
+///
+///  TPC calibration base class for one ROC
+
 #include <TObject.h>
 #include <TMath.h>
 #include <AliTPCROC.h>
@@ -72,12 +71,14 @@ class AliTPCCalROC : public TNamed {
   Double_t GetNeighbourhoodValue(TLinearFitter* fitterQ, Int_t row, Int_t pad, Int_t rRadius, Int_t pRadius, AliTPCCalROC *const ROCoutliers, Bool_t robust, Double_t chi2Threshold, Double_t robustFraction);
   void GetNeighbourhood(TArrayI* &rowArray, TArrayI* &padArray, Int_t row, Int_t pad, Int_t rRadius, Int_t pRadius);
   
-  UInt_t     fSector;          // sector number
-  UInt_t     fNChannels;       // number of channels
-  UInt_t     fNRows;           // number of rows
-  const UInt_t* fkIndexes;      //!indexes
-  Float_t  *fData;            //[fNChannels] Data
+  UInt_t     fSector;          ///< sector number
+  UInt_t     fNChannels;       ///< number of channels
+  UInt_t     fNRows;           ///< number of rows
+  const UInt_t* fkIndexes;      //!< indexes
+  Float_t  *fData;            ///< [fNChannels] Data
+  /// \cond CLASSIMP
   ClassDef(AliTPCCalROC,2)    //  TPC ROC calibration class
+  /// \endcond
 
 };
 
diff --git a/TPC/TPCbase/AliTPCCalibCE.cxx b/TPC/TPCbase/AliTPCCalibCE.cxx
index 32befce2b39..fc4071aae11 100644
--- a/TPC/TPCbase/AliTPCCalibCE.cxx
+++ b/TPC/TPCbase/AliTPCCalibCE.cxx
@@ -13,250 +13,237 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/* $Id$ */
-
-////////////////////////////////////////////////////////////////////////////////////////
-//                                                                                    //
-//             Implementation of the TPC Central Electrode calibration                //
-//                                                                                    //
-//   Origin: Jens Wiechula, Marian Ivanov   J.Wiechula@gsi.de, Marian.Ivanov@cern.ch  //
-//                                                                                    //
-////////////////////////////////////////////////////////////////////////////////////////
-//
-//
-// *************************************************************************************
-// *                                Class Description                                  *
-// *************************************************************************************
-//
-/* BEGIN_HTML
- <h4>The AliTPCCalibCE class is used to get calibration data from the Central Electrode
- using laser runs.</h4>
-
- The information retrieved is
- <ul style="list-style-type: square;">
-   <li>Time arrival from the CE</li>
-   <li>Signal width</li>
-   <li>Signal sum</li>
- </ul>
-
-<h4>Overview:</h4>
- <ol style="list-style-type: upper-roman;">
-   <li><a href="#working">Working principle</a></li>
-   <li><a href="#user">User interface for filling data</a></li>
-   <li><a href="#info">Stored information</a></li>
- </ol>
-
- <h3><a name="working">I. Working principle</a></h3>
-
- <h4>Raw laser data is processed by calling one of the ProcessEvent(...) functions
- (see below). These in the end call the Update(...) function.</h4>
-
- <ul style="list-style-type: square;">
-   <li>the Update(...) function:<br />
-       In this function the array fPadSignal is filled with the adc signals between the specified range
-       fFirstTimeBin and fLastTimeBin for the current pad.
-       before going to the next pad the ProcessPad() function is called, which analyses the data for one pad
-       stored in fPadSignal.
-   </li>
-   <ul style="list-style-type: square;">
-   <li>the ProcessPad() function:</li>
-   <ol style="list-style-type: decimal;">
-     <li>Find Pedestal and Noise information</li>
-     <ul style="list-style-type: square;">
-       <li>use database information which has to be set by calling<br />
-           SetPedestalDatabase(AliTPCCalPad *pedestalTPC, AliTPCCalPad *padNoiseTPC)</li>
-       <li>if no information from the pedestal data base
-           is available the informaion is calculated on the fly
-           ( see FindPedestal() function )</li>
-     </ul>
-     <li>Find local maxima of the pad signal</li>
-     <ul style="list-style-type: square;">
-       <li>maxima arise from the laser tracks, the CE and also periodic postpeaks after the CE signal have
-       have been observed ( see FindLocalMaxima(...) )</li>
-     </ul>
-     <li>Find the CE signal information</li>
-     <ul style="list-style-type: square;">
-       <li>to find the position of the CE signal the Tmean information from the previos event is used
-           as the CE signal the local maximum closest to this Tmean is identified</li>
-       <li>calculate  mean = T0, RMS = signal width and Q sum in a range of -4+7 timebins around Q max position
-           the Q sum is scaled by pad area (see FindPulserSignal(...) function)</li>
-     </ul>
-     <li>Fill a temprary array for the T0 information (GetPadTimesEvent(fCurrentSector,kTRUE)) (why see below)</li>
-     <li>Fill the Q sum and RMS values in the histograms (GetHisto[RMS,Q](ROC,kTRUE))</li>
-     </ol>
-   </ul>
- </ul>
-
- <h4>At the end of each event the EndEvent() function is called</h4>
-
- <ul style="list-style-type: square;">
-   <li>the EndEvent() function:</li>
-   <ul style="list-style-type: square;">
-     <li>calculate the mean T0 for side A and side C. Fill T0 histogram with Time0-<Time0 for side[A,C]>
-         This is done to overcome syncronisation problems between the trigger and the fec clock.</li>
-     <li>calculate Mean T for each ROC using the COG aroud the median of the LocalMaxima distribution in one sector</li>
-     <li>calculate Mean Q</li>
-     <li>calculate Global fit parameters for Pol1 and Pol2 fits</li>
-   </ul>
- </ul>
-
- <h4>After accumulating the desired statistics the Analyse() function has to be called.</h4>
-  <ul style="list-style-type: square;">
-  <li>the Analyse() function:</li>
-    <ul style="list-style-type: square;">
-      <li>calculate the mean values of T0, RMS, Q for each pad, using
-          the AliMathBase::GetCOG(...) function</li>
-      <li>fill the calibration storage classes (AliTPCCalROC) for each ROC</li>
-         (The calibration information is stored in the TObjArrays fCalRocArrayT0, fCalRocArrayRMS and fCalRocArrayQ</li>
-    </ul>
-  </ul>
-
- <h3><a name="user">II. User interface for filling data</a></h3>
-
- <h4>To Fill information one of the following functions can be used:</h4>
-
- <ul style="list-style-type: none;">
-  <li> Bool_t ProcessEvent(eventHeaderStruct *event);</li>
-    <ul style="list-style-type: square;">
-      <li>process Date event</li>
-      <li>use AliTPCRawReaderDate and call ProcessEvent(AliRawReader *rawReader)</li>
-    </ul>
-    <br />
-
-  <li> Bool_t ProcessEvent(AliRawReader *rawReader);</li>
-    <ul style="list-style-type: square;">
-      <li>process AliRawReader event</li>
-      <li>use AliTPCRawStream to loop over data and call ProcessEvent(AliTPCRawStream *rawStream)</li>
-    </ul>
-    <br />
-
-  <li> Bool_t ProcessEvent(AliTPCRawStream *rawStream);</li>
-    <ul style="list-style-type: square;">
-      <li>process event from AliTPCRawStream</li>
-      <li>call Update function for signal filling</li>
-    </ul>
-    <br />
-
-  <li> Int_t Update(const Int_t isector, const Int_t iRow, const Int_t
-              iPad,  const Int_t iTimeBin, const Float_t signal);</li>
-    <ul style="list-style-type: square;">
-      <li>directly  fill signal information (sector, row, pad, time bin, pad)
-          to the reference histograms</li>
-    </ul>
- </ul>
-
- <h4>It is also possible to merge two independently taken calibrations using the function</h4>
-
- <ul style="list-style-type: none;">
-  <li> void Merge(AliTPCCalibSignal *sig)</li>
-    <ul style="list-style-type: square;">
-      <li>copy histograms in 'sig' if they do not exist in this instance</li>
-      <li>Add histograms in 'sig' to the histograms in this instance if the allready exist</li>
-      <li>After merging call Analyse again!</li>
-    </ul>
- </ul>
-
-
- <h4>example: filling data using root raw data:</h4>
- <pre> 
- void fillCE(Char_t *filename)
- {
-    rawReader = new AliRawReaderRoot(fileName);
-    if ( !rawReader ) return;
-    AliTPCCalibCE *calib = new AliTPCCalibCE;
-    while (rawReader->NextEvent()){
-      calib->ProcessEvent(rawReader);
-    }
-    calib->Analyse();
-    calib->DumpToFile("CEData.root");
-    delete rawReader;
-    delete calib;
- }
- </pre>
-
- <h3><a name="info">III. What kind of information is stored and how to retrieve it</a></h4>
-
- <h4><a name="info:stored">III.1 Stored information</a></h4>
- <ul style="list-style-type: none;">
-  <li>Histograms:</li>
-  <ul style="list-style-type: none;">
-    <li>For each ROC three TH2S histos 'Reference Histograms'  (ROC channel vs. [Time0, signal width, Q sum])
-        is created when it is filled for the first time (GetHisto[T0,RMS,Q](ROC,kTRUE)). The histos are
-        stored in the TObjArrays fHistoT0Array, fHistoRMSArray and fHistoQArray.</li>
-  </ul>
-  <br />
-
- <li>Calibration Data:</li>
- <ul style="list-style-type: none;">
-      <li>For each ROC three types of calibration data (AliTPCCalROC) is stored: for the mean arrival Time,
-          the signal width and the signal Sum. The AliTPCCalROC objects are stored in the TObjArrays
-          fCalRocArrayT0, fCalRocArrayRMS , fCalRocArrayQ. The object for each roc is created the first time it
-          is accessed (GetCalRoc[T0,RMS,Q](ROC,kTRUE));</li>
- </ul>
- <br />
-
- <li>For each event the following information is stored:</li>
-   
- <ul style="list-style-type: square;">
-   <li>event time ( TVectorD  fVEventTime )</li>
-   <li>event id   ( TVectorD  fVEventNumber )</li>
-   <br />
-   <li>mean arrival time for each ROC                ( TObjArray fTMeanArrayEvent )</li>
-   <li>mean Q for each ROC                           ( TObjArray fQMeanArrayEvent )</li>
-   <li>parameters of a plane fit for each ROC        ( TObjArray fParamArrayEventPol1 )</li>
-   <li>parameters of a 2D parabola fit for each ROC  ( TObjArray fParamArrayEventPol2 )</li>
-  </ul>
- </ul>
-
- <h4><a name="info:retrieve">III.2 Retrieving information</a></h4>
- <ul style="list-style-type: none;">
-  <li>Accessing the 'Reference Histograms' (Time0, signal width and Q sum information pad by pad):</li>
-    <ul style="list-style-type: square;">
-      <li>TH2F *GetHistoT0(Int_t sector);</li>
-      <li>TH2F *GetHistoRMS(Int_t sector);</li>
-      <li>TH2F *GetHistoQ(Int_t sector);</li>
-    </ul>
-    <br />
-    
-  <li>Accessing the calibration storage objects:</li>
-    <ul style="list-style-type: square;">
-      <li>AliTPCCalROC *GetCalRocT0(Int_t sector);   // for the Time0 values</li>
-      <li>AliTPCCalROC *GetCalRocRMS(Int_t sector);  // for the signal width values</li>
-      <li>AliTPCCalROC *GetCalRocQ(Int_t sector);    // for the Q sum values</li>
-    </ul>
-    <br />
-
-  <li>Accessin the event by event information:</li>
-    <ul style="list-style-type: square;">
-      <li>The event by event information can be displayed using the</li>
-      <li>MakeGraphTimeCE(Int_t sector, Int_t xVariable, Int_t fitType, Int_t fitParameter)</li>
-      <li>which creates a graph from the specified variables</li>
-    </ul>
-  </ul>
-  
-  <h4>example for visualisation:</h4>
-  <pre>
-  //if the file "CEData.root" was created using the above example one could do the following:
-  TFile fileCE("CEData.root")
-  AliTPCCalibCE *ce = (AliTPCCalibCE*)fileCE->Get("AliTPCCalibCE");
-  ce->GetCalRocT0(0)->Draw("colz");
-  ce->GetCalRocRMS(0)->Draw("colz");
-
-  //or use the AliTPCCalPad functionality:
-  AliTPCCalPad padT0(ped->GetCalPadT0());
-  AliTPCCalPad padSigWidth(ped->GetCalPadRMS());
-  padT0->MakeHisto2D()->Draw("colz");       //Draw A-Side Time0 Information
-  padSigWidth->MakeHisto2D()->Draw("colz"); //Draw A-Side signal width Information
-
-  //display event by event information:
-  //Draw mean arrival time as a function of the event time for oroc sector A00
-  ce->MakeGraphTimeCE(36, 0, 2)->Draw("alp");
-  //Draw first derivative in local x from a plane fit as a function of the event time for oroc sector A00
-  ce->MakeGraphTimeCE(36, 0, 0, 1)->Draw("alp");  
-  </pre>
-END_HTML */
-//////////////////////////////////////////////////////////////////////////////////////
-
+/// \class AliTPCCalibCE
+/// \brief Implementation of the TPC Central Electrode calibration
+///
+/// \author Jens Wiechula, Marian Ivanov   J.Wiechula@gsi.de, Marian.Ivanov@cern.ch
+///
+/// Class Description
+/// The AliTPCCalibCE class is used to get calibration data from the Central Electrode
+/// using laser runs.
+///
+///  The information retrieved is
+///  <ul style="list-style-type: square;">
+///    <li>Time arrival from the CE</li>
+///    <li>Signal width</li>
+///    <li>Signal sum</li>
+///  </ul>
+///
+/// <h4>Overview:</h4>
+///  <ol style="list-style-type: upper-roman;">
+///    <li><a href="#working">Working principle</a></li>
+///    <li><a href="#user">User interface for filling data</a></li>
+///    <li><a href="#info">Stored information</a></li>
+///  </ol>
+///
+///  <h3><a name="working">I. Working principle</a></h3>
+///
+///  <h4>Raw laser data is processed by calling one of the ProcessEvent(...) functions
+///  (see below). These in the end call the Update(...) function.</h4>
+///
+///  <ul style="list-style-type: square;">
+///    <li>the Update(...) function:<br />
+///        In this function the array fPadSignal is filled with the adc signals between the specified range
+///        fFirstTimeBin and fLastTimeBin for the current pad.
+///        before going to the next pad the ProcessPad() function is called, which analyses the data for one pad
+///        stored in fPadSignal.
+///    </li>
+///    <ul style="list-style-type: square;">
+///    <li>the ProcessPad() function:</li>
+///    <ol style="list-style-type: decimal;">
+///      <li>Find Pedestal and Noise information</li>
+///      <ul style="list-style-type: square;">
+///        <li>use database information which has to be set by calling<br />
+///            SetPedestalDatabase(AliTPCCalPad *pedestalTPC, AliTPCCalPad *padNoiseTPC)</li>
+///        <li>if no information from the pedestal data base
+///            is available the informaion is calculated on the fly
+///            ( see FindPedestal() function )</li>
+///      </ul>
+///      <li>Find local maxima of the pad signal</li>
+///      <ul style="list-style-type: square;">
+///        <li>maxima arise from the laser tracks, the CE and also periodic postpeaks after the CE signal have
+///        have been observed ( see FindLocalMaxima(...) )</li>
+///      </ul>
+///      <li>Find the CE signal information</li>
+///      <ul style="list-style-type: square;">
+///        <li>to find the position of the CE signal the Tmean information from the previos event is used
+///            as the CE signal the local maximum closest to this Tmean is identified</li>
+///        <li>calculate  mean = T0, RMS = signal width and Q sum in a range of -4+7 timebins around Q max position
+///            the Q sum is scaled by pad area (see FindPulserSignal(...) function)</li>
+///      </ul>
+///      <li>Fill a temprary array for the T0 information (GetPadTimesEvent(fCurrentSector,kTRUE)) (why see below)</li>
+///      <li>Fill the Q sum and RMS values in the histograms (GetHisto[RMS,Q](ROC,kTRUE))</li>
+///      </ol>
+///    </ul>
+///  </ul>
+///
+///  <h4>At the end of each event the EndEvent() function is called</h4>
+///
+///  <ul style="list-style-type: square;">
+///    <li>the EndEvent() function:</li>
+///    <ul style="list-style-type: square;">
+///      <li>calculate the mean T0 for side A and side C. Fill T0 histogram with Time0-<Time0 for side[A,C]>
+///          This is done to overcome syncronisation problems between the trigger and the fec clock.</li>
+///      <li>calculate Mean T for each ROC using the COG aroud the median of the LocalMaxima distribution in one sector</li>
+///      <li>calculate Mean Q</li>
+///      <li>calculate Global fit parameters for Pol1 and Pol2 fits</li>
+///    </ul>
+///  </ul>
+///
+///  <h4>After accumulating the desired statistics the Analyse() function has to be called.</h4>
+///   <ul style="list-style-type: square;">
+///   <li>the Analyse() function:</li>
+///     <ul style="list-style-type: square;">
+///       <li>calculate the mean values of T0, RMS, Q for each pad, using
+///           the AliMathBase::GetCOG(...) function</li>
+///       <li>fill the calibration storage classes (AliTPCCalROC) for each ROC</li>
+///          (The calibration information is stored in the TObjArrays fCalRocArrayT0, fCalRocArrayRMS and fCalRocArrayQ</li>
+///     </ul>
+///   </ul>
+///
+///  <h3><a name="user">II. User interface for filling data</a></h3>
+///
+///  <h4>To Fill information one of the following functions can be used:</h4>
+///
+///  <ul style="list-style-type: none;">
+///   <li> Bool_t ProcessEvent(eventHeaderStruct *event);</li>
+///     <ul style="list-style-type: square;">
+///       <li>process Date event</li>
+///       <li>use AliTPCRawReaderDate and call ProcessEvent(AliRawReader *rawReader)</li>
+///     </ul>
+///     <br />
+///
+///   <li> Bool_t ProcessEvent(AliRawReader *rawReader);</li>
+///     <ul style="list-style-type: square;">
+///       <li>process AliRawReader event</li>
+///       <li>use AliTPCRawStream to loop over data and call ProcessEvent(AliTPCRawStream *rawStream)</li>
+///     </ul>
+///     <br />
+///
+///   <li> Bool_t ProcessEvent(AliTPCRawStream *rawStream);</li>
+///     <ul style="list-style-type: square;">
+///       <li>process event from AliTPCRawStream</li>
+///       <li>call Update function for signal filling</li>
+///     </ul>
+///     <br />
+///
+///   <li> Int_t Update(const Int_t isector, const Int_t iRow, const Int_t
+///               iPad,  const Int_t iTimeBin, const Float_t signal);</li>
+///     <ul style="list-style-type: square;">
+///       <li>directly  fill signal information (sector, row, pad, time bin, pad)
+///           to the reference histograms</li>
+///     </ul>
+///  </ul>
+///
+///  <h4>It is also possible to merge two independently taken calibrations using the function</h4>
+///
+///  <ul style="list-style-type: none;">
+///   <li> void Merge(AliTPCCalibSignal *sig)</li>
+///     <ul style="list-style-type: square;">
+///       <li>copy histograms in 'sig' if they do not exist in this instance</li>
+///       <li>Add histograms in 'sig' to the histograms in this instance if the allready exist</li>
+///       <li>After merging call Analyse again!</li>
+///     </ul>
+///  </ul>
+///
+///
+///  <h4>example: filling data using root raw data:</h4>
+///  <pre>
+///  void fillCE(Char_t *filename)
+///  {
+///     rawReader = new AliRawReaderRoot(fileName);
+///     if ( !rawReader ) return;
+///     AliTPCCalibCE *calib = new AliTPCCalibCE;
+///     while (rawReader->NextEvent()){
+///       calib->ProcessEvent(rawReader);
+///     }
+///     calib->Analyse();
+///     calib->DumpToFile("CEData.root");
+///     delete rawReader;
+///     delete calib;
+///  }
+///  </pre>
+///
+///  <h3><a name="info">III. What kind of information is stored and how to retrieve it</a></h4>
+///
+///  <h4><a name="info:stored">III.1 Stored information</a></h4>
+///  <ul style="list-style-type: none;">
+///   <li>Histograms:</li>
+///   <ul style="list-style-type: none;">
+///     <li>For each ROC three TH2S histos 'Reference Histograms'  (ROC channel vs. [Time0, signal width, Q sum])
+///         is created when it is filled for the first time (GetHisto[T0,RMS,Q](ROC,kTRUE)). The histos are
+///         stored in the TObjArrays fHistoT0Array, fHistoRMSArray and fHistoQArray.</li>
+///   </ul>
+///   <br />
+///
+///  <li>Calibration Data:</li>
+///  <ul style="list-style-type: none;">
+///       <li>For each ROC three types of calibration data (AliTPCCalROC) is stored: for the mean arrival Time,
+///           the signal width and the signal Sum. The AliTPCCalROC objects are stored in the TObjArrays
+///           fCalRocArrayT0, fCalRocArrayRMS , fCalRocArrayQ. The object for each roc is created the first time it
+///           is accessed (GetCalRoc[T0,RMS,Q](ROC,kTRUE));</li>
+///  </ul>
+///  <br />
+///
+///  <li>For each event the following information is stored:</li>
+///
+///  <ul style="list-style-type: square;">
+///    <li>event time ( TVectorD  fVEventTime )</li>
+///    <li>event id   ( TVectorD  fVEventNumber )</li>
+///    <br />
+///    <li>mean arrival time for each ROC                ( TObjArray fTMeanArrayEvent )</li>
+///    <li>mean Q for each ROC                           ( TObjArray fQMeanArrayEvent )</li>
+///    <li>parameters of a plane fit for each ROC        ( TObjArray fParamArrayEventPol1 )</li>
+///    <li>parameters of a 2D parabola fit for each ROC  ( TObjArray fParamArrayEventPol2 )</li>
+///   </ul>
+///  </ul>
+///
+///  <h4><a name="info:retrieve">III.2 Retrieving information</a></h4>
+///  <ul style="list-style-type: none;">
+///   <li>Accessing the 'Reference Histograms' (Time0, signal width and Q sum information pad by pad):</li>
+///     <ul style="list-style-type: square;">
+///       <li>TH2F *GetHistoT0(Int_t sector);</li>
+///       <li>TH2F *GetHistoRMS(Int_t sector);</li>
+///       <li>TH2F *GetHistoQ(Int_t sector);</li>
+///     </ul>
+///     <br />
+///
+///   <li>Accessing the calibration storage objects:</li>
+///     <ul style="list-style-type: square;">
+///       <li>AliTPCCalROC *GetCalRocT0(Int_t sector);   // for the Time0 values</li>
+///       <li>AliTPCCalROC *GetCalRocRMS(Int_t sector);  // for the signal width values</li>
+///       <li>AliTPCCalROC *GetCalRocQ(Int_t sector);    // for the Q sum values</li>
+///     </ul>
+///     <br />
+///
+///   <li>Accessin the event by event information:</li>
+///     <ul style="list-style-type: square;">
+///       <li>The event by event information can be displayed using the</li>
+///       <li>MakeGraphTimeCE(Int_t sector, Int_t xVariable, Int_t fitType, Int_t fitParameter)</li>
+///       <li>which creates a graph from the specified variables</li>
+///     </ul>
+///   </ul>
+///
+///   <h4>example for visualisation:</h4>
+///   <pre>
+///   //if the file "CEData.root" was created using the above example one could do the following:
+///   TFile fileCE("CEData.root")
+///   AliTPCCalibCE *ce = (AliTPCCalibCE*)fileCE->Get("AliTPCCalibCE");
+///   ce->GetCalRocT0(0)->Draw("colz");
+///   ce->GetCalRocRMS(0)->Draw("colz");
+///
+///   //or use the AliTPCCalPad functionality:
+///   AliTPCCalPad padT0(ped->GetCalPadT0());
+///   AliTPCCalPad padSigWidth(ped->GetCalPadRMS());
+///   padT0->MakeHisto2D()->Draw("colz");       //Draw A-Side Time0 Information
+///   padSigWidth->MakeHisto2D()->Draw("colz"); //Draw A-Side signal width Information
+///
+///   //display event by event information:
+///   //Draw mean arrival time as a function of the event time for oroc sector A00
+///   ce->MakeGraphTimeCE(36, 0, 2)->Draw("alp");
+///   //Draw first derivative in local x from a plane fit as a function of the event time for oroc sector A00
+///   ce->MakeGraphTimeCE(36, 0, 0, 1)->Draw("alp");
+///   </pre>
 
 //Root includes
 #include <TObjArray.h>
@@ -303,7 +290,9 @@ END_HTML */
 #include "AliCDBEntry.h"
 //date
 #include "event.h"
+/// \cond CLASSIMP
 ClassImp(AliTPCCalibCE)
+/// \endcond
 
 
 AliTPCCalibCE::AliTPCCalibCE() :
@@ -467,11 +456,10 @@ AliTPCCalibCE::AliTPCCalibCE(const AliTPCCalibCE &sig) :
   fArrFitGraphs(0x0),
   fEventInBunch(0)
 {
-  //
-  // AliTPCSignal copy constructor
-  //
+  /// AliTPCSignal copy constructor
+
   for (Int_t i=0;i<1024;++i) fPadSignal[i]=0;
-  
+
   for (Int_t iSec = 0; iSec < 72; ++iSec){
     const AliTPCCalROC *calQ   = (AliTPCCalROC*)sig.fCalRocArrayQ.UncheckedAt(iSec);
     const AliTPCCalROC *calT0  = (AliTPCCalROC*)sig.fCalRocArrayT0.UncheckedAt(iSec);
@@ -553,7 +541,7 @@ AliTPCCalibCE::AliTPCCalibCE(const AliTPCCalibCE &sig) :
   for (Int_t i=0;i<sig.fTimeBursts.GetNrows();++i){
     fTimeBursts[i]=sig.fTimeBursts[i];
   }
-  
+
   for (Int_t i=0;i<14;++i){
     fPeaks[i]=sig.fPeaks[i];
     fPeakWidths[i]=sig.fPeakWidths[i];
@@ -564,7 +552,7 @@ AliTPCCalibCE::AliTPCCalibCE(const AliTPCCalibCE &sig) :
   }
 
   for (Int_t i=0; i<100; ++i) fBinsLastAna[i]=sig.fBinsLastAna[i];
-  
+
 }
 //_____________________________________________________________________
 AliTPCCalibCE::AliTPCCalibCE(const TMap *config) :
@@ -640,9 +628,8 @@ AliTPCCalibCE::AliTPCCalibCE(const TMap *config) :
   fArrFitGraphs(0x0),
   fEventInBunch(0)
 {
-  //
-  // constructor which uses a tmap as input to set some specific parameters
-  //
+  /// constructor which uses a tmap as input to set some specific parameters
+
   SetNameTitle("AliTPCCalibCE","AliTPCCalibCE");
   fFirstTimeBin=650;
   fLastTimeBin=1030;
@@ -670,13 +657,13 @@ AliTPCCalibCE::AliTPCCalibCE(const TMap *config) :
   if (config->GetValue("ProcessOld")) fProcessOld = (Bool_t)((TObjString*)config->GetValue("ProcessOld"))->GetString().Atoi();
   if (config->GetValue("ProcessNew")) fProcessNew = (Bool_t)((TObjString*)config->GetValue("ProcessNew"))->GetString().Atoi();
   if (config->GetValue("AnalyseNew")) fAnalyseNew = (Bool_t)((TObjString*)config->GetValue("AnalyseNew"))->GetString().Atoi();
-  
+
   for (Int_t i=0;i<1024;++i) fPadSignal[i]=0;
   for (Int_t i=0;i<14;++i){
     fPeaks[i]=0;
     fPeakWidths[i]=0;
   }
-  
+
   fParam->Update();
   for (Int_t i=0; i<100; ++i) fBinsLastAna[i]=0;
 }
@@ -684,9 +671,8 @@ AliTPCCalibCE::AliTPCCalibCE(const TMap *config) :
 //_____________________________________________________________________
 AliTPCCalibCE& AliTPCCalibCE::operator = (const  AliTPCCalibCE &source)
 {
-  //
-  // assignment operator
-  //
+  /// assignment operator
+
   if (&source == this) return *this;
   new (this) AliTPCCalibCE(source);
 
@@ -695,35 +681,33 @@ AliTPCCalibCE& AliTPCCalibCE::operator = (const  AliTPCCalibCE &source)
 //_____________________________________________________________________
 AliTPCCalibCE::~AliTPCCalibCE()
 {
-  //
-  // destructor
-  //
-  
+  /// destructor
+
   fCalRocArrayT0.Delete();
   fCalRocArrayT0Err.Delete();
   fCalRocArrayQ.Delete();
   fCalRocArrayRMS.Delete();
   fCalRocArrayOutliers.Delete();
-  
+
   fHistoQArray.Delete();
   fHistoT0Array.Delete();
   fHistoRMSArray.Delete();
-  
+
   fHistoTmean.Delete();
-  
+
   fParamArrayEventPol1.Delete();
   fParamArrayEventPol2.Delete();
   fTMeanArrayEvent.Delete();
   fQMeanArrayEvent.Delete();
-  
+
   fPadTimesArrayEvent.Delete();
   fPadQArrayEvent.Delete();
   fPadRMSArrayEvent.Delete();
   fPadPedestalArrayEvent.Delete();
-  
+
   fArrHnDrift.SetOwner();
   fArrHnDrift.Delete();
-  
+
   if (fArrFitGraphs){
     fArrFitGraphs->SetOwner();
     delete fArrFitGraphs;
@@ -736,11 +720,9 @@ Int_t AliTPCCalibCE::Update(const Int_t icsector,
 				const Int_t icTimeBin,
 				const Float_t csignal)
 {
-  //
-  // Signal filling methode on the fly pedestal and Time offset correction if necessary.
-  // no extra analysis necessary. Assumes knowledge of the signal shape!
-  // assumes that it is looped over consecutive time bins of one pad
-  //
+  /// Signal filling methode on the fly pedestal and Time offset correction if necessary.
+  /// no extra analysis necessary. Assumes knowledge of the signal shape!
+  /// assumes that it is looped over consecutive time bins of one pad
 
   if (!fProcessOld) return 0;
   //temp
@@ -782,24 +764,22 @@ Int_t AliTPCCalibCE::Update(const Int_t icsector,
 void AliTPCCalibCE::ProcessBunch(const Int_t sector, const Int_t row, const Int_t pad,
                   const Int_t length, const UInt_t startTimeBin, const UShort_t* signal)
 {
-  //
-  // new filling method to fill the THnSparse histogram
-  //
+  /// new filling method to fill the THnSparse histogram
 
   //only in new processing mode
   if (!fProcessNew) return;
     //don't use the IROCs and inner part of OROCs
   if (sector<36) return;
-  if (row<40) return;    
+  if (row<40) return;
   //only bunches with reasonable length
   if (length<3||length>10) return;
-  
+
   UShort_t  timeBin    = (UShort_t)startTimeBin;
   //skip first laser layer
   if (timeBin<280) return;
 
   Double_t timeBurst=SetBurstHnDrift();
-  
+
   Int_t cePeak=((sector/18)%2)*7+6;
   //after 1 event setup peak ranges
   if (fEventInBunch==1 && fPeaks[cePeak]==0) {
@@ -810,7 +790,7 @@ void AliTPCCalibCE::ProcessBunch(const Int_t sector, const Int_t row, const Int_
     fHnDrift->GetAxis(4)->SetRangeUser(fHnDrift->GetAxis(4)->GetXmin(),fHnDrift->GetAxis(4)->GetXmax());
     fHnDrift->Reset();
   }
-  
+
   // After the first event only fill every 5th  bin in a row with the CE information
   Int_t padFill=pad;
   if (fEventInBunch==0||(fPeaks[cePeak]>100&&TMath::Abs((Short_t)fPeaks[cePeak]-(Short_t)timeBin)<(Short_t)fPeakWidths[cePeak])){
@@ -821,10 +801,10 @@ void AliTPCCalibCE::ProcessBunch(const Int_t sector, const Int_t row, const Int_
 
   //noise removal
   if (!IsPeakInRange(timeBin+length/2,sector)) return;
-  
+
   Double_t x[kHnBinsDV]={(Double_t)sector,(Double_t)row,
       (Double_t)padFill,(Double_t)timeBin,timeBurst};
-  
+
   for (Int_t iTimeBin = 0; iTimeBin<length; iTimeBin++){
     Float_t sig=(Float_t)signal[iTimeBin];
      // if (fPeaks[6]>900&&timeBin>(fPeaks[6]-20)&&sig<20) continue;
@@ -837,9 +817,7 @@ void AliTPCCalibCE::ProcessBunch(const Int_t sector, const Int_t row, const Int_
 //_____________________________________________________________________
 void AliTPCCalibCE::FindLaserLayers()
 {
-  //
-  // Find the laser layer positoins
-  //
+  /// Find the laser layer positoins
 
   //A-side + C-side
   for (Int_t iside=0;iside<2;++iside){
@@ -851,11 +829,11 @@ void AliTPCCalibCE::FindLaserLayers()
     Int_t maxbin=hproj->GetMaximumBin();
     Double_t binc=hproj->GetBinCenter(maxbin);
     hproj->GetXaxis()->SetRangeUser(binc-5,binc+5);
-  
+
     fPeaks[add+6]=(UShort_t)TMath::Nint(binc);
   //   fPeakWidths[4]=(UShort_t)TMath::Nint(4*hproj->GetRMS()+.5);
     fPeakWidths[add+6]=7;
-  
+
     hproj->GetXaxis()->SetRangeUser(0,maxbin-10);
     TSpectrum s(6);
     s.Search(hproj,2,"goff");
@@ -865,20 +843,20 @@ void AliTPCCalibCE::FindLaserLayers()
       fPeaks[i+add]=(UShort_t)TMath::Nint(s.GetPositionX()[index[i]]);
       fPeakWidths[i+add]=5;
     }
-    
+
     //other peaks
-    
+
 //    Int_t timepos=fPeaks[4]-2*fPeakWidths[4];
 //    Int_t width=100;
-   
+
 //    for (Int_t i=3; i>=0; --i){
 //      hproj->GetXaxis()->SetRangeUser(timepos-width,timepos);
-//      fPeaks[i]=hproj->GetMaximumBin(); 
+//      fPeaks[i]=hproj->GetMaximumBin();
 //      fPeakWidths[i]=(UShort_t)TMath::Nint(10.);
 //      width=250;
 //      timepos=fPeaks[i]-width/2;
 //    }
-  
+
 //    for (Int_t i=add; i<add+7; ++i){
 //      printf("Peak: %u +- %u\n",fPeaks[i],fPeakWidths[i]);
 //    }
@@ -897,10 +875,9 @@ void AliTPCCalibCE::FindLaserLayers()
 //_____________________________________________________________________
 void AliTPCCalibCE::FindPedestal(Float_t part)
 {
-  //
-    // find pedestal and noise for the current pad. Use either database or
-    // truncated mean with part*100%
-  //
+  /// find pedestal and noise for the current pad. Use either database or
+  /// truncated mean with part*100%
+
   Bool_t noPedestal = kTRUE;
 
     //use pedestal database if set
@@ -981,30 +958,29 @@ void AliTPCCalibCE::FindPedestal(Float_t part)
 //_____________________________________________________________________
 void AliTPCCalibCE::UpdateCETimeRef()
 {
-  // Find the time reference of the last valid CE signal in sector
-  // for irocs of the A-Side the reference of the corresponging OROC is returned
-  // the reason are the non reflective bands on the A-Side, which make the reference very uncertain
+  /// Find the time reference of the last valid CE signal in sector
+  /// for irocs of the A-Side the reference of the corresponging OROC is returned
+  /// the reason are the non reflective bands on the A-Side, which make the reference very uncertain
+
   if ( fLastSector == fCurrentSector ) return;
-  Int_t sector=fCurrentSector; 
+  Int_t sector=fCurrentSector;
   if ( sector < 18 ) sector+=36;
   fCurrentCETimeRef=0;
   TVectorF *vtRef = GetTMeanEvents(sector);
-  if ( !vtRef ) return; 
+  if ( !vtRef ) return;
   Int_t vtRefSize= vtRef->GetNrows();
   if ( vtRefSize < fNevents+1 ) vtRef->ResizeTo(vtRefSize+100);
-  else vtRefSize=fNevents; 
+  else vtRefSize=fNevents;
   while ( (*vtRef)[vtRefSize]==0 && vtRefSize>=0 ) --vtRefSize;
   fCurrentCETimeRef=(*vtRef)[vtRefSize];
-  AliDebug(3,Form("Sector: %02d - T0 ref: %.2f",fCurrentSector,fCurrentCETimeRef)); 
-} 
+  AliDebug(3,Form("Sector: %02d - T0 ref: %.2f",fCurrentSector,fCurrentCETimeRef));
+}
 //_____________________________________________________________________
 void AliTPCCalibCE::FindCESignal(TVectorD &param, Float_t &qSum, const TVectorF maxima)
 {
-  //
-    //  Find position, signal width and height of the CE signal (last signal)
-    //  param[0] = Qmax, param[1] = mean time, param[2] = rms;
-    //  maxima: array of local maxima of the pad signal use the one closest to the mean CE position
-  //
+  ///  Find position, signal width and height of the CE signal (last signal)
+  ///  param[0] = Qmax, param[1] = mean time, param[2] = rms;
+  ///  maxima: array of local maxima of the pad signal use the one closest to the mean CE position
 
   Float_t ceQmax  =0, ceQsum=0, ceTime=0, ceRMS=0;
   Int_t   cemaxpos       = 0;
@@ -1048,7 +1024,7 @@ void AliTPCCalibCE::FindCESignal(TVectorD &param, Float_t &qSum, const TVectorF
   //                                the pick-up signal should scale with the pad area. In addition
   //                                the signal should decrease with the wire distance (4mm in IROC, 6mm in OROC),
   //                                ratio 2/3. The pad area we express in cm2. We normalise the signal
-  //                                to the OROC signal (factor 2/3 for the IROCs).  
+  //                                to the OROC signal (factor 2/3 for the IROCs).
     Float_t norm = fParam->GetPadPitchWidth(fCurrentSector)*fParam->GetPadPitchLength(fCurrentSector,fCurrentRow);
     if ( fCurrentSector<fParam->GetNInnerSector() ) norm*=3./2.;
 
@@ -1062,17 +1038,16 @@ void AliTPCCalibCE::FindCESignal(TVectorD &param, Float_t &qSum, const TVectorF
     ceQsum=0;
   }
   param[0] = ceQmax;
-  param[1] = ceTime; 
+  param[1] = ceTime;
   param[2] = ceRMS;
   qSum     = ceQsum;
 }
 //_____________________________________________________________________
 Bool_t AliTPCCalibCE::IsPeak(Int_t pos, Int_t tminus, Int_t tplus) const
 {
-  //
-  // Check if 'pos' is a Maximum. Consider 'tminus' timebins before
-  // and 'tplus' timebins after 'pos'
-  //
+  /// Check if 'pos' is a Maximum. Consider 'tminus' timebins before
+  /// and 'tplus' timebins after 'pos'
+
   if ( (pos-tminus)<fFirstTimeBin || (pos+tplus)>fLastTimeBin ) return kFALSE;
   for (Int_t iTime = pos; iTime>pos-tminus; --iTime)
     if ( fPadSignal[iTime-1] >= fPadSignal[iTime] ) return kFALSE;
@@ -1086,12 +1061,11 @@ Bool_t AliTPCCalibCE::IsPeak(Int_t pos, Int_t tminus, Int_t tplus) const
 //_____________________________________________________________________
 void AliTPCCalibCE::FindLocalMaxima(TVectorF &maxima)
 {
-  //
-    // Find local maxima on the pad signal and Histogram them
-  //
+  /// Find local maxima on the pad signal and Histogram them
+
   Float_t ceThreshold = fNoiseThresholdMax*TMath::Max(fPadNoise,Float_t(1.));  // threshold for the signal
   Int_t   count       = 0;
-  
+
   for (Int_t i=fLastTimeBin-fPeakDetPlus+1; i>=fFirstTimeBin+fPeakDetMinus; --i){
     if ( (fPadSignal[i]-fPadPedestal)<ceThreshold ) continue;
     if (IsPeak(i,fPeakDetMinus,fPeakDetPlus) ){
@@ -1106,53 +1080,53 @@ void AliTPCCalibCE::FindLocalMaxima(TVectorF &maxima)
 //_____________________________________________________________________
 void AliTPCCalibCE::ProcessPad()
 {
-  //
-  //  Process data of current pad
-  //
+  ///  Process data of current pad
+
   FindPedestal();
-  
+
   TVectorF maxima(15);     // the expected maximum number of maxima in the complete TPC should be 8 laser beam layers
                              // + central electrode and possibly post peaks from the CE signal
                              // however if we are on a high noise pad a lot more peaks due to the noise might occur
   FindLocalMaxima(maxima);
   if ( (fNevents == 0) || (fOldRunNumber!=fRunNumber) ) return;  // return because we don't have Time0 info for the CE yet
-  
+
   UpdateCETimeRef();                       // update the time refenrence for the current sector
   if ( fCurrentCETimeRef<1e-30 ) return;      //return if we don't have time 0 info, eg if only one side has laser
   TVectorD param(3);
   Float_t  qSum;
   FindCESignal(param, qSum, maxima);
-  
+
   Double_t meanT  = param[1];
   Double_t sigmaT = param[2];
-  
+
     //Fill Event T0 counter
   (*GetPadTimesEvent(fCurrentSector,kTRUE)).GetMatrixArray()[fCurrentChannel] = meanT;
-  
+
     //Fill Q histogram
   GetHistoQ(fCurrentSector,kTRUE)->Fill( TMath::Sqrt(qSum), fCurrentChannel );
-  
+
     //Fill RMS histogram
   GetHistoRMS(fCurrentSector,kTRUE)->Fill( sigmaT, fCurrentChannel );
-  
-  
+
+
     //Fill debugging info
   if ( GetStreamLevel()>0 ){
     (*GetPadPedestalEvent(fCurrentSector,kTRUE)).GetMatrixArray()[fCurrentChannel]=fPadPedestal;
     (*GetPadRMSEvent(fCurrentSector,kTRUE)).GetMatrixArray()[fCurrentChannel]=sigmaT;
     (*GetPadQEvent(fCurrentSector,kTRUE)).GetMatrixArray()[fCurrentChannel]=qSum;
   }
-  
+
   ResetPad();
 }
 //_____________________________________________________________________
 void AliTPCCalibCE::EndEvent()
 {
-  //  Process data of current pad
-  //  The Functions 'SetTimeStamp' and 'SetRunNumber'  should be called
-  //  before the EndEvent function to set the event timestamp and number!!!
-  //  This is automatically done if the ProcessEvent(AliRawReader *rawReader)
-  //  function was called
+  ///  Process data of current pad
+  ///  The Functions 'SetTimeStamp' and 'SetRunNumber'  should be called
+  ///  before the EndEvent function to set the event timestamp and number!!!
+  ///  This is automatically done if the ProcessEvent(AliRawReader *rawReader)
+  ///  function was called
+
   if (!fProcessOld) {
     if (fProcessNew){
       ++fNevents;
@@ -1160,7 +1134,7 @@ void AliTPCCalibCE::EndEvent()
     }
     return;
   }
-  
+
   //check if last pad has allready been processed, if not do so
   if ( fMaxTimeBin>-1 ) ProcessPad();
 
@@ -1201,7 +1175,7 @@ void AliTPCCalibCE::EndEvent()
       AliDebug(3,Form("Skipping sec. '%02d': Not enough statistics\n",iSec));
       continue;
     }
-    
+
     Double_t entries = hMeanT->GetEffectiveEntries();
     Double_t sum     = 0;
     Short_t *arr     = hMeanT->GetArray()+1;
@@ -1216,7 +1190,7 @@ void AliTPCCalibCE::EndEvent()
     if ( firstBin<fFirstTimeBin ) firstBin=fFirstTimeBin;
     if ( lastBin>fLastTimeBin   ) lastBin =fLastTimeBin;
     Float_t median =AliMathBase::GetCOG(arr+ibin-delta,2*delta,firstBin,lastBin);
-    
+
 	// check boundaries for ebye info of mean time
     TVectorF *vMeanTime=GetTMeanEvents(iSec,kTRUE);
     Int_t vSize=vMeanTime->GetNrows();
@@ -1232,27 +1206,27 @@ void AliTPCCalibCE::EndEvent()
     }
     fVTime0SideA.GetMatrixArray()[fNevents]=time0Side[0];
     fVTime0SideC.GetMatrixArray()[fNevents]=time0Side[1];
-    
+
     vMeanTime->GetMatrixArray()[fNevents]=median;
     nSecMeanT++;
     // end find median
-    
+
     TVectorF *vTimes = GetPadTimesEvent(iSec);
     if ( !vTimes ) continue;                     //continue if no time information for this sector is available
-    
+
     AliTPCCalROC calIrocOutliers(0);
     AliTPCCalROC calOrocOutliers(36);
-    
+
     // calculate mean Q of the sector
     TVectorF *vMeanQ=GetQMeanEvents(iSec,kTRUE);
     vSize=vMeanQ->GetNrows();
     if ( vSize < fNevents+1 ){
       vMeanQ->ResizeTo(vSize+100);
-    }   
+    }
     Float_t meanQ = 0;
     if ( fVMeanQCounter.GetMatrixArray()[iSec]>0 ) meanQ=fVMeanQ.GetMatrixArray()[iSec]/fVMeanQCounter.GetMatrixArray()[iSec];
     vMeanQ->GetMatrixArray()[fNevents]=meanQ;
-   
+
     for ( UInt_t iChannel=0; iChannel<fROC->GetNChannels(iSec); ++iChannel ){
       Float_t time  = (*vTimes).GetMatrixArray()[iChannel];
 
@@ -1267,7 +1241,7 @@ void AliTPCCalibCE::EndEvent()
       }
 
       if ( (fNevents>0) && (fOldRunNumber==fRunNumber) )
-        // test that we really found the CE signal reliably 
+        // test that we really found the CE signal reliably
         if ( TMath::Abs(fVTime0SideA.GetMatrixArray()[fNevents-1]-time0Side[0])<.05)
           GetHistoT0(iSec,kTRUE)->Fill( time-time0Side[(iSec/18)%2],iChannel );
 
@@ -1280,17 +1254,17 @@ void AliTPCCalibCE::EndEvent()
           Int_t row=0;
           Int_t pad=0;
           Int_t padc=0;
-          
+
           Float_t q   = (*GetPadQEvent(iSec))[iChannel];
           Float_t rms = (*GetPadRMSEvent(iSec))[iChannel];
-          
+
           UInt_t channel=iChannel;
           Int_t sector=iSec;
-          
+
           while ( channel > (fROC->GetRowIndexes(sector)[row]+fROC->GetNPads(sector,row)-1) ) row++;
           pad = channel-fROC->GetRowIndexes(sector)[row];
           padc = pad-(fROC->GetNPads(sector,row)/2);
-          
+
 //		TH1F *h1 = new TH1F(Form("hSignalD%d.%d.%d",sector,row,pad),
 //				    Form("hSignalD%d.%d.%d",sector,row,pad),
 //				    fLastTimeBin-fFirstTimeBin,
@@ -1299,7 +1273,7 @@ void AliTPCCalibCE::EndEvent()
         //
 //		for (Int_t i=fFirstTimeBin; i<fLastTimeBin+1; ++i)
 //		    h1->Fill(i,fPadSignal(i));
-          
+
           Double_t t0Sec = 0;
           if (fVTime0OffsetCounter.GetMatrixArray()[iSec]>0)
             t0Sec = fVTime0Offset.GetMatrixArray()[iSec]/fVTime0OffsetCounter.GetMatrixArray()[iSec];
@@ -1321,7 +1295,7 @@ void AliTPCCalibCE::EndEvent()
             "MeanQ=" << meanQ <<
         //		    "hist.=" << h1 <<
             "\n";
-          
+
     //		delete h1;
         }
       }
@@ -1337,7 +1311,7 @@ void AliTPCCalibCE::EndEvent()
       TMatrixD matPol2(6,6);
       Float_t  chi2Pol1=0;
       Float_t  chi2Pol2=0;
-      
+
       if ( (fNevents>0) && (fOldRunNumber==fRunNumber) ){
         if ( iSec < 36 ){
           calIroc->GlobalFit(&calIrocOutliers,0,paramPol1,matPol1,chi2Pol1,0);
@@ -1346,11 +1320,11 @@ void AliTPCCalibCE::EndEvent()
           calOroc->GlobalFit(&calOrocOutliers,0,paramPol1,matPol1,chi2Pol1,0);
           calOroc->GlobalFit(&calOrocOutliers,0,paramPol2,matPol2,chi2Pol2,1);
         }
-        
+
         GetParamArrayPol1(iSec,kTRUE)->AddAtAndExpand(new TVectorD(paramPol1), fNevents);
         GetParamArrayPol2(iSec,kTRUE)->AddAtAndExpand(new TVectorD(paramPol2), fNevents);
       }
-      
+
   //-------------------------------  Debug start  ------------------------------
       if ( GetStreamLevel()>0 ){
         TTreeSRedirector *streamer=GetDebugStreamer();
@@ -1377,8 +1351,8 @@ void AliTPCCalibCE::EndEvent()
   }// end sector loop
     //return if no sector has a valid mean time
   if ( nSecMeanT == 0 ) return;
-    
-    
+
+
 //    fTMeanArrayEvent.AddAtAndExpand(new TVectorF(vMeanTime),fNevents);
 //    fQMeanArrayEvent.AddAtAndExpand(new TVectorF(vMeanQ),fNevents);
   if ( fVEventTime.GetNrows() < fNevents+1 ) {
@@ -1401,10 +1375,9 @@ TH2S* AliTPCCalibCE::GetHisto(Int_t sector, TObjArray *arr,
 				  Int_t nbinsY, Float_t ymin, Float_t ymax,
 				  const Char_t *type, Bool_t force)
 {
-    //
-    // return pointer to TH2S histogram of 'type'
-    // if force is true create a new histogram if it doesn't exist allready
-    //
+    /// return pointer to TH2S histogram of 'type'
+    /// if force is true create a new histogram if it doesn't exist allready
+
     if ( !force || arr->UncheckedAt(sector) )
       return (TH2S*)arr->UncheckedAt(sector);
 
@@ -1420,30 +1393,27 @@ TH2S* AliTPCCalibCE::GetHisto(Int_t sector, TObjArray *arr,
 //_____________________________________________________________________
 TH2S* AliTPCCalibCE::GetHistoT0(Int_t sector, Bool_t force)
 {
-    //
-    // return pointer to T0 histogram
-    // if force is true create a new histogram if it doesn't exist allready
-    //
+    /// return pointer to T0 histogram
+    /// if force is true create a new histogram if it doesn't exist allready
+
     TObjArray *arr = &fHistoT0Array;
     return GetHisto(sector, arr, fNbinsT0, fXminT0, fXmaxT0, "T0", force);
 }
 //_____________________________________________________________________
 TH2S* AliTPCCalibCE::GetHistoQ(Int_t sector, Bool_t force)
 {
-    //
-    // return pointer to Q histogram
-    // if force is true create a new histogram if it doesn't exist allready
-    //
+    /// return pointer to Q histogram
+    /// if force is true create a new histogram if it doesn't exist allready
+
     TObjArray *arr = &fHistoQArray;
     return GetHisto(sector, arr, fNbinsQ, fXminQ, fXmaxQ, "Q", force);
 }
 //_____________________________________________________________________
 TH2S* AliTPCCalibCE::GetHistoRMS(Int_t sector, Bool_t force)
 {
-    //
-    // return pointer to Q histogram
-    // if force is true create a new histogram if it doesn't exist allready
-    //
+    /// return pointer to Q histogram
+    /// if force is true create a new histogram if it doesn't exist allready
+
     TObjArray *arr = &fHistoRMSArray;
     return GetHisto(sector, arr, fNbinsRMS, fXminRMS, fXmaxRMS, "RMS", force);
 }
@@ -1451,10 +1421,9 @@ TH2S* AliTPCCalibCE::GetHistoRMS(Int_t sector, Bool_t force)
 TH1S* AliTPCCalibCE::GetHisto(Int_t sector, TObjArray *arr,
 			      const Char_t *type, Bool_t force)
 {
-    //
-    // return pointer to TH1S histogram
-    // if force is true create a new histogram if it doesn't exist allready
-    //
+    /// return pointer to TH1S histogram
+    /// if force is true create a new histogram if it doesn't exist allready
+
     if ( !force || arr->UncheckedAt(sector) )
       return (TH1S*)arr->UncheckedAt(sector);
 
@@ -1469,20 +1438,18 @@ TH1S* AliTPCCalibCE::GetHisto(Int_t sector, TObjArray *arr,
 //_____________________________________________________________________
 TH1S* AliTPCCalibCE::GetHistoTmean(Int_t sector, Bool_t force)
 {
-    //
-    // return pointer to Q histogram
-    // if force is true create a new histogram if it doesn't exist allready
-    //
+    /// return pointer to Q histogram
+    /// if force is true create a new histogram if it doesn't exist allready
+
     TObjArray *arr = &fHistoTmean;
     return GetHisto(sector, arr, "LastTmean", force);
 }
 //_____________________________________________________________________
 TVectorF* AliTPCCalibCE::GetVectSector(Int_t sector, TObjArray *arr, UInt_t size, Bool_t force) const
 {
-    //
-    // return pointer to Pad Info from 'arr' for the current event and sector
-    // if force is true create it if it doesn't exist allready
-    //
+    /// return pointer to Pad Info from 'arr' for the current event and sector
+    /// if force is true create it if it doesn't exist allready
+
     if ( !force || arr->UncheckedAt(sector) )
 	return (TVectorF*)arr->UncheckedAt(sector);
 
@@ -1493,21 +1460,18 @@ TVectorF* AliTPCCalibCE::GetVectSector(Int_t sector, TObjArray *arr, UInt_t size
 //_____________________________________________________________________
 TVectorF* AliTPCCalibCE::GetPadTimesEvent(Int_t sector, Bool_t force)
 {
-    //
-    // return pointer to Pad Times Array for the current event and sector
-    // if force is true create it if it doesn't exist allready
-    //
+    /// return pointer to Pad Times Array for the current event and sector
+    /// if force is true create it if it doesn't exist allready
+
     TObjArray *arr = &fPadTimesArrayEvent;
     return GetVectSector(sector,arr,fROC->GetNChannels(sector),force);
 }
 //_____________________________________________________________________
 TVectorF* AliTPCCalibCE::GetPadQEvent(Int_t sector, Bool_t force)
 {
-    //
-    // return pointer to Pad Q Array for the current event and sector
-    // if force is true create it if it doesn't exist allready
-    // for debugging purposes only
-    //
+    /// return pointer to Pad Q Array for the current event and sector
+    /// if force is true create it if it doesn't exist allready
+    /// for debugging purposes only
 
     TObjArray *arr = &fPadQArrayEvent;
     return GetVectSector(sector,arr,fROC->GetNChannels(sector),force);
@@ -1515,52 +1479,47 @@ TVectorF* AliTPCCalibCE::GetPadQEvent(Int_t sector, Bool_t force)
 //_____________________________________________________________________
 TVectorF* AliTPCCalibCE::GetPadRMSEvent(Int_t sector, Bool_t force)
 {
-    //
-    // return pointer to Pad RMS Array for the current event and sector
-    // if force is true create it if it doesn't exist allready
-    // for debugging purposes only
-    //
+    /// return pointer to Pad RMS Array for the current event and sector
+    /// if force is true create it if it doesn't exist allready
+    /// for debugging purposes only
+
     TObjArray *arr = &fPadRMSArrayEvent;
     return GetVectSector(sector,arr,fROC->GetNChannels(sector),force);
 }
 //_____________________________________________________________________
 TVectorF* AliTPCCalibCE::GetPadPedestalEvent(Int_t sector, Bool_t force)
 {
-    //
-    // return pointer to Pad RMS Array for the current event and sector
-    // if force is true create it if it doesn't exist allready
-    // for debugging purposes only
-    //
+    /// return pointer to Pad RMS Array for the current event and sector
+    /// if force is true create it if it doesn't exist allready
+    /// for debugging purposes only
+
     TObjArray *arr = &fPadPedestalArrayEvent;
     return GetVectSector(sector,arr,fROC->GetNChannels(sector),force);
 }
 //_____________________________________________________________________
 TVectorF* AliTPCCalibCE::GetTMeanEvents(Int_t sector, Bool_t force)
 {
-    //
-    // return pointer to the EbyE info of the mean arrival time for 'sector'
-    // if force is true create it if it doesn't exist allready
-    //
+    /// return pointer to the EbyE info of the mean arrival time for 'sector'
+    /// if force is true create it if it doesn't exist allready
+
     TObjArray *arr = &fTMeanArrayEvent;
     return GetVectSector(sector,arr,100,force);
 }
 //_____________________________________________________________________
 TVectorF* AliTPCCalibCE::GetQMeanEvents(Int_t sector, Bool_t force)
 {
-    //
-    // return pointer to the EbyE info of the mean arrival time for 'sector'
-    // if force is true create it if it doesn't exist allready
-    //
+    /// return pointer to the EbyE info of the mean arrival time for 'sector'
+    /// if force is true create it if it doesn't exist allready
+
     TObjArray *arr = &fQMeanArrayEvent;
     return GetVectSector(sector,arr,100,force);
 }
 //_____________________________________________________________________
 AliTPCCalROC* AliTPCCalibCE::GetCalRoc(Int_t sector, TObjArray* arr, Bool_t force) const
 {
-    //
-    // return pointer to ROC Calibration
-    // if force is true create a new histogram if it doesn't exist allready
-    //
+    /// return pointer to ROC Calibration
+    /// if force is true create a new histogram if it doesn't exist allready
+
     if ( !force || arr->UncheckedAt(sector) )
 	return (AliTPCCalROC*)arr->UncheckedAt(sector);
 
@@ -1574,60 +1533,54 @@ AliTPCCalROC* AliTPCCalibCE::GetCalRoc(Int_t sector, TObjArray* arr, Bool_t forc
 //_____________________________________________________________________
 AliTPCCalROC* AliTPCCalibCE::GetCalRocT0(Int_t sector, Bool_t force)
 {
-    //
-    // return pointer to Time 0 ROC Calibration
-    // if force is true create a new histogram if it doesn't exist allready
-    //
+    /// return pointer to Time 0 ROC Calibration
+    /// if force is true create a new histogram if it doesn't exist allready
+
     TObjArray *arr = &fCalRocArrayT0;
     return GetCalRoc(sector, arr, force);
 }
 //_____________________________________________________________________
 AliTPCCalROC* AliTPCCalibCE::GetCalRocT0Err(Int_t sector, Bool_t force)
 {
-    //
-    // return pointer to the error of Time 0 ROC Calibration
-    // if force is true create a new histogram if it doesn't exist allready
-    //
+    /// return pointer to the error of Time 0 ROC Calibration
+    /// if force is true create a new histogram if it doesn't exist allready
+
     TObjArray *arr = &fCalRocArrayT0Err;
     return GetCalRoc(sector, arr, force);
 }
 //_____________________________________________________________________
 AliTPCCalROC* AliTPCCalibCE::GetCalRocQ(Int_t sector, Bool_t force)
 {
-    //
-    // return pointer to T0 ROC Calibration
-    // if force is true create a new histogram if it doesn't exist allready
-    //
+    /// return pointer to T0 ROC Calibration
+    /// if force is true create a new histogram if it doesn't exist allready
+
     TObjArray *arr = &fCalRocArrayQ;
     return GetCalRoc(sector, arr, force);
 }
 //_____________________________________________________________________
 AliTPCCalROC* AliTPCCalibCE::GetCalRocRMS(Int_t sector, Bool_t force)
 {
-    //
-    // return pointer to signal width ROC Calibration
-    // if force is true create a new histogram if it doesn't exist allready
-    //
+    /// return pointer to signal width ROC Calibration
+    /// if force is true create a new histogram if it doesn't exist allready
+
     TObjArray *arr = &fCalRocArrayRMS;
     return GetCalRoc(sector, arr, force);
 }
 //_____________________________________________________________________
 AliTPCCalROC* AliTPCCalibCE::GetCalRocOutliers(Int_t sector, Bool_t force)
 {
-    //
-    // return pointer to Outliers
-    // if force is true create a new histogram if it doesn't exist allready
-    //
+    /// return pointer to Outliers
+    /// if force is true create a new histogram if it doesn't exist allready
+
     TObjArray *arr = &fCalRocArrayOutliers;
     return GetCalRoc(sector, arr, force);
 }
 //_____________________________________________________________________
 TObjArray* AliTPCCalibCE::GetParamArray(Int_t sector, TObjArray* arr, Bool_t force) const
 {
-    //
-    // return pointer to TObjArray of fit parameters
-    // if force is true create a new histogram if it doesn't exist allready
-    //
+    /// return pointer to TObjArray of fit parameters
+    /// if force is true create a new histogram if it doesn't exist allready
+
     if ( !force || arr->UncheckedAt(sector) )
 	return (TObjArray*)arr->UncheckedAt(sector);
 
@@ -1641,20 +1594,18 @@ TObjArray* AliTPCCalibCE::GetParamArray(Int_t sector, TObjArray* arr, Bool_t for
 //_____________________________________________________________________
 TObjArray* AliTPCCalibCE::GetParamArrayPol1(Int_t sector, Bool_t force)
 {
-    //
-    // return pointer to TObjArray of fit parameters from plane fit
-    // if force is true create a new histogram if it doesn't exist allready
-    //
+    /// return pointer to TObjArray of fit parameters from plane fit
+    /// if force is true create a new histogram if it doesn't exist allready
+
     TObjArray *arr = &fParamArrayEventPol1;
     return GetParamArray(sector, arr, force);
 }
 //_____________________________________________________________________
 TObjArray* AliTPCCalibCE::GetParamArrayPol2(Int_t sector, Bool_t force)
 {
-    //
-    // return pointer to TObjArray of fit parameters from parabola fit
-    // if force is true create a new histogram if it doesn't exist allready
-    //
+    /// return pointer to TObjArray of fit parameters from parabola fit
+    /// if force is true create a new histogram if it doesn't exist allready
+
     TObjArray *arr = &fParamArrayEventPol2;
     return GetParamArray(sector, arr, force);
 }
@@ -1662,20 +1613,18 @@ TObjArray* AliTPCCalibCE::GetParamArrayPol2(Int_t sector, Bool_t force)
 //_____________________________________________________________________
 void AliTPCCalibCE::CreateDVhist()
 {
-  //
-  // Setup the THnSparse for the drift velocity determination
-  //
+  /// Setup the THnSparse for the drift velocity determination
 
   //HnSparse bins
   //roc, row, pad, timebin, timestamp
   TTimeStamp begin(2010,01,01,0,0,0);
   TTimeStamp end(2035,01,01,0,0,0);
   Int_t nbinsTime=(end.GetSec()-begin.GetSec())/60; //Minutes resolution
-  
+
   Int_t    bins[kHnBinsDV] = { 72,  96,  140,  1030, nbinsTime};
   Double_t xmin[kHnBinsDV] = { 0.,  0.,   0.,    0., (Double_t)begin.GetSec()};
   Double_t xmax[kHnBinsDV] = {72., 96., 140., 1030., (Double_t)end.GetSec()};
-  
+
   fHnDrift=new THnSparseI("fHnDrift","Laser digits",kHnBinsDV, bins, xmin, xmax);
   fHnDrift->GetAxis(0)->SetNameTitle("ROC","Read-out chamber number");
   fHnDrift->GetAxis(1)->SetNameTitle("Row","Row number");
@@ -1688,9 +1637,8 @@ void AliTPCCalibCE::CreateDVhist()
 //_____________________________________________________________________
 void AliTPCCalibCE::ResetEvent()
 {
-    //
-    //  Reset global counters  -- Should be called before each event is processed
-    //
+    ///  Reset global counters  -- Should be called before each event is processed
+
     fLastSector=-1;
     fCurrentSector=-1;
     fCurrentRow=-1;
@@ -1713,9 +1661,8 @@ void AliTPCCalibCE::ResetEvent()
 //_____________________________________________________________________
 void AliTPCCalibCE::ResetPad()
 {
-    //
-    //  Reset pad infos -- Should be called after a pad has been processed
-    //
+    ///  Reset pad infos -- Should be called after a pad has been processed
+
     for (Int_t i=fFirstTimeBin; i<fLastTimeBin+1; ++i)
       fPadSignal[i] = 0;
     fMaxTimeBin   = -1;
@@ -1726,20 +1673,19 @@ void AliTPCCalibCE::ResetPad()
 //_____________________________________________________________________
 void AliTPCCalibCE::Merge(AliTPCCalibCE * const ce)
 {
-  //
-  //  Merge ce to the current AliTPCCalibCE
-  //
+  ///  Merge ce to the current AliTPCCalibCE
+
   MergeBase(ce);
   Int_t nCEevents = ce->GetNeventsProcessed();
-  
+
   if (fProcessOld&&ce->fProcessOld){
   //merge histograms
     for (Int_t iSec=0; iSec<72; ++iSec){
       TH2S *hRefQmerge   = ce->GetHistoQ(iSec);
       TH2S *hRefT0merge  = ce->GetHistoT0(iSec);
       TH2S *hRefRMSmerge = ce->GetHistoRMS(iSec);
-      
-      
+
+
       if ( hRefQmerge ){
         TDirectory *dir = hRefQmerge->GetDirectory(); hRefQmerge->SetDirectory(0);
         TH2S *hRefQ   = GetHistoQ(iSec);
@@ -1773,23 +1719,23 @@ void AliTPCCalibCE::Merge(AliTPCCalibCE * const ce)
         }
         hRefRMSmerge->SetDirectory(dir);
       }
-      
+
     }
-    
+
     // merge time information
-    
-    
+
+
     for (Int_t iSec=0; iSec<72; ++iSec){
       TObjArray *arrPol1CE  = ce->GetParamArrayPol1(iSec);
       TObjArray *arrPol2CE  = ce->GetParamArrayPol2(iSec);
       TVectorF *vMeanTimeCE = ce->GetTMeanEvents(iSec);
       TVectorF *vMeanQCE    = ce->GetQMeanEvents(iSec);
-      
+
       TObjArray *arrPol1  = 0x0;
       TObjArray *arrPol2  = 0x0;
       TVectorF *vMeanTime = 0x0;
       TVectorF *vMeanQ    = 0x0;
-      
+
   //resize arrays
       if ( arrPol1CE && arrPol2CE ){
         arrPol1 = GetParamArrayPol1(iSec,kTRUE);
@@ -1803,7 +1749,7 @@ void AliTPCCalibCE::Merge(AliTPCCalibCE * const ce)
         vMeanTime->ResizeTo(fNevents+nCEevents);
         vMeanQ->ResizeTo(fNevents+nCEevents);
       }
-      
+
       for (Int_t iEvent=0; iEvent<nCEevents; ++iEvent){
         if ( arrPol1CE && arrPol2CE ){
           TVectorD *paramPol1 = (TVectorD*)(arrPol1CE->UncheckedAt(iEvent));
@@ -1819,9 +1765,9 @@ void AliTPCCalibCE::Merge(AliTPCCalibCE * const ce)
         }
       }
     }
-    
-    
-    
+
+
+
     const TVectorD&  eventTimes  = ce->fVEventTime;
     const TVectorD&  eventIds    = ce->fVEventNumber;
     const TVectorF&  time0SideA  = ce->fVTime0SideA;
@@ -1836,7 +1782,7 @@ void AliTPCCalibCE::Merge(AliTPCCalibCE * const ce)
       Double_t evId       = eventIds.GetMatrixArray()[iEvent];
       Float_t  t0SideA    = time0SideA.GetMatrixArray()[iEvent];
       Float_t  t0SideC    = time0SideC.GetMatrixArray()[iEvent];
-      
+
       fVEventTime.GetMatrixArray()[fNevents+iEvent]   = evTime;
       fVEventNumber.GetMatrixArray()[fNevents+iEvent] = evId;
       fVTime0SideA.GetMatrixArray()[fNevents+iEvent]  = t0SideA;
@@ -1857,16 +1803,14 @@ void AliTPCCalibCE::Merge(AliTPCCalibCE * const ce)
       //TODO: What to do with fTimeBursts???
     }
   }
-  
+
   fNevents+=nCEevents; //increase event counter
 }
 
 //_____________________________________________________________________
 Long64_t AliTPCCalibCE::Merge(TCollection * const list)
 {
-  //
-  // Merge all objects of this type in list
-  //
+  /// Merge all objects of this type in list
 
   Long64_t nmerged=1;
 
@@ -1888,16 +1832,14 @@ Long64_t AliTPCCalibCE::Merge(TCollection * const list)
 //_____________________________________________________________________
 TGraph *AliTPCCalibCE::MakeGraphTimeCE(Int_t sector, Int_t xVariable, Int_t fitType, Int_t fitParameter)
 {
-  //
-  // Make graph from fit parameters of pol1 fit, pol2 fit, mean arrival time or mean Q for ROC 'sector'
-  // or side (-1: A-Side, -2: C-Side)
-  // xVariable:    0-event time, 1-event id, 2-internal event counter
-  // fitType:      0-pol1 fit, 1-pol2 fit, 2-mean time, 3-mean Q
-  // fitParameter: fit parameter ( 0-2 for pol1 ([0]+[1]*x+[2]*y),
-  //                               0-5 for pol2 ([0]+[1]*x+[2]*y+[3]*x*x+[4]*y*y+[5]*x*y),
-  //                               not used for mean time and mean Q )
-  // for an example see class description at the beginning
-  //
+  /// Make graph from fit parameters of pol1 fit, pol2 fit, mean arrival time or mean Q for ROC 'sector'
+  /// or side (-1: A-Side, -2: C-Side)
+  /// xVariable:    0-event time, 1-event id, 2-internal event counter
+  /// fitType:      0-pol1 fit, 1-pol2 fit, 2-mean time, 3-mean Q
+  /// fitParameter: fit parameter ( 0-2 for pol1 ([0]+[1]*x+[2]*y),
+  ///                               0-5 for pol2 ([0]+[1]*x+[2]*y+[3]*x*x+[4]*y*y+[5]*x*y),
+  ///                               not used for mean time and mean Q )
+  /// for an example see class description at the beginning
 
   TVectorD *xVar = 0x0;
   TObjArray *aType = 0x0;
@@ -1930,10 +1872,10 @@ TGraph *AliTPCCalibCE::MakeGraphTimeCE(Int_t sector, Int_t xVariable, Int_t fitT
     xVar = new TVectorD(fNevents);
     for ( Int_t i=0;i<fNevents; ++i) (*xVar)[i]=i;
   }
-  
+
   Double_t *x = new Double_t[fNevents];
   Double_t *y = new Double_t[fNevents];
-  
+
   for (Int_t ievent =0; ievent<fNevents; ++ievent){
     if ( fitType<2 ){
       TObjArray *events = (TObjArray*)(aType->At(sector));
@@ -1972,61 +1914,59 @@ TGraph *AliTPCCalibCE::MakeGraphTimeCE(Int_t sector, Int_t xVariable, Int_t fitT
 //_____________________________________________________________________
 void AliTPCCalibCE::Analyse()
 {
-  //
-  //  Calculate calibration constants
-  //
+  ///  Calculate calibration constants
 
   if (fProcessOld){
     TVectorD paramQ(3);
     TVectorD paramT0(3);
     TVectorD paramRMS(3);
     TMatrixD dummy(3,3);
-    
+
     Float_t channelCounter=0;
     fMeanT0rms=0;
     fMeanQrms=0;
     fMeanRMSrms=0;
-    
+
     for (Int_t iSec=0; iSec<72; ++iSec){
       TH2S *hT0 = GetHistoT0(iSec);
       if (!hT0 ) continue;
-      
+
       AliTPCCalROC *rocQ     = GetCalRocQ  (iSec,kTRUE);
       AliTPCCalROC *rocT0    = GetCalRocT0 (iSec,kTRUE);
       AliTPCCalROC *rocT0Err = GetCalRocT0Err (iSec,kTRUE);
       AliTPCCalROC *rocRMS   = GetCalRocRMS(iSec,kTRUE);
       AliTPCCalROC *rocOut   = GetCalRocOutliers(iSec,kTRUE);
-      
+
       TH2S *hQ   = GetHistoQ(iSec);
       TH2S *hRMS = GetHistoRMS(iSec);
-      
+
       Short_t *arrayhQ   = hQ->GetArray();
       Short_t *arrayhT0  = hT0->GetArray();
       Short_t *arrayhRMS = hRMS->GetArray();
-      
+
       UInt_t nChannels = fROC->GetNChannels(iSec);
-      
+
   //debug
       Int_t row=0;
       Int_t pad=0;
       Int_t padc=0;
   //! debug
-      
+
       for (UInt_t iChannel=0; iChannel<nChannels; ++iChannel){
-        
-        
+
+
         Float_t cogTime0 = -1000;
         Float_t cogQ     = -1000;
         Float_t cogRMS   = -1000;
         Float_t cogOut   = 0;
         Float_t rms      = 0;
         Float_t rmsT0    = 0;
-        
-        
+
+
         Int_t offsetQ = (fNbinsQ+2)*(iChannel+1)+1;
         Int_t offsetT0 = (fNbinsT0+2)*(iChannel+1)+1;
         Int_t offsetRMS = (fNbinsRMS+2)*(iChannel+1)+1;
-        
+
         cogQ     = AliMathBase::GetCOG(arrayhQ+offsetQ,fNbinsQ,fXminQ,fXmaxQ,&rms);
         fMeanQrms+=rms;
         cogTime0 = AliMathBase::GetCOG(arrayhT0+offsetT0,fNbinsT0,fXminT0,fXmaxT0,&rmsT0);
@@ -2034,7 +1974,7 @@ void AliTPCCalibCE::Analyse()
         cogRMS   = AliMathBase::GetCOG(arrayhRMS+offsetRMS,fNbinsRMS,fXminRMS,fXmaxRMS,&rms);
         fMeanRMSrms+=rms;
         channelCounter++;
-        
+
       /*
              //outlier specifications
          if ( (cogQ < ??) && (cogTime0 > ??) && (cogTime0<??) && ( cogRMS>??) ){
@@ -2049,17 +1989,17 @@ void AliTPCCalibCE::Analyse()
         rocT0Err->SetValue(iChannel, rmsT0);
         rocRMS->SetValue(iChannel, cogRMS);
         rocOut->SetValue(iChannel, cogOut);
-        
-        
+
+
       //debug
         if ( GetStreamLevel() > 0 ){
           TTreeSRedirector *streamer=GetDebugStreamer();
           if ( streamer ) {
-            
+
             while ( iChannel > (fROC->GetRowIndexes(iSec)[row]+fROC->GetNPads(iSec,row)-1) ) row++;
             pad = iChannel-fROC->GetRowIndexes(iSec)[row];
             padc = pad-(fROC->GetNPads(iSec,row)/2);
-            
+
             (*streamer) << "DataEnd" <<
               "Sector="  << iSec      <<
               "Pad="     << pad       <<
@@ -2073,9 +2013,9 @@ void AliTPCCalibCE::Analyse()
           }
         }
       //! debug
-        
+
       }
-      
+
     }
     if ( channelCounter>0 ){
       fMeanT0rms/=channelCounter;
@@ -2112,20 +2052,18 @@ void AliTPCCalibCE::Analyse()
 //_____________________________________________________________________
 void AliTPCCalibCE::FindLocalMaxima(TObjArray * const arrObj, Double_t timestamp, Int_t burst)
 {
-  //
-  //Find the local maximums for the projections to each axis
-  //
-  
+  /// Find the local maximums for the projections to each axis
+
   //find laser layer positoins
   fHnDrift->GetAxis(4)->SetRangeUser(timestamp-2*60,timestamp+2*60);
   FindLaserLayers();
   THnSparse *hProj=fHnDrift;
   Double_t posCE[4]={0.,0.,0.,0.};
   Double_t widthCE[4]={0.,0.,0.,0.};
-  
+
 //   if(fPeaks[4]!=0){
   // find central electrode position once more, separately for IROC, OROC, A-, C-Side
-  
+
   for (Int_t i=0; i<4; ++i){
     Int_t ce=(i/2>0)*7+6;
     hProj->GetAxis(0)->SetRangeUser(i*18,(i+1)*18-1);
@@ -2152,15 +2090,15 @@ void AliTPCCalibCE::FindLocalMaxima(TObjArray * const arrObj, Double_t timestamp
   //Current drift velocity
   Float_t vdrift=2.61301900000000000e+06;//fParam->GetDriftV();
 //   cout<<"vdrift="<<vdrift<<endl;
-  
+
   AliDebug(5,Form("Timestamp %f - default drift velocity %f",timestamp,vdrift));
   //loop over all entries in the histogram
   Int_t coord[5];
   for(Long64_t ichunk=0;ichunk<hProj->GetNbins();ichunk++){
     //get entry position and content
     Double_t adc=hProj->GetBinContent(ichunk,coord);
-    
-    
+
+
     Int_t sector = coord[0]-1;
     Int_t row    = coord[1]-1;
     Int_t pad    = coord[2]-1;
@@ -2170,7 +2108,7 @@ void AliTPCCalibCE::FindLocalMaxima(TObjArray * const arrObj, Double_t timestamp
 //     return;
 //     fPeaks[4]=(UInt_t)posCE[sector/18];
 //     fPeakWidths[4]=(UInt_t)widthCE[sector/18];
-    
+
     //cuts
     if (time<timestamp-120||time>timestamp+120) continue; //window of +- 2min
     if (adc < 5 ) continue;
@@ -2178,7 +2116,7 @@ void AliTPCCalibCE::FindLocalMaxima(TObjArray * const arrObj, Double_t timestamp
 //     if (!IsPeakInRange(timeBin)) continue;
 //     if (isCE&&((row%2)||(row%2)||(sector%2))) continue;
 //     if (isCE&&(sector!=0)) continue;
-    
+
     Int_t padmin=-2, padmax=2;
     Int_t timemin=-2, timemax=2;
     Int_t minsumperpad=2;
@@ -2191,7 +2129,7 @@ void AliTPCCalibCE::FindLocalMaxima(TObjArray * const arrObj, Double_t timestamp
       timemin=-3;
       timemax=7;
     }
-    
+
     //
     // Find local maximum and cogs
     //
@@ -2199,26 +2137,26 @@ void AliTPCCalibCE::FindLocalMaxima(TObjArray * const arrObj, Double_t timestamp
     Float_t totalmass=0, tbcm=0, padcm=0, rmstb=0, rmspad=0;
     Double_t cogY=0, rmsY=0;
     Int_t npart=0;
-    
+
     // for position calculation use
     for(Int_t ipad=padmin;ipad<=padmax;++ipad){
       Float_t lxyz[3];
       fROC->GetPositionLocal(sector,row,pad+ipad,lxyz);
-      
+
       for(Int_t itime=timemin;itime<=timemax;++itime){
-        
+
         Int_t a[5]={coord[0],coord[1],coord[2]+ipad,coord[3]+itime,coord[4]};
         Double_t val=hProj->GetBinContent(a);
         totalmass+=val;
-        
+
         tbcm +=(timeBin+itime)*val;
         padcm+=(pad+ipad)*val;
         cogY +=lxyz[1]*val;
-        
+
         rmstb +=(timeBin+itime)*(timeBin+itime)*val;
         rmspad+=(pad+ipad)*(pad+ipad)*val;
         rmsY  +=lxyz[1]*lxyz[1]*val;
-        
+
         if (val>0) ++npart;
         if (val>adc) {
           isMaximum=kFALSE;
@@ -2227,46 +2165,46 @@ void AliTPCCalibCE::FindLocalMaxima(TObjArray * const arrObj, Double_t timestamp
       }
       if (!isMaximum)  break;
     }
-    
+
     if (!isMaximum||!npart)  continue;
     if (totalmass<npart*minsumperpad) continue;
     if (!isCE&&rmspad<.1) continue; //most probably noise, since signal only in one pad,
                                     //for CE we want only one pad by construction
-    
+
     tbcm/=totalmass;
     padcm/=totalmass;
     cogY/=totalmass;
-    
+
     rmstb/=totalmass;
     rmspad/=totalmass;
     rmsY/=totalmass;
-    
+
     rmstb=TMath::Sqrt(TMath::Abs(tbcm*tbcm-rmstb));
     rmspad=TMath::Sqrt(TMath::Abs(padcm*padcm-rmspad));
     rmsY=TMath::Sqrt(TMath::Abs(cogY*cogY-rmsY));
-    
+
     Int_t cog=TMath::Nint(padcm);
-    
+
     // timebin --> z position
     Float_t zlength=fParam->GetZLength(side);
 //     Float_t timePos=tbcm+(1000-fPeaks[4])
     // drift velocity is in m/s we would like to have cm/100ns, so 100cm/(10^7*100ns)
     Double_t gz=(zlength-(tbcm*vdrift*1.e-7))*TMath::Power(-1,side);
-    
+
     // local to global transformation--> x and y positions
     Float_t padlxyz[3];
     fROC->GetPositionLocal(sector,row,pad,padlxyz);
-    
+
     Double_t gxyz[3]={padlxyz[0],cogY,gz};
     Double_t lxyz[3]={padlxyz[0],cogY,gz};
     Double_t igxyz[3]={0,0,0};
     AliTPCTransform t1;
     t1.RotatedGlobal2Global(sector,gxyz);
-    
+
     Double_t mindist=0;
     Int_t trackID=-1;
     Int_t trackID2=-1;
-    
+
     //find track id and index of the position in the track (row)
     Int_t index=0;
     if (!isCE){
@@ -2285,15 +2223,15 @@ void AliTPCCalibCE::FindLocalMaxima(TObjArray * const arrObj, Double_t timestamp
 //       mindist=TMath::Abs(fPeaks[4]-tbcm);
       mindist=1.;
     }
-    
+
     // fill track vectors
     if (trackID>0){
       AliTPCLaserTrack *ltr=(AliTPCLaserTrack*)arrObj->UncheckedAt(trackID);
       Double_t oldMinDist=ltr->fVecPhi->GetMatrixArray()[index];
-      
-      
+
+
 //      travel time effect of light includes
-      
+
       Double_t raylength=ltr->GetRayLength();
       Double_t globmir[3]={ltr->Xv(),ltr->Yv(),ltr->Zv()};
       ltr->GetXYZ(globmir);
@@ -2309,7 +2247,7 @@ void AliTPCCalibCE::FindLocalMaxima(TObjArray * const arrObj, Double_t timestamp
                                        +(gxyz[2]-globmir[2])*(gxyz[2]-globmir[2])+raylength))*vdrift*TMath::Power(10.,-6.)/30000;
         }
       }
-      
+
       if (TMath::Abs(oldMinDist)<1.e-20||oldMinDist>mindist){
         ltr->fVecSec->GetMatrixArray()[index]=sector;
         ltr->fVecP2->GetMatrixArray()[index]=0;
@@ -2328,8 +2266,8 @@ void AliTPCCalibCE::FindLocalMaxima(TObjArray * const arrObj, Double_t timestamp
       igxyz[1]=ltr->fVecGY->GetMatrixArray()[row];
       igxyz[2]=ltr->fVecGZ->GetMatrixArray()[row];
     }
-    
-    
+
+
     if (fStreamLevel>4){
       (*GetDebugStreamer()) << "clusters" <<
         "run="   << fRunNumber <<
@@ -2344,28 +2282,28 @@ void AliTPCCalibCE::FindLocalMaxima(TObjArray * const arrObj, Double_t timestamp
         "cogCE="     << posCE[sector/18] <<
         "withCE="    << widthCE[sector/18] <<
         "index="     << index     <<
-        
+
         "padcm="     << padcm     <<
         "rmspad="    << rmspad    <<
-        
+
         "cogtb="     << tbcm      <<
         "rmstb="     << rmstb     <<
-        
+
         "npad="      << npart     <<
-        
+
         "lx="        << padlxyz[0]<<
         "ly="        << cogY      <<
         "lypad="     << padlxyz[1]<<
         "rmsY="      << rmsY      <<
-        
+
         "gx="        << gxyz[0]   <<
         "gy="        << gxyz[1]   <<
         "gz="        << gxyz[2]   <<
-        
+
         "igx="        << igxyz[0] <<
         "igy="        << igxyz[1] <<
         "igz="        << igxyz[2] <<
-        
+
         "mind="      << mindist   <<
         "max="       << adc       <<
         "trackid="   << trackID   <<
@@ -2373,19 +2311,17 @@ void AliTPCCalibCE::FindLocalMaxima(TObjArray * const arrObj, Double_t timestamp
         "npart="     << npart     <<
         "\n";
     } // end stream levelmgz.fElements
-    
+
   }
-  
+
 }
 
 //_____________________________________________________________________
 void AliTPCCalibCE::AnalyseTrack()
 {
-  //
-  //  Analyse the tracks
-  //
-  
-  
+  ///  Analyse the tracks
+
+
   AliTPCLaserTrack::LoadTracks();
 //   AliTPCParam *param=0x0;
 //   //cdb run number
@@ -2403,12 +2339,12 @@ void AliTPCCalibCE::AnalyseTrack()
 //   } else {
 //     AliError("Could not get updated AliTPCParam from OCDB!!!");
 //   }
-  
+
   //Measured and ideal laser tracks
   TObjArray* arrMeasured = SetupMeasured();
   TObjArray* arrIdeal    = AliTPCLaserTrack::GetTracks();
   AddCEtoIdeal(arrIdeal);
-  
+
   //find bursts and loop over them
   for (Int_t iburst=0; iburst<fArrHnDrift.GetEntries();++iburst){
     Double_t timestamp=fTimeBursts[iburst];
@@ -2418,24 +2354,24 @@ void AliTPCCalibCE::AnalyseTrack()
     UInt_t entries=(UInt_t)fHnDrift->GetEntries();
     if (fBinsLastAna[iburst]>=entries) continue; //already analysed!!!
     fBinsLastAna[iburst]=entries;
-    
+
     for (Int_t iDim=0; iDim<fHnDrift->GetNdimensions(); ++iDim) fHnDrift->GetAxis(iDim)->SetRange(0,0);
 //     if (iburst==0) FindLaserLayers();
-    
+
     //reset laser tracks
     ResetMeasured(arrMeasured);
-    
+
     //find clusters and associate to the tracks
     FindLocalMaxima(arrMeasured, timestamp, iburst);
-    
+
     //calculate drift velocity
     CalculateDV(arrIdeal,arrMeasured,iburst);
-    
+
     //Dump information to file if requested
     if (fStreamLevel>2){
       //printf("make tree\n");
       //laser track information
-      
+
       for (Int_t itrack=0; itrack<338; ++itrack){
         TObject *iltr=arrIdeal->UncheckedAt(itrack);
         TObject *mltr=arrMeasured->UncheckedAt(itrack);
@@ -2456,23 +2392,21 @@ void AliTPCCalibCE::AnalyseTrack()
 Int_t AliTPCCalibCE::FindLaserTrackID(Int_t sector,Int_t row, const Double_t *peakpos,Double_t &mindist,
                                       const Double_t *peakposloc, Int_t &itrackMin2)
 {
-  //
-  //  Find the tracks, which are closest to the ideal tracks, from clusters closest to the ideal tracks
-  //
-  
-  
+  ///  Find the tracks, which are closest to the ideal tracks, from clusters closest to the ideal tracks
+
+
   TObjArray *arr=AliTPCLaserTrack::GetTracks();
   TVector3 vP(peakpos[0],peakpos[1],peakpos[2]);
   TVector3 vDir;
   TVector3 vSt;
-  
+
   Int_t firstbeam=0;
   Int_t lastbeam=336/2;
   if ( (sector/18)%2 ) {
     firstbeam=336/2;
     lastbeam=336;
   }
-  
+
   mindist=1000000;
   Int_t itrackMin=-1;
   for (Int_t itrack=firstbeam; itrack<lastbeam; ++itrack){
@@ -2484,27 +2418,27 @@ Int_t AliTPCCalibCE::FindLaserTrackID(Int_t sector,Int_t row, const Double_t *pe
     vDir.SetMagThetaPhi(1,ltr->Theta(),TMath::ASin(ltr->GetSnp()));
     vSt.RotateZ(ltr->GetAlpha());
     vDir.RotateZ(ltr->GetAlpha());
-    
+
     Double_t dist=(vDir.Cross(vSt-vP)).Mag()/vDir.Mag();
-    
+
     if (dist<mindist){
       mindist=dist;
       itrackMin=itrack;
     }
-    
+
   }
   itrackMin2=-1;
   Float_t mindist2=10;
   for (Int_t itrack=firstbeam; itrack<lastbeam; ++itrack){
     AliTPCLaserTrack *ltr=(AliTPCLaserTrack*)arr->At(itrack);  //get the track
     if ((ltr->fVecSec->GetMatrixArray())[row]!=sector) continue;
-    
+
     Double_t deltaZ=ltr->GetZ()-peakpos[2];
     if (TMath::Abs(deltaZ)>40) continue;
-    
+
     Double_t dist=TMath::Abs((ltr->fVecLY->GetMatrixArray())[row]-peakposloc[1]);
     if (dist>1) continue;
-    
+
     if (dist<mindist2){
       mindist2=dist;
       itrackMin2=itrack;
@@ -2512,37 +2446,34 @@ Int_t AliTPCCalibCE::FindLaserTrackID(Int_t sector,Int_t row, const Double_t *pe
   }
   mindist=mindist2;
   return itrackMin2;
-  
+
 }
 
 //_____________________________________________________________________
 Bool_t AliTPCCalibCE::IsEdgePad(Int_t sector, Int_t row, Int_t pad) const
 {
-  //
-  // return true if pad is on the edge of a row
-  //
+  /// return true if pad is on the edge of a row
+
   Int_t edge1   = 0;
   if ( pad == edge1 ) return kTRUE;
   Int_t edge2   = fROC->GetNPads(sector,row)-1;
   if ( pad == edge2 ) return kTRUE;
-  
+
   return kFALSE;
 }
 
 //_____________________________________________________________________
 TObjArray* AliTPCCalibCE::SetupMeasured()
 {
-  //
-  // setup array of measured laser tracks and CE
-  //
-  
+  /// setup array of measured laser tracks and CE
+
   TObjArray *arrIdeal    = AliTPCLaserTrack::GetTracks();
   TObjArray *arrMeasured = new TObjArray(338);
   arrMeasured->SetOwner();
   for(Int_t itrack=0;itrack<336;itrack++){
     arrMeasured->AddAt(new AliTPCLaserTrack(*((AliTPCLaserTrack*)arrIdeal->At(itrack))),itrack);
   }
-  
+
   //"tracks" for CE
   AliTPCLaserTrack *ltrce=new AliTPCLaserTrack;
   ltrce->SetId(336);
@@ -2556,9 +2487,9 @@ TObjArray* AliTPCCalibCE::SetupMeasured()
   ltrce->fVecLX=new TVectorD(557568/2);
   ltrce->fVecLY=new TVectorD(557568/2);
   ltrce->fVecLZ=new TVectorD(557568/2);
-  
+
   arrMeasured->AddAt(ltrce,336); //CE A-Side
-  
+
   ltrce=new AliTPCLaserTrack;
   ltrce->SetId(337);
   ltrce->SetSide(1);
@@ -2572,16 +2503,15 @@ TObjArray* AliTPCCalibCE::SetupMeasured()
   ltrce->fVecLY=new TVectorD(557568/2);
   ltrce->fVecLZ=new TVectorD(557568/2);
   arrMeasured->AddAt(ltrce,337); //CE C-Side
-  
+
   return arrMeasured;
 }
 
 //_____________________________________________________________________
 void AliTPCCalibCE::ResetMeasured(TObjArray * const arr)
 {
-  //
-  // reset array of measured laser tracks and CE
-  //
+  /// reset array of measured laser tracks and CE
+
   for(Int_t itrack=0;itrack<338;itrack++){
     AliTPCLaserTrack *ltr=(AliTPCLaserTrack*)arr->UncheckedAt(itrack);
     ltr->fVecSec->Zero();
@@ -2599,10 +2529,8 @@ void AliTPCCalibCE::ResetMeasured(TObjArray * const arr)
 //_____________________________________________________________________
 void AliTPCCalibCE::AddCEtoIdeal(TObjArray *arr)
 {
-  //
-  // Add ideal CE positions to the ideal track data
-  //
-  
+  /// Add ideal CE positions to the ideal track data
+
   arr->Expand(338);
   //"tracks" for CE
   AliTPCLaserTrack *ltrceA=new AliTPCLaserTrack;
@@ -2618,7 +2546,7 @@ void AliTPCCalibCE::AddCEtoIdeal(TObjArray *arr)
   ltrceA->fVecLY=new TVectorD(557568/2);
   ltrceA->fVecLZ=new TVectorD(557568/2);
   arr->AddAt(ltrceA,336); //CE A-Side
-  
+
   AliTPCLaserTrack *ltrceC=new AliTPCLaserTrack;
   ltrceC->SetId(337);
   ltrceC->SetSide(1);
@@ -2632,7 +2560,7 @@ void AliTPCCalibCE::AddCEtoIdeal(TObjArray *arr)
   ltrceC->fVecLY=new TVectorD(557568/2);
   ltrceC->fVecLZ=new TVectorD(557568/2);
   arr->AddAt(ltrceC,337); //CE C-Side
-  
+
   //Calculate ideal positoins
   Float_t gxyz[3];
   Float_t lxyz[3];
@@ -2640,7 +2568,7 @@ void AliTPCCalibCE::AddCEtoIdeal(TObjArray *arr)
   Int_t channelSideC=0;
   Int_t channelSide=0;
   AliTPCLaserTrack *ltrce=0x0;
-  
+
   for (Int_t isector=0; isector<72; ++isector){
     Int_t side=((isector/18)%2);
     for (UInt_t irow=0;irow<fROC->GetNRows(isector);++irow){
@@ -2654,7 +2582,7 @@ void AliTPCCalibCE::AddCEtoIdeal(TObjArray *arr)
           ltrce=ltrceC;
           channelSide=channelSideC;
         }
-        
+
         ltrce->fVecSec->GetMatrixArray()[channelSide]=isector;
         ltrce->fVecP2->GetMatrixArray()[channelSide]=0;
         ltrce->fVecPhi->GetMatrixArray()[channelSide]=0;
@@ -2664,7 +2592,7 @@ void AliTPCCalibCE::AddCEtoIdeal(TObjArray *arr)
         ltrce->fVecLX->GetMatrixArray()[channelSide]=lxyz[0];
         ltrce->fVecLY->GetMatrixArray()[channelSide]=lxyz[1];
 //         ltrce->fVecLZ->GetMatrixArray()[channelSide]=-1;
-        
+
         if (side==0){
           ltrce->fVecGZ->GetMatrixArray()[channelSide]=-0.335;
           ltrce->fVecLZ->GetMatrixArray()[channelSide]=-0.335;
@@ -2678,56 +2606,54 @@ void AliTPCCalibCE::AddCEtoIdeal(TObjArray *arr)
       }
     }
   }
-  
-  
+
+
 }
 
 //_____________________________________________________________________
 void AliTPCCalibCE::CalculateDV(TObjArray * const arrIdeal, TObjArray * const arrMeasured, Int_t burst)
 {
-  //
-  // calculate the drift velocity from the reconstructed clusters associated
-  // to the ideal laser tracks
-  // use two different fit scenarios: Separate fit for A- and C-Side
-  //                                  Common fit for A- and C-Side
-  //
-  
+  /// calculate the drift velocity from the reconstructed clusters associated
+  /// to the ideal laser tracks
+  /// use two different fit scenarios: Separate fit for A- and C-Side
+  ///                                  Common fit for A- and C-Side
+
   if (!fArrFitGraphs){
     fArrFitGraphs=new TObjArray;
   }
-  
+
 //   static TLinearFitter fdriftA(5,"hyp4");
 //   static TLinearFitter fdriftC(5,"hyp4");
 //   static TLinearFitter fdriftAC(6,"hyp5");
   Double_t timestamp=fTimeBursts[burst];
-  
+
   static TLinearFitter fdriftA(4,"hyp3");
   static TLinearFitter fdriftC(4,"hyp3");
   static TLinearFitter fdriftAC(5,"hyp4");
   TVectorD fitA(7),fitC(7),fitAC(8); //fit values+chi2+npoints
-  
+
   Float_t chi2A = 10;
   Float_t chi2C = 10;
   Float_t chi2AC = 10;
   Int_t npointsA=0;
   Int_t npointsC=0;
   Int_t npointsAC=0;
-  
+
   Double_t minres[3]={20.,1,0.8};
   //----
   for(Int_t i=0;i<3;i++){
-    
+
     fdriftA.ClearPoints();
     fdriftC.ClearPoints();
     fdriftAC.ClearPoints();
-    
+
     chi2A = 10;
     chi2C = 10;
     chi2AC = 10;
     npointsA=0;
     npointsC=0;
     npointsAC=0;
-    
+
     for (Int_t itrack=0; itrack<338; ++itrack){
       AliTPCLaserTrack *iltr=(AliTPCLaserTrack*)arrIdeal->UncheckedAt(itrack);
       AliTPCLaserTrack *mltr=(AliTPCLaserTrack*)arrMeasured->UncheckedAt(itrack);
@@ -2736,47 +2662,47 @@ void AliTPCCalibCE::CalculateDV(TObjArray * const arrIdeal, TObjArray * const ar
       if ((itrack%7==0||itrack%7==6)&&itrack<336) continue;
       Int_t clustercounter=0;
       Int_t indexMax=159;
-      
+
       //-- exclude the low intensity tracks
-      
+
       for (Int_t index=0; index<indexMax; ++index){
-        
+
         Double_t mGx=mltr->fVecGX->GetMatrixArray()[index];
         Double_t mGy=mltr->fVecGY->GetMatrixArray()[index];
         Double_t mGz=mltr->fVecGZ->GetMatrixArray()[index];
-        
+
         if (TMath::Abs(mGz)<1e-20 && TMath::Abs(mGy)<1e-20 && TMath::Abs(mGx)<1e-20) clustercounter++;
       }
       if (clustercounter>130&&itrack<336) continue; // don't accept tracks with <= 159-130=29 clusters
       clustercounter=0;
 
-      
+
       //-- drift length
       Double_t zlength = (iltr->GetSide()==0)? fParam->GetZLength(36): fParam->GetZLength(71);
-      
+
       if (itrack>335) indexMax=557568/2;
       for (Int_t index=0; index<indexMax; ++index){
         Double_t iGx=iltr->fVecGX->GetMatrixArray()[index];
         Double_t iGy=iltr->fVecGY->GetMatrixArray()[index];
         Double_t iGz=iltr->fVecGZ->GetMatrixArray()[index];
         Double_t iR=TMath::Sqrt(iGx*iGx+iGy*iGy);
-        
+
         Double_t mGx=mltr->fVecGX->GetMatrixArray()[index];
         Double_t mGy=mltr->fVecGY->GetMatrixArray()[index];
         Double_t mGz=mltr->fVecGZ->GetMatrixArray()[index];
         Double_t mR=TMath::Sqrt(mGx*mGx+mGy*mGy);
-        
+
       //cut if no track info available
         if (iltr->GetBundle()==0) continue;
         if (iR<133||mR<133) continue;
         if(TMath::Abs(mltr->fVecP2->GetMatrixArray()[index])>minres[i]) continue;
-        
+
         Double_t ldrift  = (iltr->GetSide()==0)?zlength-iGz:iGz+zlength;
         Double_t mdrift  = (iltr->GetSide()==0)?zlength-mGz:mGz+zlength;
-        
+
         //Double_t xxx[4] = {ldrift,iGy*ldrift/(zlength*250.), 250.-mR, iltr->fVecSec->GetMatrixArray()[index]>35};
         Double_t xxx[3] = {ldrift,iGy*ldrift/(zlength*250.), 250.-mR};
-        
+
         if (iltr->GetSide()==0){
           fdriftA.AddPoint(xxx,mdrift,1);
         }else{
@@ -2785,30 +2711,30 @@ void AliTPCCalibCE::CalculateDV(TObjArray * const arrIdeal, TObjArray * const ar
 //         Double_t xxx2[4] = { ldrift,iGy*ldrift/(zlength*250.), 250.-mR, iltr->fVecSec->GetMatrixArray()[index]>35, iltr->GetSide()};
         Double_t xxx2[4] = { ldrift,iGy*ldrift/(zlength*250.), 250.-mR, static_cast<Double_t>(iltr->GetSide())};
         fdriftAC.AddPoint(xxx2,mdrift,1);
-        
+
       }//end index loop
     }//end laser track loop
-    
+
   //perform fit
     fdriftA.Eval();
     fdriftC.Eval();
     fdriftAC.Eval();
-    
-    
-    
+
+
+
   //get fit values
     fdriftA.GetParameters(fitA);
     fdriftC.GetParameters(fitC);
     fdriftAC.GetParameters(fitAC);
-    
+
   //Parameters:  0 linear offset
   //             1 mean drift velocity correction factor
   //             2 relative global y gradient
   //             3 radial deformation
   //             4 IROC/OROC offset
-    
+
 //      FindResiduals(arrMeasured,arrIdeal,fitA,fitC);
-    
+
     for (Int_t itrack=0; itrack<338; ++itrack){
       AliTPCLaserTrack *iltr=(AliTPCLaserTrack*)arrIdeal->UncheckedAt(itrack);
       AliTPCLaserTrack *mltr=(AliTPCLaserTrack*)arrMeasured->UncheckedAt(itrack);
@@ -2838,49 +2764,49 @@ void AliTPCCalibCE::CalculateDV(TObjArray * const arrIdeal, TObjArray * const ar
         Double_t iGy=iltr->fVecGY->GetMatrixArray()[index];
         Double_t iGz=iltr->fVecGZ->GetMatrixArray()[index];
         Double_t iR=TMath::Sqrt(iGx*iGx+iGy*iGy);
-        
+
         Double_t mGx=mltr->fVecGX->GetMatrixArray()[index];
         Double_t mGy=mltr->fVecGY->GetMatrixArray()[index];
         Double_t mGz=mltr->fVecGZ->GetMatrixArray()[index];
         Double_t mR=TMath::Sqrt(mGx*mGx+mGy*mGy);
-        
+
       //cut if no track info available
         if (iR<60||mR<60) continue;
-        
+
         Double_t ldrift  = (iltr->GetSide()==0)?zlength-iGz:iGz+zlength;
         Double_t mdrift  = (iltr->GetSide()==0)?zlength-mGz:mGz+zlength;
-        
+
         TVectorD *v=&fitA;
         if (iltr->GetSide()==1) v=&fitC;
 //         Double_t iCorr=(*v)[0]+(*v)[1]*ldrift+(*v)[2]*iGy*ldrift/(zlength*250.)+(*v)[3]*(250.-mR)+(*v)[4]*( iltr->fVecSec->GetMatrixArray()[index]>35);
         Double_t iCorr=(*v)[0]+(*v)[1]*ldrift+(*v)[2]*iGy*ldrift/(zlength*250.)+(*v)[3]*(250.-mR);
-        
+
         mltr->fVecP2->GetMatrixArray()[index]=mdrift-iCorr;
-        
+
       }
     }
-    
+
     fitA.ResizeTo(7);
     fitC.ResizeTo(7);
     fitAC.ResizeTo(8);
-    
+
 //set statistics values
 
     npointsA= fdriftA.GetNpoints();
     if (npointsA>0) chi2A = fdriftA.GetChisquare()/fdriftA.GetNpoints();
     fitA[5]=npointsA;
     fitA[6]=chi2A;
-    
+
     npointsC= fdriftC.GetNpoints();
     if (npointsC>0) chi2C = fdriftC.GetChisquare()/fdriftC.GetNpoints();
     fitC[5]=npointsC;
     fitC[6]=chi2C;
-    
+
     npointsAC= fdriftAC.GetNpoints();
     if (npointsAC>0) chi2AC = fdriftAC.GetChisquare()/fdriftAC.GetNpoints();
     fitAC[5]=npointsAC;
     fitAC[6]=chi2AC;
-    
+
     if (fStreamLevel>2){
     //laser track information
       (*GetDebugStreamer()) << "DriftV" <<
@@ -2891,31 +2817,31 @@ void AliTPCCalibCE::CalculateDV(TObjArray * const arrIdeal, TObjArray * const ar
         "fitC.="  << &fitC <<
         "fitAC.=" << &fitAC <<
         "\n";
-      
-      
+
+
     }
-    
+
   }
 //-----
-  
-  
+
+
   //Parameters:  0 linear offset (global)
   //             1 mean drift velocity correction factor
   //             2 relative global y gradient
   //             3 radial deformation
   //             4 IROC/OROC offset
   //             5 linear offset relative A-C
-  
+
   //get graphs
   TGraphErrors *grA[7];
   TGraphErrors *grC[7];
   TGraphErrors *grAC[8];
   TString names("GRAPH_MEAN_DELAY_LASER_ALL_;GRAPH_MEAN_DRIFT_LASER_ALL_;GRAPH_MEAN_GLOBALYGRADIENT_LASER_ALL_;GRAPH_MEAN_RGRADIENT_LASER_ALL_;GRAPH_MEAN_IROCOROCOFFSET_LASER_ALL_;GRAPH_MEAN_NPOINTS_LASER_ALL_;GRAPH_MEAN_CHI2_LASER_ALL_");
   TString namesAC("GRAPH_MEAN_DELAY_LASER_ALL_;GRAPH_MEAN_DRIFT_LASER_ALL_;GRAPH_MEAN_GLOBALYGRADIENT_LASER_ALL_;GRAPH_MEAN_RGRADIENT_LASER_ALL_;GRAPH_MEAN_IROCOROCOFFSET_LASER_ALL_;GRAPH_MEAN_NPOINTS_LASER_ALL_;GRAPH_MEAN_CHI2_LASER_ALL_;GRAPH_MEAN_DELAYC_LASER_ALL_");
-  
+
   TObjArray *arrNames=names.Tokenize(";");
   TObjArray *arrNamesAC=namesAC.Tokenize(";");
-  
+
   //A-Side graphs
   for (Int_t i=0; i<7; ++i){
     TString grName=arrNames->UncheckedAt(i)->GetName();
@@ -2933,7 +2859,7 @@ void AliTPCCalibCE::CalculateDV(TObjArray * const arrIdeal, TObjArray * const ar
     grA[i]->SetPointError(ipoint,60,.0001);
     if (i<4) grA[i]->SetPointError(ipoint,60,fdriftA.GetCovarianceMatrixElement(i,i));
   }
-  
+
   //C-Side graphs
   for (Int_t i=0; i<7; ++i){
     TString grName=arrNames->UncheckedAt(i)->GetName();
@@ -2951,7 +2877,7 @@ void AliTPCCalibCE::CalculateDV(TObjArray * const arrIdeal, TObjArray * const ar
     grC[i]->SetPointError(ipoint,60,.0001);
     if (i<4) grC[i]->SetPointError(ipoint,60,fdriftC.GetCovarianceMatrixElement(i,i));
   }
-  
+
   //AC-Side graphs
   for (Int_t i=0; i<8; ++i){
     TString grName=arrNamesAC->UncheckedAt(i)->GetName();
@@ -2969,7 +2895,7 @@ void AliTPCCalibCE::CalculateDV(TObjArray * const arrIdeal, TObjArray * const ar
     grAC[i]->SetPointError(ipoint,60,.0001);
     if (i<5) grAC[i]->SetPointError(ipoint,60,fdriftAC.GetCovarianceMatrixElement(i,i));
   }
-  
+
   if (fDebugLevel>10){
     printf("A side fit parameters:\n");
     fitA.Print();
@@ -2985,10 +2911,9 @@ void AliTPCCalibCE::CalculateDV(TObjArray * const arrIdeal, TObjArray * const ar
 //_____________________________________________________________________
 Double_t AliTPCCalibCE::SetBurstHnDrift()
 {
-  //
-  // Create a new THnSparse for the current burst
-  // return the time of the current burst
-  //
+  /// Create a new THnSparse for the current burst
+  /// return the time of the current burst
+
   Int_t i=0;
   for(i=0; i<fTimeBursts.GetNrows(); ++i){
     if(fTimeBursts.GetMatrixArray()[i]<1.e-20) break;
@@ -2997,7 +2922,7 @@ Double_t AliTPCCalibCE::SetBurstHnDrift()
       return fTimeBursts(i);
     }
   }
-  
+
   CreateDVhist();
   fArrHnDrift.AddAt(fHnDrift,i);
   fTimeBursts.GetMatrixArray()[i]=fTimeStamp;
@@ -3012,25 +2937,23 @@ Double_t AliTPCCalibCE::SetBurstHnDrift()
 //_____________________________________________________________________
 void AliTPCCalibCE::DumpToFile(const Char_t *filename, const Char_t *dir, Bool_t /*append*/)
 {
-  //
-  //  Write class to file
-  //  option can be specified in the dir option:
-  //  options:
-  //    name=<objname>: the name of the calibration object in file will be <objname>
-  //    type=<type>:    the saving type:
-  //                    0 - write the complte object
-  //                    1 - Store the histogram arrays separately to make the streamed object smaller, Analyse to be called
-  //                    2 - like 2, but in addition delete objects that will most probably not be used for calibration
-  //                    3 - store only calibration output, don't store the reference histograms
-  //                        and THnSparse (requires Analyse called before)
-  //
-  //  NOTE: to read the object back, the ReadFromFile function should be used
-  //
-  
+  ///  Write class to file
+  ///  option can be specified in the dir option:
+  ///  options:
+  ///    name=<objname>: the name of the calibration object in file will be <objname>
+  ///    type=<type>:    the saving type:
+  ///                    0 - write the complte object
+  ///                    1 - Store the histogram arrays separately to make the streamed object smaller, Analyse to be called
+  ///                    2 - like 2, but in addition delete objects that will most probably not be used for calibration
+  ///                    3 - store only calibration output, don't store the reference histograms
+  ///                        and THnSparse (requires Analyse called before)
+  ///
+  ///  NOTE: to read the object back, the ReadFromFile function should be used
+
   TString sDir(dir);
   TString objName=GetName();
   Int_t type=0;
-  
+
   //get options
   TObjArray *arr=sDir.Tokenize(",");
   TIter next(arr);
@@ -3078,7 +3001,7 @@ void AliTPCCalibCE::DumpToFile(const Char_t *filename, const Char_t *dir, Bool_t
     fParamArrayEventPol1.Delete();
     fParamArrayEventPol2.Delete();
   }
-  
+
   TObjArray histoQArray(72);
   TObjArray histoT0Array(72);
   TObjArray histoRMSArray(72);
@@ -3098,17 +3021,17 @@ void AliTPCCalibCE::DumpToFile(const Char_t *filename, const Char_t *dir, Bool_t
     fHistoQArray.Clear();
     fHistoT0Array.Clear();
     fHistoRMSArray.Clear();
-    
+
     for (Int_t i=0;i<fArrHnDrift.GetEntries();++i){
       arrHnDrift.AddAt(fArrHnDrift.UncheckedAt(i),i);
     }
     fArrHnDrift.SetOwner(kFALSE);
     fArrHnDrift.Clear();
   }
-  
-  
+
+
   TDirectory *backup = gDirectory;
-  
+
   TFile f(filename,"recreate");
   Write(objName.Data());
   if (type==1||type==2) {
@@ -3137,18 +3060,16 @@ void AliTPCCalibCE::DumpToFile(const Char_t *filename, const Char_t *dir, Bool_t
     }
     fArrHnDrift.SetOwner(kTRUE);
   }
-  
+
   if ( backup ) backup->cd();
 }
 //_____________________________________________________________________
 AliTPCCalibCE* AliTPCCalibCE::ReadFromFile(const Char_t *filename)
 {
-  //
-  // Read object from file
-  // Handle properly if the histogram arrays were stored separately
-  // call Analyse to make sure to have the calibration relevant information in the object
-  //
-  
+  /// Read object from file
+  /// Handle properly if the histogram arrays were stored separately
+  /// call Analyse to make sure to have the calibration relevant information in the object
+
   TFile f(filename);
   if (!f.IsOpen() || f.IsZombie() ) return 0x0;
   TList *l=f.GetListOfKeys();
@@ -3161,7 +3082,7 @@ AliTPCCalibCE* AliTPCCalibCE::ReadFromFile(const Char_t *filename)
   TObjArray *histoT0Array=0x0;
   TObjArray *histoRMSArray=0x0;
   TObjArray *arrHnDrift=0x0;
-  
+
   while ( (key=(TKey*)next()) ){
     o=key->ReadObj();
     if ( o->IsA()==AliTPCCalibCE::Class() ){
@@ -3186,7 +3107,7 @@ AliTPCCalibCE* AliTPCCalibCE::ReadFromFile(const Char_t *filename)
       }
       ce->fHistoQArray.SetOwner(kTRUE);
     }
-    
+
     if (histoT0Array) {
       for (Int_t i=0; i<72; ++i){
         hist=(TH1*)histoT0Array->UncheckedAt(i);
@@ -3195,7 +3116,7 @@ AliTPCCalibCE* AliTPCCalibCE::ReadFromFile(const Char_t *filename)
       }
       ce->fHistoT0Array.SetOwner(kTRUE);
     }
-    
+
     if (histoRMSArray){
       for (Int_t i=0; i<72; ++i){
         hist=(TH1*)histoRMSArray->UncheckedAt(i);
@@ -3204,17 +3125,17 @@ AliTPCCalibCE* AliTPCCalibCE::ReadFromFile(const Char_t *filename)
       }
       ce->fHistoRMSArray.SetOwner(kTRUE);
     }
-    
+
     if (arrHnDrift){
       for (Int_t i=0; i<arrHnDrift->GetEntries(); ++i){
         THnSparseI *hSparse=(THnSparseI*)arrHnDrift->UncheckedAt(i);
         ce->fArrHnDrift.AddAt(hSparse,i);
       }
     }
-    
+
     ce->Analyse();
   }
   f.Close();
-  
+
   return ce;
 }
diff --git a/TPC/TPCbase/AliTPCCalibCE.h b/TPC/TPCbase/AliTPCCalibCE.h
index 5f0b3479188..19c2587da80 100644
--- a/TPC/TPCbase/AliTPCCalibCE.h
+++ b/TPC/TPCbase/AliTPCCalibCE.h
@@ -3,11 +3,8 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-////////////////////////////////////////////////////////////////////////////////////////
-//                                                                                    //
-//             Implementation of the TPC Central Electrode calibration                //
-//                                                                                    //
-////////////////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCCalibCE
+/// \brief Implementation of the TPC Central Electrode calibration
 
 #include <TVectorT.h>
 #include <THnSparse.h>
@@ -30,36 +27,36 @@ class TCollection;
 struct eventHeaderStruct;
 
 class AliTPCCalibCE : public AliTPCCalibRawBase {
-  
+
 public:
   AliTPCCalibCE();
   AliTPCCalibCE(const AliTPCCalibCE &sig);
   AliTPCCalibCE(const TMap *config);
   virtual ~AliTPCCalibCE();
-  
+
   AliTPCCalibCE& operator = (const  AliTPCCalibCE &source);
-  
+
   virtual Int_t Update(const Int_t isector, const Int_t iRow, const Int_t iPad,
                        const Int_t iTimeBin, const Float_t signal);
   virtual void ProcessBunch(const Int_t sector, const Int_t row, const Int_t pad,
                             const Int_t length, const UInt_t startTimeBin, const UShort_t* signal);
-  
+
   virtual void Analyse();
   void AnalyseTrack();
-  
+
     //
   AliTPCCalROC* GetCalRocT0  (Int_t sector, Bool_t force=kFALSE);  // get calibration object - sector
   AliTPCCalROC* GetCalRocT0Err(Int_t sector, Bool_t force=kFALSE);  // get calibration object - sector
   AliTPCCalROC* GetCalRocQ   (Int_t sector, Bool_t force=kFALSE);  // get calibration object - sector
   AliTPCCalROC* GetCalRocRMS(Int_t sector, Bool_t force=kFALSE);  // get calibration object - sector
   AliTPCCalROC* GetCalRocOutliers(Int_t sector, Bool_t force=kFALSE);  // get calibration object - sector
-  
+
   const TObjArray* GetCalPadT0()    const { return &fCalRocArrayT0; }      // get calibration object
   const TObjArray* GetCalPadT0Err() const { return &fCalRocArrayT0Err; }      // get calibration object
   const TObjArray* GetCalPadQ()     const { return &fCalRocArrayQ;  }      // get calibration object
   const TObjArray* GetCalPadRMS()   const { return &fCalRocArrayRMS;}      // get calibration object
   const TObjArray* GetCalPadOutliers() const { return &fCalRocArrayOutliers;}      // get calibration object
-  
+
   TH2S* GetHistoQ  (Int_t sector, Bool_t force=kFALSE);           // get refernce histogram
   TH2S* GetHistoT0 (Int_t sector, Bool_t force=kFALSE);           // get refernce histogram
   TH2S* GetHistoRMS(Int_t sector, Bool_t force=kFALSE);           // get refernce histogram
@@ -67,28 +64,28 @@ public:
   Float_t GetMeanT0rms() const {return fMeanT0rms;}
   Float_t GetMeanQrms() const {return fMeanQrms;}
   Float_t GetMeanRMSrms() const {return fMeanRMSrms;}
-  
+
   Int_t   GetPeakDetectionMinus() const {return fPeakDetMinus;}
   Int_t   GetPeakDetectionPlus()  const {return fPeakDetPlus;}
   Int_t   GetPeakIntRangeMinus() const {return fPeakIntMinus;}
   Int_t   GetPeakIntRangePlus()  const {return fPeakIntPlus;}
   Float_t GetNnoiseThresholdMax() const {return fNoiseThresholdMax;}
   Float_t GetNnoiseThresholdSum() const {return fNoiseThresholdSum;}
-  
+
   TH1S* GetHistoTmean(Int_t sector, Bool_t force=kFALSE);           // get refernce histogram
-  
+
     //needed here to merge ClibCE objects
   TObjArray* GetParamArrayPol1(Int_t sector, Bool_t force=kFALSE);
   TObjArray* GetParamArrayPol2(Int_t sector, Bool_t force=kFALSE);
-  
+
 //    TObjArray*  GetTMeanArrayEvent(){ return &fTMeanArrayEvent; }
 //    TObjArray*  GetQMeanArrayEvent(){ return &fQMeanArrayEvent; }
   TVectorF* GetTMeanEvents(Int_t sector, Bool_t force=kFALSE);
   TVectorF* GetQMeanEvents(Int_t sector, Bool_t force=kFALSE);
-  
+
   const TVectorD*   GetEventTimes()  const   { return &fVEventTime;      }
   const TVectorD*   GetEventIds()    const   { return &fVEventNumber;    }
-  
+
   //
   void  SetRangeRefQ  (Int_t nBins, Float_t xMin, Float_t xMax){ fNbinsQ   = nBins; fXminQ   = xMin; fXmaxQ   = xMax; }   //Set range for Q reference histograms
   void  SetRangeRefT0 (Int_t nBins, Float_t xMin, Float_t xMax){ fNbinsT0  = nBins; fXminT0  = xMin; fXmaxT0  = xMax; }   //Set range for T0 reference histograms
@@ -109,170 +106,170 @@ public:
   void SetProcessNew(Bool_t process=kTRUE) {fProcessNew=process; if (process&&!fHnDrift) CreateDVhist(); }
   //Getters
   Int_t GetNeventsProcessed() const { return fNevents; }
-  
+
   Bool_t GetIsZeroSuppressed() const { return fIsZeroSuppressed; }
-  
+
   Float_t  GetSecRejectRatio() const { return fSecRejectRatio; }
 
   const TVectorF *GetTime0Side(Int_t side=0) const {return (side==0)?&fVTime0SideA:&fVTime0SideC;}
   Float_t GetPeakIntegralMinus() const {return fPeakIntMinus;}
   Float_t GetPeakIntegralPlus() const {return fPeakIntPlus;}
-  
-  
+
+
   void Merge(AliTPCCalibCE * const ce);
   virtual Long64_t Merge(TCollection * const list);
-  
+
   TGraph *MakeGraphTimeCE(Int_t sector, Int_t xVariable=0, Int_t fitType=0, Int_t fitParameter=0);
 
   //
   // New functions using also the laser tracks
   //
   Bool_t IsEdgePad(Int_t sector, Int_t row, Int_t pad) const;
-  
+
   void FindLocalMaxima(TObjArray * const arrObj, Double_t timestamp, Int_t burst);
   Int_t FindLaserTrackID(Int_t sector,Int_t row, const Double_t *peakpos,Double_t &mindist, const Double_t *peakposloc, Int_t &itrackMin2);
-  
+
   const THnSparseI *GetHnDrift() const {return fHnDrift;}
   const TObjArray& GetArrHnDrift() const {return fArrHnDrift;}
   const TVectorD&  GetTimeBursts() const {return fTimeBursts;}
   const TObjArray  *GetArrFitGraphs() const {return fArrFitGraphs;}
 
   virtual void DumpToFile(const Char_t *filename, const Char_t *dir="", Bool_t append=kFALSE);
-  
+
   static AliTPCCalibCE *ReadFromFile(const Char_t *filename);
-  
+
 protected:
   virtual void EndEvent();
   virtual void ResetEvent();
-  
+
 private:
     // reference histogram ranges
-  Int_t   fNbinsT0;                 //  Number of bins for T0 reference histogram
-  Float_t fXminT0;                  //  xmin   of T0 reference histogram
-  Float_t fXmaxT0;                  //  xmax   of T0 reference histogram
-  Int_t   fNbinsQ;                  //  Number of bins for T0 reference histogram
-  Float_t fXminQ;                   //  xmin   of T0 reference histogram
-  Float_t fXmaxQ;                   //  xmax   of T0 reference histogram
-  Int_t   fNbinsRMS;                //  Number of bins for T0 reference histogram
-  Float_t fXminRMS;                 //  xmin   of T0 reference histogram
-  Float_t fXmaxRMS;                 //  xmax   of T0 reference histogram
-  Int_t   fPeakDetMinus;               //  Consecutive timebins on rising edge to be regarded as a signal
-  Int_t   fPeakDetPlus;                //  Consecutive timebins on falling edge to be regarded as a signal
-  Int_t   fPeakIntMinus;            //  Peak integral range for COG determination. Bins used before max bin
-  Int_t   fPeakIntPlus;             //  Peak integral range for COG determination. Bins used after max bin
-  Float_t fNoiseThresholdMax;       //  Analysis Treshold for signal finding: Max>fNoiseThresholdMax*PadNoise
-  Float_t fNoiseThresholdSum;       //  Analysis Treshold for signal finding: Sum>fNoiseThresholdSum*PadNoise
-  
-  Bool_t  fIsZeroSuppressed;        //  If data is Zero Suppressed -> Don't subtrakt pedestals!
-  
-  Int_t     fLastSector;            //! Last sector processed
-  
-  Float_t   fSecRejectRatio;        //! Needed percentage of signals in one chamber. Below it will be rejected
+  Int_t   fNbinsT0;                 ///< Number of bins for T0 reference histogram
+  Float_t fXminT0;                  ///< xmin   of T0 reference histogram
+  Float_t fXmaxT0;                  ///< xmax   of T0 reference histogram
+  Int_t   fNbinsQ;                  ///< Number of bins for T0 reference histogram
+  Float_t fXminQ;                   ///< xmin   of T0 reference histogram
+  Float_t fXmaxQ;                   ///< xmax   of T0 reference histogram
+  Int_t   fNbinsRMS;                ///< Number of bins for T0 reference histogram
+  Float_t fXminRMS;                 ///< xmin   of T0 reference histogram
+  Float_t fXmaxRMS;                 ///< xmax   of T0 reference histogram
+  Int_t   fPeakDetMinus;               ///< Consecutive timebins on rising edge to be regarded as a signal
+  Int_t   fPeakDetPlus;                ///< Consecutive timebins on falling edge to be regarded as a signal
+  Int_t   fPeakIntMinus;            ///< Peak integral range for COG determination. Bins used before max bin
+  Int_t   fPeakIntPlus;             ///< Peak integral range for COG determination. Bins used after max bin
+  Float_t fNoiseThresholdMax;       ///< Analysis Treshold for signal finding: Max>fNoiseThresholdMax*PadNoise
+  Float_t fNoiseThresholdSum;       ///< Analysis Treshold for signal finding: Sum>fNoiseThresholdSum*PadNoise
+
+  Bool_t  fIsZeroSuppressed;        ///< If data is Zero Suppressed -> Don't subtrakt pedestals!
+
+  Int_t     fLastSector;            //!< Last sector processed
+
+  Float_t   fSecRejectRatio;        //!< Needed percentage of signals in one chamber. Below it will be rejected
                                       //  This is neede if we do not process a laser event
-  
-  AliTPCParam *fParam;              //! TPC information
-  
-  AliTPCCalPad *fPedestalTPC;       //! Pedestal Information whole TPC
-  AliTPCCalPad *fPadNoiseTPC;       //! Pad noise Information whole TPC
-  AliTPCCalROC *fPedestalROC;       //! Pedestal Information for current ROC
-  AliTPCCalROC *fPadNoiseROC;       //! Pad noise Information for current ROC
-  
-  TObjArray fCalRocArrayT0;         //  Array of AliTPCCalROC class for Time0 calibration
-  TObjArray fCalRocArrayT0Err;      //  Array of AliTPCCalROC class for the error (rms) of Time0 calibration
-  TObjArray fCalRocArrayQ;          //  Array of AliTPCCalROC class for Charge calibration
-  TObjArray fCalRocArrayRMS;        //  Array of AliTPCCalROC class for signal width calibration
-  TObjArray fCalRocArrayOutliers;   //  Array of AliTPCCalROC class for signal outliers
-  
-  TObjArray fHistoQArray;           //  Calibration histograms for Charge distribution
-  TObjArray fHistoT0Array;          //  Calibration histograms for Time0  distribution
-  TObjArray fHistoRMSArray;         //  Calibration histograms for signal width distribution
-  
-  Float_t   fMeanT0rms;             // mean of the rms of all pad T0  fits, used as error estimation of T0 results
-  Float_t   fMeanQrms;              // mean of the rms of all pad Q   fits, used as error estimation of Q results
-  Float_t   fMeanRMSrms;            // mean of the rms of all pad TMS fits, used as error estimation of RMS results
-  
-  TObjArray fHistoTmean;            //! Calibration histograms of the mean CE position for all sectors
-  
-  TObjArray fParamArrayEventPol1;   //  Store mean arrival time parameters for each sector event by event from global plane fit
-  TObjArray fParamArrayEventPol2;   //  Store mean arrival time parameters for each sector event by event from global parabola fit
-  TObjArray fTMeanArrayEvent;       //  Store mean arrival time for each sector event by event
-  TObjArray fQMeanArrayEvent;       //  Store mean arrival Charge for each sector event by event
-  TVectorD  fVEventTime;            //  Timestamps of the events
-  TVectorD  fVEventNumber;          //  Eventnumbers of the events
-  TVectorF  fVTime0SideA;           //  Mean Time0 for side A for all events
-  TVectorF  fVTime0SideC;           //  Mean Time0 for side C for all events
-  Double_t  fEventId;               //! Event Id of the current event
-  UInt_t  fOldRunNumber;          //! Old Run Number
-  
-  TObjArray fPadTimesArrayEvent;    //! Pad Times for the event, before mean Time0 corrections
-  TObjArray fPadQArrayEvent;        //! Charge for the event, only needed for debugging streamer
-  TObjArray fPadRMSArrayEvent;      //! Signal width for the event, only needed for debugging streamer
-  TObjArray fPadPedestalArrayEvent; //! Signal width for the event, only needed for debugging streamer
-  
-  Int_t     fCurrentChannel;        //! current channel processed
-  Int_t     fCurrentSector;         //! current sector processed
-  Int_t     fCurrentRow;            //! current row processed
-  Float_t   fMaxPadSignal;          //! maximum bin of current pad
-  Int_t     fMaxTimeBin;            //! time bin with maximum value
-  Float_t   fPadSignal[1024];       //! signal of current Pad
-  Float_t   fPadPedestal;           //! Pedestal Value of current pad
-  Float_t   fPadNoise;              //! Noise Value of current pad
-  
-  TVectorD  fVTime0Offset;          //!  Time0 Offset for each sector;
-  TVectorD  fVTime0OffsetCounter;   //!  Time0 Offset counter for each sector;
-  TVectorD  fVMeanQ;                //!  Mean Q for each sector;
-  TVectorD  fVMeanQCounter;         //!  Mean Q counter for each sector;
-  
-  Float_t   fCurrentCETimeRef;      //! Time refernce of the current sector
-  
+
+  AliTPCParam *fParam;              //!< TPC information
+
+  AliTPCCalPad *fPedestalTPC;       //!< Pedestal Information whole TPC
+  AliTPCCalPad *fPadNoiseTPC;       //!< Pad noise Information whole TPC
+  AliTPCCalROC *fPedestalROC;       //!< Pedestal Information for current ROC
+  AliTPCCalROC *fPadNoiseROC;       //!< Pad noise Information for current ROC
+
+  TObjArray fCalRocArrayT0;         ///< Array of AliTPCCalROC class for Time0 calibration
+  TObjArray fCalRocArrayT0Err;      ///< Array of AliTPCCalROC class for the error (rms) of Time0 calibration
+  TObjArray fCalRocArrayQ;          ///< Array of AliTPCCalROC class for Charge calibration
+  TObjArray fCalRocArrayRMS;        ///< Array of AliTPCCalROC class for signal width calibration
+  TObjArray fCalRocArrayOutliers;   ///< Array of AliTPCCalROC class for signal outliers
+
+  TObjArray fHistoQArray;           ///< Calibration histograms for Charge distribution
+  TObjArray fHistoT0Array;          ///< Calibration histograms for Time0  distribution
+  TObjArray fHistoRMSArray;         ///< Calibration histograms for signal width distribution
+
+  Float_t   fMeanT0rms;             ///< mean of the rms of all pad T0  fits, used as error estimation of T0 results
+  Float_t   fMeanQrms;              ///< mean of the rms of all pad Q   fits, used as error estimation of Q results
+  Float_t   fMeanRMSrms;            ///< mean of the rms of all pad TMS fits, used as error estimation of RMS results
+
+  TObjArray fHistoTmean;            //!< Calibration histograms of the mean CE position for all sectors
+
+  TObjArray fParamArrayEventPol1;   ///< Store mean arrival time parameters for each sector event by event from global plane fit
+  TObjArray fParamArrayEventPol2;   ///< Store mean arrival time parameters for each sector event by event from global parabola fit
+  TObjArray fTMeanArrayEvent;       ///< Store mean arrival time for each sector event by event
+  TObjArray fQMeanArrayEvent;       ///< Store mean arrival Charge for each sector event by event
+  TVectorD  fVEventTime;            ///< Timestamps of the events
+  TVectorD  fVEventNumber;          ///< Eventnumbers of the events
+  TVectorF  fVTime0SideA;           ///< Mean Time0 for side A for all events
+  TVectorF  fVTime0SideC;           ///< Mean Time0 for side C for all events
+  Double_t  fEventId;               //!< Event Id of the current event
+  UInt_t  fOldRunNumber;          //!< Old Run Number
+
+  TObjArray fPadTimesArrayEvent;    //!< Pad Times for the event, before mean Time0 corrections
+  TObjArray fPadQArrayEvent;        //!< Charge for the event, only needed for debugging streamer
+  TObjArray fPadRMSArrayEvent;      //!< Signal width for the event, only needed for debugging streamer
+  TObjArray fPadPedestalArrayEvent; //!< Signal width for the event, only needed for debugging streamer
+
+  Int_t     fCurrentChannel;        //!< current channel processed
+  Int_t     fCurrentSector;         //!< current sector processed
+  Int_t     fCurrentRow;            //!< current row processed
+  Float_t   fMaxPadSignal;          //!< maximum bin of current pad
+  Int_t     fMaxTimeBin;            //!< time bin with maximum value
+  Float_t   fPadSignal[1024];       //!< signal of current Pad
+  Float_t   fPadPedestal;           //!< Pedestal Value of current pad
+  Float_t   fPadNoise;              //!< Noise Value of current pad
+
+  TVectorD  fVTime0Offset;          //!< Time0 Offset for each sector;
+  TVectorD  fVTime0OffsetCounter;   //!< Time0 Offset counter for each sector;
+  TVectorD  fVMeanQ;                //!< Mean Q for each sector;
+  TVectorD  fVMeanQCounter;         //!< Mean Q counter for each sector;
+
+  Float_t   fCurrentCETimeRef;      //!< Time refernce of the current sector
+
   // new part of the algorithm
-  Bool_t      fProcessOld;             // Whether to use the old algorithm
-  Bool_t      fProcessNew;             // Whether to use the new algorithm
-  Bool_t      fAnalyseNew;             //! Whether to analyse the new part of the algorithm.
+  Bool_t      fProcessOld;             ///< Whether to use the old algorithm
+  Bool_t      fProcessNew;             ///< Whether to use the new algorithm
+  Bool_t      fAnalyseNew;             //!< Whether to analyse the new part of the algorithm.
                                        //In the DA this needs to be switched off, in the Preprocessor on...
   enum {kHnBinsDV=5};
-  THnSparseI *fHnDrift;                //! Histogram digits for each pad and timebin for several timestamps
-  TObjArray   fArrHnDrift;             // array of sparse histograms for each burst
-  TVectorD    fTimeBursts;             //  time stamps of bursts
-  UInt_t      fBinsLastAna[100];       // number of bin in the THnSparse during the last analysis
-  UShort_t    fPeaks[14];               //! Peak position: 4 laser layers and CE
-  UShort_t    fPeakWidths[14];          //! Peak window widths
-  TObjArray  *fArrFitGraphs;           // Fit resut graphs for each parameter
-  UInt_t      fEventInBunch;           //! event in current bunch
-  
-  
+  THnSparseI *fHnDrift;                //!< Histogram digits for each pad and timebin for several timestamps
+  TObjArray   fArrHnDrift;             ///< array of sparse histograms for each burst
+  TVectorD    fTimeBursts;             ///< time stamps of bursts
+  UInt_t      fBinsLastAna[100];       ///< number of bin in the THnSparse during the last analysis
+  UShort_t    fPeaks[14];               //!< Peak position: 4 laser layers and CE
+  UShort_t    fPeakWidths[14];          //!< Peak window widths
+  TObjArray  *fArrFitGraphs;           ///< Fit resut graphs for each parameter
+  UInt_t      fEventInBunch;           //!< event in current bunch
+
+
   //
   void   FindPedestal(Float_t part=.6);
   void   UpdateCETimeRef(); //Get the time reference of the last valid measurement in sector
   void   FindCESignal(TVectorD &param, Float_t &qSum, const TVectorF maxima);
   void   FindLocalMaxima(TVectorF &maxima);
   Bool_t IsPeak(Int_t pos, Int_t tminus, Int_t tplus) const;
-  
+
   TH2S* GetHisto(Int_t sector, TObjArray *arr,
                  Int_t nbinsY, Float_t ymin, Float_t ymax,
                  const Char_t *type, Bool_t force);
   TH1S* GetHisto(Int_t sector, TObjArray *arr,
                  const Char_t *type, Bool_t force);
-  
+
   AliTPCCalROC* GetCalRoc(Int_t sector, TObjArray* arr, Bool_t force) const;
-  
+
   TVectorF* GetVectSector(Int_t sector, TObjArray *arr, UInt_t size, Bool_t force=kFALSE) const;
   TVectorF* GetPadTimesEvent(Int_t sector, Bool_t force=kFALSE);
-  
+
   TObjArray* GetParamArray(Int_t sector, TObjArray *arr, Bool_t force=kFALSE) const;
-  
+
   void ResetPad();
   void ProcessPad();
 
   // new part of the algorithm
   void CreateDVhist();
-  
+
   void   FindLaserLayers();
   Bool_t IsPeakInRange(UShort_t timebin, Int_t roc) const;
 
   TObjArray *SetupMeasured();
   void ResetMeasured(TObjArray * const arr);
-  
+
   void AddCEtoIdeal(TObjArray *arr);
 
   void CalculateDV(TObjArray * const arrIdeal, TObjArray * const arrMeasured, Int_t burst);
@@ -281,17 +278,18 @@ private:
   TVectorF* GetPadQEvent(Int_t sector, Bool_t force=kFALSE);
   TVectorF* GetPadRMSEvent(Int_t sector, Bool_t force=kFALSE);
   TVectorF* GetPadPedestalEvent(Int_t sector, Bool_t force=kFALSE);
-  
+
+  /// \cond CLASSIMP
   ClassDef(AliTPCCalibCE,10)  //Implementation of the TPC Central Electrode calibration
+  /// \endcond
 };
 
 //Inline functions
 //_____________________________________________________________________
 inline Bool_t AliTPCCalibCE::IsPeakInRange(UShort_t timebin, Int_t roc) const
 {
-  //
-  // Check whether timebin is in the range of a laser layer
-  //
+  /// Check whether timebin is in the range of a laser layer
+
   Int_t side=(roc/18)%2;
   Int_t add=7*side;
 //   return kTRUE;
diff --git a/TPC/TPCbase/AliTPCCalibGlobalMisalignment.cxx b/TPC/TPCbase/AliTPCCalibGlobalMisalignment.cxx
index b1f98fe898d..4bf1486752c 100644
--- a/TPC/TPCbase/AliTPCCalibGlobalMisalignment.cxx
+++ b/TPC/TPCbase/AliTPCCalibGlobalMisalignment.cxx
@@ -14,18 +14,17 @@
  **************************************************************************/
 
 
-////////////////////////////////////////////////////////////////////////////
-//                                                                        //
-// AliTPCCalibGlobalMisalignment class                                        //
-// The class calculates the space point distortions due to simple         // 
-// misalignments like shifts in caresian coordinates or a rotation        //
-// of the TPC read out planes (A and C side)                              //
-// Optionaly possible to use it for visualization of the alignemnt form the Alignment OCDB //
-// fUseGeoManager has to be set to kTRUE to enable this option
-//                                                                        //
-// date: 06/05/2010                                                       //
-// Authors: Stefan Rossegger, Jim Thomas, Magnus Mager                    //
-////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCCalibGlobalMisalignment
+///
+/// AliTPCCalibGlobalMisalignment class
+/// The class calculates the space point distortions due to simple
+/// misalignments like shifts in caresian coordinates or a rotation
+/// of the TPC read out planes (A and C side)
+/// Optionaly possible to use it for visualization of the alignemnt form the Alignment OCDB
+/// fUseGeoManager has to be set to kTRUE to enable this option
+///
+/// \author Stefan Rossegger, Jim Thomas, Magnus Mager
+/// \date 06/05/2010
 
 #include "AliTPCCalibGlobalMisalignment.h"
 #include "TMath.h"
@@ -56,15 +55,13 @@ AliTPCCalibGlobalMisalignment::AliTPCCalibGlobalMisalignment()
     fMatrixGlobalDelta(0), // global Alignment Delta A side-c side
     fArraySector(0)   // fArraySector
 {
-  //
-  // default constructor
-  //
+  /// default constructor
+
 }
 
 AliTPCCalibGlobalMisalignment::~AliTPCCalibGlobalMisalignment() {
-  //
-  // destructor
-  //
+  /// destructor
+
   delete fQuadrantQ0;   //OROC medium pads -delta ly+ - ly - shift
   delete fQuadrantRQ0;  //OROC medium pads -delta ly+ - ly - rotation 
   delete fQuadrantQ1;   //OROC long   pads -delta ly+ - ly - shift
@@ -79,11 +76,11 @@ AliTPCCalibGlobalMisalignment::~AliTPCCalibGlobalMisalignment() {
 
 
 Bool_t AliTPCCalibGlobalMisalignment::AddCorrectionCompact(AliTPCCorrection* corr, Double_t weight){
-  //
-  // Add correction  and make them compact
-  // Assumptions:
-  //  - origin of distortion/correction are additive
-  //  - only correction ot the same type supported ()
+  /// Add correction  and make them compact
+  /// Assumptions:
+  ///  - origin of distortion/correction are additive
+  ///  - only correction ot the same type supported ()
+
   if (corr==NULL) {
     //AliError("Zerro pointer - correction");
     return kFALSE;
@@ -202,10 +199,9 @@ Bool_t AliTPCCalibGlobalMisalignment::AddCorrectionCompact(AliTPCCorrection* cor
 
 
 void AliTPCCalibGlobalMisalignment::SetQuadranAlign(const TVectorD *quadrantQ0, const TVectorD *quadrantRQ0, const TVectorD *quadrantQ1,const TVectorD *quadrantRQ1,  const TVectorD *quadrantQ2,  const TVectorD *quadrantRQ2){
-  //
-  // Set quadrant alignment
-  // 6 vectors for 36 (super) sectors
-  //
+  /// Set quadrant alignment
+  /// 6 vectors for 36 (super) sectors
+
   if (quadrantQ0) fQuadrantQ0   = new TVectorD(*quadrantQ0);
   if (quadrantRQ0) fQuadrantRQ0 = new TVectorD(*quadrantRQ0);
   //
@@ -218,30 +214,27 @@ void AliTPCCalibGlobalMisalignment::SetQuadranAlign(const TVectorD *quadrantQ0,
 
 
 void AliTPCCalibGlobalMisalignment::SetAlignGlobal(const TGeoMatrix * matrixGlobal){
-  //
-  // Set global misalignment
-  // Object is OWNER 
-  // 
+  /// Set global misalignment
+  /// Object is OWNER
+
   if (fMatrixGlobal) delete fMatrixGlobal;
   fMatrixGlobal=0;
   if (matrixGlobal) fMatrixGlobal = new TGeoHMatrix(*matrixGlobal);
 }
 
 void AliTPCCalibGlobalMisalignment::SetAlignGlobalDelta(const TGeoMatrix * matrixGlobalDelta){
-  //
-  // Set global misalignment
-  // Object is OWNER 
-  // 
+  /// Set global misalignment
+  /// Object is OWNER
+
   if (fMatrixGlobalDelta) delete fMatrixGlobalDelta;
   fMatrixGlobalDelta=0;
   if (matrixGlobalDelta) fMatrixGlobalDelta = new TGeoHMatrix(*matrixGlobalDelta);
 }
 
 void AliTPCCalibGlobalMisalignment::SetAlignSectors(const TObjArray *arraySector){
-  //
-  // Set misalignment TObjArray of TGeoMatrices  - for each sector
-  // Object is OWNER
-  // 
+  /// Set misalignment TObjArray of TGeoMatrices  - for each sector
+  /// Object is OWNER
+
   if (fArraySector) delete fArraySector;
   fArraySector=0;
   if (arraySector) fArraySector = (TObjArray*)arraySector->Clone();
@@ -269,9 +262,8 @@ void AliTPCCalibGlobalMisalignment::SetAlignSectors(const TObjArray *arraySector
 
 
 void AliTPCCalibGlobalMisalignment::GetCorrection(const Float_t x[],const Short_t roc,Float_t dx[]) {
-  //
-  // Calculates the simple correction due to a shift (in x,y,z) or an rotation of the TPC (around z)
-  //  
+  /// Calculates the simple correction due to a shift (in x,y,z) or an rotation of the TPC (around z)
+
   static AliTPCROC *tpcRoc =AliTPCROC::Instance();  
   Double_t xref  = ( tpcRoc->GetPadRowRadii(0,0)+tpcRoc->GetPadRowRadii(36,tpcRoc->GetNRows(36)-1))*0.5;
   Double_t xquadrant  = tpcRoc->GetPadRowRadii(36,53); // row 53 from uli
@@ -378,9 +370,8 @@ void AliTPCCalibGlobalMisalignment::GetCorrection(const Float_t x[],const Short_
 }
 
 void AliTPCCalibGlobalMisalignment::Print(Option_t* option )  const{
-  //
-  // Print function to check the settings 
-  //
+  /// Print function to check the settings
+
   printf("%s",GetTitle());  
   printf(" - Trivial Misalignments for calibration purposes: \n");
   printf(" - X-Shift: %1.3f cm, Y-Shift: %1.3f cm, Z-Shift: %1.3f cm \n",fXShift,fYShift,fZShift);
@@ -404,9 +395,8 @@ void AliTPCCalibGlobalMisalignment::Print(Option_t* option )  const{
 }
 
 void AliTPCCalibGlobalMisalignment::AddAlign(const  AliTPCCalibGlobalMisalignment & add){
-  //
-  // Add the alignmnet to current object
-  //
+  /// Add the alignmnet to current object
+
   fXShift+=add.fXShift;               // Shift in global X [cm]
   fYShift+=add.fYShift;               // Shift in global Y [cm]
   fZShift+=add.fZShift;               // Shift in global Z [cm]
@@ -465,11 +455,10 @@ void AliTPCCalibGlobalMisalignment::AddAlign(const  AliTPCCalibGlobalMisalignmen
 
 
 AliTPCCalibGlobalMisalignment *  AliTPCCalibGlobalMisalignment::CreateOCDBAlign(){
-  //
-  // Create  AliTPCCalibGlobalMisalignment from OCDB Alignment entry
-  // OCDB has to be initialized before in user code
-  // All storages (defualt and specific)  and run number 
-  //
+  /// Create  AliTPCCalibGlobalMisalignment from OCDB Alignment entry
+  /// OCDB has to be initialized before in user code
+  /// All storages (defualt and specific)  and run number
+
   AliCDBEntry * entry = AliCDBManager::Instance()->Get("TPC/Align/Data");
   if (!entry){
     printf("Missing alignmnet entry. OCDB not initialized?\n");
@@ -508,13 +497,12 @@ AliTPCCalibGlobalMisalignment *  AliTPCCalibGlobalMisalignment::CreateOCDBAlign(
 
 
 AliTPCCalibGlobalMisalignment *  AliTPCCalibGlobalMisalignment::CreateMeanAlign(const AliTPCCalibGlobalMisalignment *alignIn){
-  //
-  // Create new object, disantangle common mean alignmnet and sector alignment
-  //
-  // 1. Try to get mean alignment
-  // 2. Remove mean alignment from sector alignment
-  // 3. Create new object
-  //
+  /// Create new object, disantangle common mean alignmnet and sector alignment
+  ///
+  /// 1. Try to get mean alignment
+  /// 2. Remove mean alignment from sector alignment
+  /// 3. Create new object
+
   TObjArray * array = alignIn->GetAlignSectors();
   TObjArray * arrayNew = new TObjArray(72);
   //
@@ -583,9 +571,8 @@ AliTPCCalibGlobalMisalignment *  AliTPCCalibGlobalMisalignment::CreateMeanAlign(
 
 
 void AliTPCCalibGlobalMisalignment::DumpAlignment( AliTPCCalibGlobalMisalignment* align, TTreeSRedirector *pcstream, const char *name){
-  //
-  // Dump alignment per sector into tree
-  //
+  /// Dump alignment per sector into tree
+
   TObjArray * array = align->GetAlignSectors();
   if (!array) return;
   //
diff --git a/TPC/TPCbase/AliTPCCalibGlobalMisalignment.h b/TPC/TPCbase/AliTPCCalibGlobalMisalignment.h
index e6d9bf8a23f..bdb3a608345 100644
--- a/TPC/TPCbase/AliTPCCalibGlobalMisalignment.h
+++ b/TPC/TPCbase/AliTPCCalibGlobalMisalignment.h
@@ -4,16 +4,15 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-////////////////////////////////////////////////////////////////////////////
-//                                                                        //
-// AliTPCCalibGlobalMisalignment class                                        //
-// The class calculates the space point distortions due to simple         // 
-// misalignments like shifts in caresian coordinates or a rotation        //
-// of the TPC read out planes (A and C side)                              //
-//                                                                        //
-// date: 06/05/2010                                                       //
-// Authors: Stefan Rossegger, Jim Thomas, Magnus Mager                    //
-////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCCalibGlobalMisalignment
+///
+/// AliTPCCalibGlobalMisalignment class
+/// The class calculates the space point distortions due to simple
+/// misalignments like shifts in caresian coordinates or a rotation
+/// of the TPC read out planes (A and C side)
+///
+/// \author Stefan Rossegger, Jim Thomas, Magnus Mager
+/// \date 06/05/2010
 
 #include "AliTPCCorrection.h"
 #include "TVectorD.h"
@@ -67,34 +66,36 @@ protected:
   virtual void GetCorrection(const Float_t x[],const Short_t roc,Float_t dx[]);
 
 private:
-  Float_t fXShift;               // Shift in global X [cm]
-  Float_t fYShift;               // Shift in global Y [cm]
-  Float_t fZShift;               // Shift in global Z [cm]
+  Float_t fXShift;               ///< Shift in global X [cm]
+  Float_t fYShift;               ///< Shift in global Y [cm]
+  Float_t fZShift;               ///< Shift in global Z [cm]
 
-  Float_t fRotPhiA;      // simple rotation of A side read-out plane around the Z axis [rad]
-  Float_t fRotPhiC;      // simple rotation of C side read-out plane around the Z axis [rad]
-  Float_t fdRPhiOffsetA;  // add a constant offset of dRPhi (or local Y) in [cm]: purely for calibration purposes!
-  Float_t fdRPhiOffsetC;  // add a constant offset of dRPhi (or local Y) in [cm]: purely for calibration purposes!
+  Float_t fRotPhiA;      ///< simple rotation of A side read-out plane around the Z axis [rad]
+  Float_t fRotPhiC;      ///< simple rotation of C side read-out plane around the Z axis [rad]
+  Float_t fdRPhiOffsetA;  ///< add a constant offset of dRPhi (or local Y) in [cm]: purely for calibration purposes!
+  Float_t fdRPhiOffsetC;  ///< add a constant offset of dRPhi (or local Y) in [cm]: purely for calibration purposes!
   //
   // Quadrant alignment
   //
-  TVectorD *fQuadrantQ0;   //OROC medium pads -delta ly+ - ly - shift (cm)
-  TVectorD *fQuadrantRQ0;  //OROC medium pads -delta ly+ - ly - rotation (rad) 
-  TVectorD *fQuadrantQ1;   //OROC long   pads -delta ly+ - ly - shift
-  TVectorD *fQuadrantQ2;   //OROC long   pads -shift
-  TVectorD *fQuadrantRQ1;  //OROC long   pads -delta ly+ - ly - rotation
-  TVectorD *fQuadrantRQ2;  //OROC long   pads -rotation
+  TVectorD *fQuadrantQ0;   ///< OROC medium pads -delta ly+ - ly - shift (cm)
+  TVectorD *fQuadrantRQ0;  ///< OROC medium pads -delta ly+ - ly - rotation (rad)
+  TVectorD *fQuadrantQ1;   ///< OROC long   pads -delta ly+ - ly - shift
+  TVectorD *fQuadrantQ2;   ///< OROC long   pads -shift
+  TVectorD *fQuadrantRQ1;  ///< OROC long   pads -delta ly+ - ly - rotation
+  TVectorD *fQuadrantRQ2;  ///< OROC long   pads -rotation
   // 
   //
   // Global alignment - use native ROOT representation
   //
-  TGeoMatrix * fMatrixGlobal; // global Alignment common
-  TGeoMatrix * fMatrixGlobalDelta; // global Alignment common A side-C side
-  TObjArray   * fArraySector; //  local Alignmnet Sector
+  TGeoMatrix * fMatrixGlobal; ///< global Alignment common
+  TGeoMatrix * fMatrixGlobalDelta; ///< global Alignment common A side-C side
+  TObjArray   * fArraySector; ///< local Alignmnet Sector
   //
   AliTPCCalibGlobalMisalignment& operator=(const AliTPCCalibGlobalMisalignment&);
   AliTPCCalibGlobalMisalignment(const AliTPCCalibGlobalMisalignment&);
+  /// \cond CLASSIMP
   ClassDef(AliTPCCalibGlobalMisalignment,3);
+  /// \endcond
 };
 
 #endif
diff --git a/TPC/TPCbase/AliTPCCalibPedestal.cxx b/TPC/TPCbase/AliTPCCalibPedestal.cxx
index 690f7eb5841..9b13b1c5d80 100644
--- a/TPC/TPCbase/AliTPCCalibPedestal.cxx
+++ b/TPC/TPCbase/AliTPCCalibPedestal.cxx
@@ -13,11 +13,9 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
+/// \class AliTPCCalibPedestal
 
-/* $Id$ */
-
-
-//Root includes
+// Root includes
 #include <TH1F.h>
 #include <TH2F.h>
 #include <TString.h>
@@ -196,7 +194,9 @@
 //
 
 
+/// \cond CLASSIMP
 ClassImp(AliTPCCalibPedestal)
+/// \endcond
 
 AliTPCCalibPedestal::AliTPCCalibPedestal() : 
   AliTPCCalibRawBase(),
@@ -236,9 +236,8 @@ AliTPCCalibPedestal::AliTPCCalibPedestal(const AliTPCCalibPedestal &ped) :
   fCalRocArrayMean(72),
   fCalRocArrayRMS(72)
 {
-  //
-  // copy constructor
-  //
+  /// copy constructor
+
   for (Int_t iSec = 0; iSec < 72; ++iSec){
     const AliTPCCalROC *calPed = (AliTPCCalROC*)ped.fCalRocArrayPedestal.UncheckedAt(iSec);
     const AliTPCCalROC *calRMS = (AliTPCCalROC*)ped.fCalRocArrayRMS.UncheckedAt(iSec);
@@ -268,9 +267,8 @@ AliTPCCalibPedestal::AliTPCCalibPedestal(const TMap *config):
   fCalRocArrayMean(72),
   fCalRocArrayRMS(72)  
 {
- //
- // This constructor uses a TMap for setting some parametes
- //
+ /// This constructor uses a TMap for setting some parametes
+
   SetNameTitle("AliTPCCalibPedestal","AliTPCCalibPedestal");
   fFirstTimeBin=60;
   fLastTimeBin=1000;
@@ -285,9 +283,8 @@ AliTPCCalibPedestal::AliTPCCalibPedestal(const TMap *config):
 //_____________________________________________________________________
 AliTPCCalibPedestal& AliTPCCalibPedestal::operator = (const  AliTPCCalibPedestal &source)
 {
-  //
-  // assignment operator
-  //
+  /// assignment operator
+
   if (&source == this) return *this;
   new (this) AliTPCCalibPedestal(source);
 
@@ -298,9 +295,7 @@ AliTPCCalibPedestal& AliTPCCalibPedestal::operator = (const  AliTPCCalibPedestal
 //_____________________________________________________________________
 AliTPCCalibPedestal::~AliTPCCalibPedestal() 
 {
-  //
-  // destructor
-  //
+  /// destructor
 
   fCalRocArrayPedestal.Delete();
   fCalRocArrayRMS.Delete();
@@ -324,16 +319,14 @@ AliTPCCalibPedestal::~AliTPCCalibPedestal()
 //_____________________________________________________________________
 void AliTPCCalibPedestal::SetTimeAnalysis(Bool_t time)
 {
-  //
-  // Use time dependent analysis: Pedestals are analysed as a function
-  // of the drift time. There is one mean value generated for each time
-  // bin and each channel. It can be used as reference data and for
-  // configuration of the ALTRO pattern memory for baseline subtraction.
-  //
-  // ATTENTION: Use only on LDC in TPCPEDESTALda! On a LDC we get data
-  // only from one sector. For the full TPC we would need a lot of
-  // memory (36*159*140*1024*4bytes = 3.3GB)!
-  //
+  /// Use time dependent analysis: Pedestals are analysed as a function
+  /// of the drift time. There is one mean value generated for each time
+  /// bin and each channel. It can be used as reference data and for
+  /// configuration of the ALTRO pattern memory for baseline subtraction.
+  ///
+  /// ATTENTION: Use only on LDC in TPCPEDESTALda! On a LDC we get data
+  /// only from one sector. For the full TPC we would need a lot of
+  /// memory (36*159*140*1024*4bytes = 3.3GB)!
 
   fTimeAnalysis = time;
 
@@ -360,9 +353,8 @@ Int_t AliTPCCalibPedestal::Update(const Int_t icsector,
 				  const Int_t icTimeBin,
 				  const Float_t csignal)
 {
-  //
-  // Signal filling method
-  //
+  /// Signal filling method
+
   if (icRow<0) return 0;
   if (icPad<0) return 0;
   if (icTimeBin<0) return 0;
@@ -394,10 +386,8 @@ Int_t AliTPCCalibPedestal::Update(const Int_t icsector,
 //_____________________________________________________________________
 Bool_t AliTPCCalibPedestal::TestEvent() 
 {
-  //
-  //  Test event loop
-  // fill one oroc and one iroc with random gaus
-  //
+  ///  Test event loop
+  /// fill one oroc and one iroc with random gaus
 
   gRandom->SetSeed(0);
 
@@ -421,10 +411,9 @@ TH2F* AliTPCCalibPedestal::GetHisto(Int_t sector, TObjArray *arr,
 				    Int_t nbinsY, Float_t ymin, Float_t ymax,
 				    const Char_t *type, Bool_t force)
 {
-    //
-    // return pointer to Q histogram
-    // if force is true create a new histogram if it doesn't exist allready
-    //
+    /// return pointer to Q histogram
+    /// if force is true create a new histogram if it doesn't exist allready
+
     if ( !force || arr->UncheckedAt(sector) )
       return (TH2F*)arr->UncheckedAt(sector);
 
@@ -444,10 +433,9 @@ TH2F* AliTPCCalibPedestal::GetHisto(Int_t sector, TObjArray *arr,
 //_____________________________________________________________________
 TH2F* AliTPCCalibPedestal::GetHistoPedestal(Int_t sector, Bool_t force) 
 {
-    //
-    // return pointer to T0 histogram
-    // if force is true create a new histogram if it doesn't exist allready
-    //
+    /// return pointer to T0 histogram
+    /// if force is true create a new histogram if it doesn't exist allready
+
     TObjArray *arr = &fHistoPedestalArray;
     return GetHisto(sector, arr, fAdcMax-fAdcMin, fAdcMin, fAdcMax, "Pedestal", force);
 }
@@ -456,10 +444,9 @@ TH2F* AliTPCCalibPedestal::GetHistoPedestal(Int_t sector, Bool_t force)
 //_____________________________________________________________________
 AliTPCCalROC* AliTPCCalibPedestal::GetCalRoc(Int_t sector, TObjArray* arr, Bool_t force) 
 {
-    //
-    // return pointer to ROC Calibration
-    // if force is true create a new histogram if it doesn't exist allready
-    //
+    /// return pointer to ROC Calibration
+    /// if force is true create a new histogram if it doesn't exist allready
+
     if ( !force || arr->UncheckedAt(sector) )
 	return (AliTPCCalROC*)arr->UncheckedAt(sector);
 
@@ -475,10 +462,9 @@ AliTPCCalROC* AliTPCCalibPedestal::GetCalRoc(Int_t sector, TObjArray* arr, Bool_
 //_____________________________________________________________________
 AliTPCCalROC* AliTPCCalibPedestal::GetCalRocPedestal(Int_t sector, Bool_t force) 
 {
-    //
-    // return pointer to ROC with Pedestal data
-    // if force is true create a new histogram if it doesn't exist allready
-    //
+    /// return pointer to ROC with Pedestal data
+    /// if force is true create a new histogram if it doesn't exist allready
+
     TObjArray *arr = &fCalRocArrayPedestal;
     return GetCalRoc(sector, arr, force);
 }
@@ -487,20 +473,18 @@ AliTPCCalROC* AliTPCCalibPedestal::GetCalRocPedestal(Int_t sector, Bool_t force)
 //_____________________________________________________________________
 AliTPCCalROC* AliTPCCalibPedestal::GetCalRocSigma(Int_t sector, Bool_t force) 
 {
-    //
-    // return pointer to  ROC with signal witdth in sigma
-    // if force is true create a new histogram if it doesn't exist allready
-    //
+    /// return pointer to  ROC with signal witdth in sigma
+    /// if force is true create a new histogram if it doesn't exist allready
+
     TObjArray *arr = &fCalRocArraySigma;
     return GetCalRoc(sector, arr, force);
 }
 //_____________________________________________________________________
 AliTPCCalROC* AliTPCCalibPedestal::GetCalRocMean(Int_t sector, Bool_t force)
 {
-  //
-    // return pointer to ROC with signal mean information
-    // if force is true create a new histogram if it doesn't exist allready
-  //
+  /// return pointer to ROC with signal mean information
+  /// if force is true create a new histogram if it doesn't exist allready
+
   TObjArray *arr = &fCalRocArrayMean;
   return GetCalRoc(sector, arr, force);
 }
@@ -508,10 +492,9 @@ AliTPCCalROC* AliTPCCalibPedestal::GetCalRocMean(Int_t sector, Bool_t force)
 //_____________________________________________________________________
 AliTPCCalROC* AliTPCCalibPedestal::GetCalRocRMS(Int_t sector, Bool_t force) 
 {
-  //
-    // return pointer to signal width ROC Calibration
-    // if force is true create a new histogram if it doesn't exist allready
-  //
+  /// return pointer to signal width ROC Calibration
+  /// if force is true create a new histogram if it doesn't exist allready
+
   TObjArray *arr = &fCalRocArrayRMS;
   return GetCalRoc(sector, arr, force);
 }
@@ -520,9 +503,8 @@ AliTPCCalROC* AliTPCCalibPedestal::GetCalRocRMS(Int_t sector, Bool_t force)
 //_____________________________________________________________________
 void AliTPCCalibPedestal::Merge(AliTPCCalibPedestal * const ped)
 {
-  //
-  //  Merge reference histograms of sig to the current AliTPCCalibPedestal
-  //
+  ///  Merge reference histograms of sig to the current AliTPCCalibPedestal
+
   MergeBase(ped);
   // merge histograms
   for (Int_t iSec=0; iSec<72; ++iSec){
@@ -549,10 +531,8 @@ void AliTPCCalibPedestal::Merge(AliTPCCalibPedestal * const ped)
 //_____________________________________________________________________
 Long64_t AliTPCCalibPedestal::Merge(TCollection * const list)
 {
-  //
-  // Merge all objects of this type in list
-  //
-  
+  /// Merge all objects of this type in list
+
   Long64_t nmerged=1;
   
   TIter next(list);
@@ -573,9 +553,7 @@ Long64_t AliTPCCalibPedestal::Merge(TCollection * const list)
 //_____________________________________________________________________
 void AliTPCCalibPedestal::Analyse() 
 {
-  //
-  //  Calculate calibration constants
-  //
+  ///  Calculate calibration constants
 
   Int_t nbinsAdc = fAdcMax-fAdcMin;
 
@@ -632,11 +610,9 @@ void AliTPCCalibPedestal::Analyse()
 //_____________________________________________________________________
 void AliTPCCalibPedestal::AnalyseTime(Int_t nevents)
 {
-  //
-  // Calculate for each channel and time bin the mean pedestal. This
-  // is used on LDC by TPCPEDESTALda to generate data used for configuration
-  // of the pattern memory for baseline subtraction in the ALTROs.
-  //
+  /// Calculate for each channel and time bin the mean pedestal. This
+  /// is used on LDC by TPCPEDESTALda to generate data used for configuration
+  /// of the pattern memory for baseline subtraction in the ALTROs.
 
   if ( nevents <= 0 ) return;
   if ( fTimeAnalysis ) {
diff --git a/TPC/TPCbase/AliTPCCalibPedestal.h b/TPC/TPCbase/AliTPCCalibPedestal.h
index a78c373b1ce..8350fc58201 100644
--- a/TPC/TPCbase/AliTPCCalibPedestal.h
+++ b/TPC/TPCbase/AliTPCCalibPedestal.h
@@ -3,11 +3,8 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-/////////////////////////////////////////////////////////////////////////////////////////
-//                                                                                     //
-//                  Implementation of the TPC pedestal calibration                     //
-//                                                                                     //
-/////////////////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCCalibPedestal
+/// \brief Implementation of the TPC pedestal calibration
 
 #include <TObjArray.h>
 #include "AliTPCCalibRawBase.h"
@@ -45,7 +42,7 @@ public:
   AliTPCCalROC* GetCalRocRMS(Int_t sector, Bool_t force=kFALSE);        // get calibration object - sector
   const TObjArray* GetCalPadMean() const {return &fCalRocArrayMean;}          // get calibration object
   const TObjArray* GetCalPadRMS()  const {return &fCalRocArrayRMS;}             // get calibration object
-  
+
   TH2F* GetHistoPedestal  (Int_t sector, Bool_t force=kFALSE);          // get refernce histogram
   //
   void  SetTimeAnalysis(Bool_t time = kTRUE);                  // Use ONLY in TPCPEDESTALda on LDC for one sector!
@@ -56,33 +53,33 @@ public:
   Int_t   GetAdcMax()       const { return fAdcMax;       }
   Float_t GetAnaMeanDown()  const { return fAnaMeanDown;  }
   Float_t GetAnaMeanUp()    const { return fAnaMeanUp;    }
-  
+
   void  SetRangeAdc (Int_t aMin, Int_t aMax){ fAdcMin=aMin; fAdcMax=aMax; }  // Set adc range for the pedestal calibration
   void  SetAnalysisTruncationRange(Float_t down, Float_t up) {fAnaMeanDown=down; fAnaMeanUp=up;}    //Set range for truncated mean analysis of the channel information
 
   void  Merge(AliTPCCalibPedestal * const ped);
   virtual Long64_t Merge(TCollection * const list);
-  
+
   Bool_t TestEvent();  // Test the fast approach to fill histogram - used for test purposes
 
 private:
-  Int_t fAdcMin;                    //  min adc channel of pedestal value
-  Int_t fAdcMax;                    //  max adc channel of pedestal value
+  Int_t fAdcMin;                    ///< min adc channel of pedestal value
+  Int_t fAdcMax;                    ///< max adc channel of pedestal value
+
+  Float_t fAnaMeanDown;             ///< Truncated mean channel analysis - lower cut
+  Float_t fAnaMeanUp;               ///< Truncated mean channel analysis - upper cut
+
+  Bool_t  fTimeAnalysis;            //!< Should we use the time dependent analysis? ONLY ON LDC!
 
-  Float_t fAnaMeanDown;             // Truncated mean channel analysis - lower cut
-  Float_t fAnaMeanUp;               // Truncated mean channel analysis - upper cut
-  
-  Bool_t  fTimeAnalysis;            //! Should we use the time dependent analysis? ONLY ON LDC!
+  TObjArray fCalRocArrayPedestal;   ///< Array of AliTPCCalROC class for pedestal values from gaus fit
+  TObjArray fCalRocArraySigma;      ///< Array of AliTPCCalROC class for noise values from gaus fit
 
-  TObjArray fCalRocArrayPedestal;   //  Array of AliTPCCalROC class for pedestal values from gaus fit
-  TObjArray fCalRocArraySigma;      //  Array of AliTPCCalROC class for noise values from gaus fit
+  TObjArray fHistoPedestalArray;    ///< Calibration histograms for Pedestal distribution
 
-  TObjArray fHistoPedestalArray;    //  Calibration histograms for Pedestal distribution
+  TArrayF **fTimeSignal;            //!< Arrays which hold time dependent signals
 
-  TArrayF **fTimeSignal;            //! Arrays which hold time dependent signals
-  
-  TObjArray fCalRocArrayMean;       //  Array of AliTPCCalROC class for pedestal values, simple mean
-  TObjArray fCalRocArrayRMS;        //  Array of AliTPCCalROC class for noise values, simple rms
+  TObjArray fCalRocArrayMean;       ///< Array of AliTPCCalROC class for pedestal values, simple mean
+  TObjArray fCalRocArrayRMS;        ///< Array of AliTPCCalROC class for noise values, simple rms
 
   TH2F* GetHisto(Int_t sector, TObjArray *arr,
 		 Int_t nbinsY, Float_t ymin, Float_t ymax,
diff --git a/TPC/TPCbase/AliTPCCalibPulser.cxx b/TPC/TPCbase/AliTPCCalibPulser.cxx
index 4d913498201..bb5d4df4a04 100644
--- a/TPC/TPCbase/AliTPCCalibPulser.cxx
+++ b/TPC/TPCbase/AliTPCCalibPulser.cxx
@@ -13,155 +13,154 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/* $Id$ */
-
-/////////////////////////////////////////////////////////////////////////////////////////
-//                                                                                     //
-//                  Implementation of the TPC pulser calibration                       //
-//                                                                                     //
-//   Origin: Jens Wiechula, Marian Ivanov   J.Wiechula@gsi.de, Marian.Ivanov@cern.ch   //
-//                                                                                     //
-/////////////////////////////////////////////////////////////////////////////////////////
-/***************************************************************************
- *                      Class Description                                  *
- ***************************************************************************
-
- The AliTPCCalibPulser class is used to get calibration data concerning the FEE using
- runs performed with the calibration pulser.
-
- The information retrieved is
- - Time0 differences
- - Signal width differences
- - Amplification variations
-
- the seen differences arise from the manufacturing tolerances of the PASAs and are very small within
- one chip and somewhat large between different chips.
-
- Histograms:
-   For each ROC three TH2S histos 'Reference Histograms'  (ROC channel vs. [Time0, signal width, Q sum]) is created when
-   it is filled for the first time (GetHisto[T0,RMS,Q](ROC,kTRUE)). The histos are stored in the
-   TObjArrays fHistoT0Array, fHistoRMSArray and fHistoQArray.
-
-
- Working principle:
- ------------------
- Raw calibration pulser data is processed by calling one of the ProcessEvent(...) functions
- (see below). These in the end call the Update(...) function.
-
- - the Update(...) function:
-   In this function the array fPadSignal is filled with the adc signals between the specified range
-   fFirstTimeBin and fLastTimeBin for the current pad.
-   before going to the next pad the ProcessPad() function is called, which analyses the data for one pad
-   stored in fPadSignal.
-
-   - the ProcessPad() function:
-     Find Pedestal and Noise information
-     - use database information which has to be set by calling
-       SetPedestalDatabase(AliTPCCalPad *pedestalTPC, AliTPCCalPad *padNoiseTPC)
-     - if no information from the pedestal data base
-       is available the informaion is calculated on the fly ( see FindPedestal() function )
-
-     Find the Pulser signal information
-     - calculate  mean = T0, RMS = signal width and Q sum in a range of -2+7 timebins around Q max
-       the Q sum is scaled by pad area
-       (see FindPulserSignal(...) function)
-
-     Fill a temprary array for the T0 information (GetPadTimesEvent(fCurrentSector,kTRUE)) (why see below)
-     Fill the Q sum and RMS values in the histograms (GetHisto[RMS,Q](ROC,kTRUE)),
-
- At the end of each event the EndEvent() function is called
-
- - the EndEvent() function:
-   calculate the mean T0 for each ROC and fill the Time0 histogram with Time0-<Time0 for ROC>
-   This is done to overcome syncronisation problems between the trigger and the fec clock.
-
- After accumulating the desired statistics the Analyse() function has to be called.
- - the Analyse() function
-   Whithin this function the mean values of T0, RMS, Q are calculated for each pad, using
-   the AliMathBase::GetCOG(...) function, and the calibration
-   storage classes (AliTPCCalROC) are filled for each ROC.
-   The calibration information is stored in the TObjArrays fCalRocArrayT0, fCalRocArrayRMS and
-   fCalRocArrayQ;
-
-
-
- User interface for filling data:
- --------------------------------
-
- To Fill information one of the following functions can be used:
-
- Bool_t ProcessEvent(eventHeaderStruct *event);
-   - process Date event
-   - use AliTPCRawReaderDate and call ProcessEvent(AliRawReader *rawReader)
-
- Bool_t ProcessEvent(AliRawReader *rawReader);
-   - process AliRawReader event
-   - use AliTPCRawStreamV3 to loop over data and call ProcessEvent(AliTPCRawStreamV3 *rawStream)
-
- Bool_t ProcessEvent(AliTPCRawStreamV3 *rawStream);
-   - process event from AliTPCRawStreamV3
-   - call Update function for signal filling
-
- Int_t Update(const Int_t isector, const Int_t iRow, const Int_t
-              iPad,  const Int_t iTimeBin, const Float_t signal);
-   - directly  fill signal information (sector, row, pad, time bin, pad)
-     to the reference histograms
-
- It is also possible to merge two independently taken calibrations using the function
-
- void Merge(AliTPCCalibPulser *sig)
-   - copy histograms in 'sig' if the do not exist in this instance
-   - Add histograms in 'sig' to the histograms in this instance if the allready exist
-   - After merging call Analyse again!
-
-
-
- -- example: filling data using root raw data:
- void fillSignal(Char_t *filename)
- {
-    rawReader = new AliRawReaderRoot(fileName);
-    if ( !rawReader ) return;
-    AliTPCCalibPulser *calib = new AliTPCCalibPulser;
-    while (rawReader->NextEvent()){
-      calib->ProcessEvent(rawReader);
-    }
-    calib->Analyse();
-    calib->DumpToFile("SignalData.root");
-    delete rawReader;
-    delete calib;
- }
-
-
- What kind of information is stored and how to retrieve them:
- ------------------------------------------------------------
-
- - Accessing the 'Reference Histograms' (Time0, signal width and Q sum information pad by pad):
-
-   TH2F *GetHistoT0(Int_t sector);
-   TH2F *GetHistoRMS(Int_t sector);
-   TH2F *GetHistoQ(Int_t sector);
-
- - Accessing the calibration storage objects:
-
-   AliTPCCalROC *GetCalRocT0(Int_t sector);   // for the Time0 values
-   AliTPCCalROC *GetCalRocRMS(Int_t sector);  // for the signal width values
-   AliTPCCalROC *GetCalRocQ(Int_t sector);    // for the Q sum values
-
-   example for visualisation:
-   if the file "SignalData.root" was created using the above example one could do the following:
-
-   TFile fileSignal("SignalData.root")
-   AliTPCCalibPulser *sig = (AliTPCCalibPulser*)fileSignal->Get("AliTPCCalibPulser");
-   sig->GetCalRocT0(0)->Draw("colz");
-   sig->GetCalRocRMS(0)->Draw("colz");
-
-   or use the AliTPCCalPad functionality:
-   AliTPCCalPad padT0(ped->GetCalPadT0());
-   AliTPCCalPad padSigWidth(ped->GetCalPadRMS());
-   padT0->MakeHisto2D()->Draw("colz");       //Draw A-Side Time0 Information
-   padSigWidth->MakeHisto2D()->Draw("colz"); //Draw A-Side signal width Information
-*/
-
+/// \class AliTPCCalibPulser
+/// \brief Implementation of the TPC pulser calibration
+///
+/// \author Jens Wiechula, Marian Ivanov   J.Wiechula@gsi.de, Marian.Ivanov@cern.ch
+///
+/// Class Description
+/// -----------------
+///
+///  The AliTPCCalibPulser class is used to get calibration data concerning the FEE using
+///  runs performed with the calibration pulser.
+///
+///  The information retrieved is
+///  - Time0 differences
+///  - Signal width differences
+///  - Amplification variations
+///
+///  the seen differences arise from the manufacturing tolerances of the PASAs and are very small within
+///  one chip and somewhat large between different chips.
+///
+///  Histograms:
+///    For each ROC three TH2S histos 'Reference Histograms'  (ROC channel vs. [Time0, signal width, Q sum]) is created when
+///    it is filled for the first time (GetHisto[T0,RMS,Q](ROC,kTRUE)). The histos are stored in the
+///    TObjArrays fHistoT0Array, fHistoRMSArray and fHistoQArray.
+///
+///
+///  Working principle:
+///  ------------------
+///  Raw calibration pulser data is processed by calling one of the ProcessEvent(...) functions
+///  (see below). These in the end call the Update(...) function.
+///
+///  - the Update(...) function:
+///    In this function the array fPadSignal is filled with the adc signals between the specified range
+///    fFirstTimeBin and fLastTimeBin for the current pad.
+///    before going to the next pad the ProcessPad() function is called, which analyses the data for one pad
+///    stored in fPadSignal.
+///
+///    - the ProcessPad() function:
+///      Find Pedestal and Noise information
+///      - use database information which has to be set by calling
+///        SetPedestalDatabase(AliTPCCalPad *pedestalTPC, AliTPCCalPad *padNoiseTPC)
+///      - if no information from the pedestal data base
+///        is available the informaion is calculated on the fly ( see FindPedestal() function )
+///
+///      Find the Pulser signal information
+///      - calculate  mean = T0, RMS = signal width and Q sum in a range of -2+7 timebins around Q max
+///        the Q sum is scaled by pad area
+///        (see FindPulserSignal(...) function)
+///
+///      Fill a temprary array for the T0 information (GetPadTimesEvent(fCurrentSector,kTRUE)) (why see below)
+///      Fill the Q sum and RMS values in the histograms (GetHisto[RMS,Q](ROC,kTRUE)),
+///
+///  At the end of each event the EndEvent() function is called
+///
+///  - the EndEvent() function:
+///    calculate the mean T0 for each ROC and fill the Time0 histogram with Time0-<Time0 for ROC>
+///    This is done to overcome syncronisation problems between the trigger and the fec clock.
+///
+///  After accumulating the desired statistics the Analyse() function has to be called.
+///  - the Analyse() function
+///    Whithin this function the mean values of T0, RMS, Q are calculated for each pad, using
+///    the AliMathBase::GetCOG(...) function, and the calibration
+///    storage classes (AliTPCCalROC) are filled for each ROC.
+///    The calibration information is stored in the TObjArrays fCalRocArrayT0, fCalRocArrayRMS and
+///    fCalRocArrayQ;
+///
+///
+///
+///  User interface for filling data:
+///  --------------------------------
+///
+///  To Fill information one of the following functions can be used:
+///
+///  Bool_t ProcessEvent(eventHeaderStruct *event);
+///    - process Date event
+///    - use AliTPCRawReaderDate and call ProcessEvent(AliRawReader *rawReader)
+///
+///  Bool_t ProcessEvent(AliRawReader *rawReader);
+///    - process AliRawReader event
+///    - use AliTPCRawStreamV3 to loop over data and call ProcessEvent(AliTPCRawStreamV3 *rawStream)
+///
+///  Bool_t ProcessEvent(AliTPCRawStreamV3 *rawStream);
+///    - process event from AliTPCRawStreamV3
+///    - call Update function for signal filling
+///
+///  Int_t Update(const Int_t isector, const Int_t iRow, const Int_t
+///               iPad,  const Int_t iTimeBin, const Float_t signal);
+///    - directly  fill signal information (sector, row, pad, time bin, pad)
+///      to the reference histograms
+///
+///  It is also possible to merge two independently taken calibrations using the function
+///
+///  void Merge(AliTPCCalibPulser *sig)
+///    - copy histograms in 'sig' if the do not exist in this instance
+///    - Add histograms in 'sig' to the histograms in this instance if the allready exist
+///    - After merging call Analyse again!
+///
+///
+///
+///  -- example: filling data using root raw data:
+/// ~~~{.cpp}
+///  void fillSignal(Char_t *filename)
+///  {
+///     rawReader = new AliRawReaderRoot(fileName);
+///     if ( !rawReader ) return;
+///     AliTPCCalibPulser *calib = new AliTPCCalibPulser;
+///     while (rawReader->NextEvent()){
+///       calib->ProcessEvent(rawReader);
+///     }
+///     calib->Analyse();
+///     calib->DumpToFile("SignalData.root");
+///     delete rawReader;
+///     delete calib;
+///  }
+/// ~~~
+///
+///  What kind of information is stored and how to retrieve them:
+///  ------------------------------------------------------------
+///
+///  - Accessing the 'Reference Histograms' (Time0, signal width and Q sum information pad by pad):
+///
+///    TH2F *GetHistoT0(Int_t sector);
+///    TH2F *GetHistoRMS(Int_t sector);
+///    TH2F *GetHistoQ(Int_t sector);
+///
+///  - Accessing the calibration storage objects:
+///
+///    AliTPCCalROC *GetCalRocT0(Int_t sector);   // for the Time0 values
+///    AliTPCCalROC *GetCalRocRMS(Int_t sector);  // for the signal width values
+///    AliTPCCalROC *GetCalRocQ(Int_t sector);    // for the Q sum values
+///
+///    example for visualisation:
+///    if the file "SignalData.root" was created using the above example one could do the following:
+///
+/// ~~~{.cpp}
+/// TFile fileSignal("SignalData.root")
+/// AliTPCCalibPulser *sig = (AliTPCCalibPulser*)fileSignal->Get("AliTPCCalibPulser");
+/// sig->GetCalRocT0(0)->Draw("colz");
+/// sig->GetCalRocRMS(0)->Draw("colz");
+/// ~~~
+///
+/// or use the AliTPCCalPad functionality:
+///
+/// ~~~{.cpp}
+/// AliTPCCalPad padT0(ped->GetCalPadT0());
+/// AliTPCCalPad padSigWidth(ped->GetCalPadRMS());
+/// padT0->MakeHisto2D()->Draw("colz");       //Draw A-Side Time0 Information
+/// padSigWidth->MakeHisto2D()->Draw("colz"); //Draw A-Side signal width Information
+/// ~~~
 
 //Root includes
 #include <TObjArray.h>
@@ -197,7 +196,9 @@
 
 
 
+/// \cond CLASSIMP
 ClassImp(AliTPCCalibPulser)
+/// \endcond
 
 AliTPCCalibPulser::AliTPCCalibPulser() :
 AliTPCCalibRawBase(),
@@ -300,25 +301,23 @@ fPadNoise(0),
 fVTime0Offset(72),
 fVTime0OffsetCounter(72)
 {
-  //
-  // AliTPCSignal default constructor
-  //
-  
+  /// AliTPCSignal default constructor
+
   for (Int_t iSec = 0; iSec < 72; ++iSec){
     const AliTPCCalROC *calQ   = (AliTPCCalROC*)sig.fCalRocArrayQ.UncheckedAt(iSec);
     const AliTPCCalROC *calT0  = (AliTPCCalROC*)sig.fCalRocArrayT0.UncheckedAt(iSec);
     const AliTPCCalROC *calRMS = (AliTPCCalROC*)sig.fCalRocArrayRMS.UncheckedAt(iSec);
     const AliTPCCalROC *calOut = (AliTPCCalROC*)sig.fCalRocArrayOutliers.UncheckedAt(iSec);
-    
+
     const TH2S *hQ   = (TH2S*)sig.fHistoQArray.UncheckedAt(iSec);
     const TH2S *hT0  = (TH2S*)sig.fHistoT0Array.UncheckedAt(iSec);
     const TH2S *hRMS = (TH2S*)sig.fHistoRMSArray.UncheckedAt(iSec);
-    
+
     if ( calQ   != 0x0 ) fCalRocArrayQ.AddAt(new AliTPCCalROC(*calQ), iSec);
     if ( calT0  != 0x0 ) fCalRocArrayT0.AddAt(new AliTPCCalROC(*calT0), iSec);
     if ( calRMS != 0x0 ) fCalRocArrayRMS.AddAt(new AliTPCCalROC(*calRMS), iSec);
     if ( calOut != 0x0 ) fCalRocArrayOutliers.AddAt(new AliTPCCalROC(*calOut), iSec);
-    
+
     if ( hQ != 0x0 ){
       TH2S *hNew = new TH2S(*hQ);
       hNew->SetDirectory(0);
@@ -336,7 +335,7 @@ fVTime0OffsetCounter(72)
     }
     fVMeanTimeSector[iSec]=sig.fVMeanTimeSector[iSec];
   }
-  
+
   if ( sig.fHMeanTimeSector ) fHMeanTimeSector=(TH2F*)sig.fHMeanTimeSector->Clone();
   fParam->Update();
 }
@@ -386,9 +385,8 @@ fPadNoise(0),
 fVTime0Offset(72),
 fVTime0OffsetCounter(72)
 {
-  //
-  // This constructor uses a TMap for setting some parametes
-  //
+  /// This constructor uses a TMap for setting some parametes
+
   SetNameTitle("AliTPCCalibPulser","AliTPCCalibPulser");
   fFirstTimeBin=60;
   fLastTimeBin=900;
@@ -406,49 +404,45 @@ fVTime0OffsetCounter(72)
   if (config->GetValue("PeakIntMinus")) fPeakIntMinus = (Int_t)((TObjString*)config->GetValue("PeakIntMinus"))->GetString().Atof();
   if (config->GetValue("PeakIntPlus")) fPeakIntPlus = (Int_t)((TObjString*)config->GetValue("PeakIntPlus"))->GetString().Atof();
   if (config->GetValue("IsZeroSuppressed")) fIsZeroSuppressed = (Bool_t)((TObjString*)config->GetValue("IsZeroSuppressed"))->GetString().Atoi();
-  
+
   fParam->Update();
 }
 //_____________________________________________________________________
 AliTPCCalibPulser& AliTPCCalibPulser::operator = (const  AliTPCCalibPulser &source)
 {
-  //
-  // assignment operator
-  //
+  /// assignment operator
+
   if (&source == this) return *this;
   new (this) AliTPCCalibPulser(source);
-  
+
   return *this;
 }
 //_____________________________________________________________________
 AliTPCCalibPulser::~AliTPCCalibPulser()
 {
-  //
-  // destructor
-  //
-  
+  /// destructor
+
   Reset();
   delete fParam;
 }
 void AliTPCCalibPulser::Reset()
 {
-  //
-  // Delete all information: Arrays, Histograms, CalRoc objects
-  //
+  /// Delete all information: Arrays, Histograms, CalRoc objects
+
   fCalRocArrayT0.Delete();
   fCalRocArrayQ.Delete();
   fCalRocArrayRMS.Delete();
   fCalRocArrayOutliers.Delete();
-  
+
   fHistoQArray.Delete();
   fHistoT0Array.Delete();
   fHistoRMSArray.Delete();
-  
+
   fPadTimesArrayEvent.Delete();
   fPadQArrayEvent.Delete();
   fPadRMSArrayEvent.Delete();
   fPadPedestalArrayEvent.Delete();
-  
+
   if (fHMeanTimeSector) delete fHMeanTimeSector;
 }
 //_____________________________________________________________________
@@ -458,24 +452,22 @@ Int_t AliTPCCalibPulser::Update(const Int_t icsector,
                                 const Int_t icTimeBin,
                                 const Float_t csignal)
 {
-    //
-    // Signal filling methode on the fly pedestal and time offset correction if necessary.
-    // no extra analysis necessary. Assumes knowledge of the signal shape!
-    // assumes that it is looped over consecutive time bins of one pad
-    //
-  
+    /// Signal filling methode on the fly pedestal and time offset correction if necessary.
+    /// no extra analysis necessary. Assumes knowledge of the signal shape!
+    /// assumes that it is looped over consecutive time bins of one pad
+
   if (icRow<0) return 0;
   if (icPad<0) return 0;
   if (icTimeBin<0) return 0;
   if ( (icTimeBin>fLastTimeBin) || (icTimeBin<fFirstTimeBin)   ) return 0;
-  
+
   if ( icRow<0 || icPad<0 ){
     AliWarning("Wrong Pad or Row number, skipping!");
     return 0;
   }
-  
+
   Int_t iChannel  = fROC->GetRowIndexes(icsector)[icRow]+icPad; //  global pad position in sector
-  
+
     //init first pad and sector in this event
   if ( fCurrentChannel == -1 ) {
     fCurrentChannel = iChannel;
@@ -483,7 +475,7 @@ Int_t AliTPCCalibPulser::Update(const Int_t icsector,
     fCurrentRow     = icRow;
     fCurrentPad     = icPad;
   }
-  
+
     //process last pad if we change to a new one
   if ( iChannel != fCurrentChannel ){
     ProcessPad();
@@ -493,7 +485,7 @@ Int_t AliTPCCalibPulser::Update(const Int_t icsector,
     fCurrentRow     = icRow;
     fCurrentPad     = icPad;
   }
-  
+
     //fill signals for current pad
   fPadSignal[icTimeBin]=csignal;
   if ( csignal > fMaxPadSignal ){
@@ -505,10 +497,9 @@ Int_t AliTPCCalibPulser::Update(const Int_t icsector,
 //_____________________________________________________________________
 void AliTPCCalibPulser::FindPedestal(Float_t part)
 {
-    //
-    // find pedestal and noise for the current pad. Use either database or
-    // truncated mean with part*100%
-    //
+    /// find pedestal and noise for the current pad. Use either database or
+    /// truncated mean with part*100%
+
   Bool_t noPedestal = kTRUE;;
   if (fPedestalTPC&&fPadNoiseTPC){
         //use pedestal database
@@ -517,15 +508,15 @@ void AliTPCCalibPulser::FindPedestal(Float_t part)
       fPedestalROC = fPedestalTPC->GetCalROC(fCurrentSector);
       fPadNoiseROC = fPadNoiseTPC->GetCalROC(fCurrentSector);
     }
-    
+
     if ( fPedestalROC&&fPadNoiseROC ){
       fPadPedestal = fPedestalROC->GetValue(fCurrentChannel);
       fPadNoise    = fPadNoiseROC->GetValue(fCurrentChannel);
       noPedestal   = kFALSE;
     }
-    
+
   }
-  
+
     //if we are not running with pedestal database, or for the current sector there is no information
     //available, calculate the pedestal and noise on the fly
   if ( noPedestal ) {
@@ -539,7 +530,7 @@ void AliTPCCalibPulser::FindPedestal(Float_t part)
         //
     UShort_t histo[kPedMax];
     memset(histo,0,kPedMax*sizeof(UShort_t));
-    
+
     for (Int_t i=fFirstTimeBin; i<=fLastTimeBin; ++i){
       padSignal = fPadSignal.GetMatrixArray()[i];
       if (padSignal<=0) continue;
@@ -586,12 +577,10 @@ void AliTPCCalibPulser::FindPedestal(Float_t part)
 //_____________________________________________________________________
 void AliTPCCalibPulser::FindPulserSignal(TVectorD &param, Float_t &qSum)
 {
-//
-    //  Find position, signal width and height of the CE signal (last signal)
-    //  param[0] = Qmax, param[1] = mean time, param[2] = rms;
-    //  maxima: array of local maxima of the pad signal use the one closest to the mean CE position
-    //
-  
+///  Find position, signal width and height of the CE signal (last signal)
+///  param[0] = Qmax, param[1] = mean time, param[2] = rms;
+///  maxima: array of local maxima of the pad signal use the one closest to the mean CE position
+
   Float_t ceQmax  =0, ceQsum=0, ceTime=0, ceRMS=0;
   Int_t   cemaxpos       = fMaxTimeBin;
   Float_t ceSumThreshold = 10.*TMath::Max(fPadNoise,Float_t(1.));  // threshold for the signal sum
@@ -602,7 +591,7 @@ void AliTPCCalibPulser::FindPulserSignal(TVectorD &param, Float_t &qSum)
   param[1] = ceTime;
   param[2] = ceRMS;
   qSum     = ceQsum;
-  
+
   if (cemaxpos>0){
     ceQmax = fPadSignal.GetMatrixArray()[cemaxpos]-fPadPedestal;
     if ( ceQmax<ceMaxThreshold ) return;
@@ -633,7 +622,7 @@ void AliTPCCalibPulser::FindPulserSignal(TVectorD &param, Float_t &qSum)
         fVTime0OffsetCounter.GetMatrixArray()[fCurrentSector]++;
       }
     }
-    
+
   //Normalise Q to the 'cell-size': The wire density is the same in the IROC and OROC, therefore the
   //                                the pick-up signal should scale with the pad area. In addition
   //                                the signal should decrease with the wire distance (4mm in IROC, 6mm in OROC),
@@ -641,7 +630,7 @@ void AliTPCCalibPulser::FindPulserSignal(TVectorD &param, Float_t &qSum)
   //                                to the OROC signal (factor 2/3 for the IROCs).
     Float_t norm = fParam->GetPadPitchWidth(fCurrentSector)*fParam->GetPadPitchLength(fCurrentSector,fCurrentRow)*100;
     if ( fCurrentSector<fParam->GetNInnerSector() ) norm*=3./2.;
-    
+
     ceQsum/=norm;
   } else {
     ceQmax=0;
@@ -657,30 +646,28 @@ void AliTPCCalibPulser::FindPulserSignal(TVectorD &param, Float_t &qSum)
 //_____________________________________________________________________
 void AliTPCCalibPulser::ProcessPad()
 {
-  //
-  //  Process data of current pad
-  //
-  
+  ///  Process data of current pad
+
   FindPedestal();
   TVectorD param(3);
   Float_t  qSum;
   FindPulserSignal(param, qSum);
-  
+
   Double_t meanT  = param[1];
   Double_t sigmaT = param[2];
-  
-  
+
+
   //Fill Event T0 counter
   (*GetPadTimesEvent(fCurrentSector,kTRUE)).GetMatrixArray()[fCurrentChannel] = meanT;
-  
+
   //Fill Q histogram
 //   GetHistoQ(fCurrentSector,kTRUE)->Fill( TMath::Sqrt(qSum), fCurrentChannel ); //use linear scale, needs also a change in the Analyse funciton.
   GetHistoQ(fCurrentSector,kTRUE)->Fill( qSum, fCurrentChannel );
-  
+
   //Fill RMS histogram
   GetHistoRMS(fCurrentSector,kTRUE)->Fill( sigmaT, fCurrentChannel );
-  
-  
+
+
     //Fill debugging info
   if ( GetStreamLevel()>0 ){
     TTreeSRedirector *streamer=GetDebugStreamer();
@@ -710,13 +697,11 @@ void AliTPCCalibPulser::ProcessPad()
 //_____________________________________________________________________
 void AliTPCCalibPulser::EndEvent()
 {
-    //
-    //  Process data of current event
-    //
-  
+    ///  Process data of current event
+
     //check if last pad has allready been processed, if not do so
   if ( fMaxTimeBin>-1 ) ProcessPad();
-  
+
     //loop over all ROCs, fill Time0 histogram corrected for the mean Time0 of each ROC
   for ( Int_t iSec = 0; iSec<72; ++iSec ){
     TVectorF *vTimes = GetPadTimesEvent(iSec);
@@ -724,11 +709,11 @@ void AliTPCCalibPulser::EndEvent()
     Float_t time0 = fVTime0Offset[iSec]/fVTime0OffsetCounter[iSec];
     for ( UInt_t iChannel=0; iChannel<fROC->GetNChannels(iSec); ++iChannel ){
       Float_t time  = (*vTimes).GetMatrixArray()[iChannel];
-      
+
       GetHistoT0(iSec,kTRUE)->Fill( time-time0,iChannel );
             //GetHistoT0(iSec,kTRUE)->Fill( time,iChannel );
-      
-      
+
+
       //Debug start
       if ( GetStreamLevel()>1 ){
         TTreeSRedirector *streamer=GetDebugStreamer();
@@ -736,17 +721,17 @@ void AliTPCCalibPulser::EndEvent()
           Int_t row=0;
           Int_t pad=0;
           Int_t padc=0;
-          
+
           Float_t q   = (*GetPadQEvent(iSec)).GetMatrixArray()[iChannel];
           Float_t rms = (*GetPadRMSEvent(iSec)).GetMatrixArray()[iChannel];
-          
+
           UInt_t channel=iChannel;
           Int_t sector=iSec;
-          
+
           while ( channel > (fROC->GetRowIndexes(sector)[row]+fROC->GetNPads(sector,row)-1) ) row++;
           pad = channel-fROC->GetRowIndexes(sector)[row];
           padc = pad-(fROC->GetNPads(sector,row)/2);
-          
+
           (*streamer) << "DataPad" <<
     		    "Event=" << fNevents <<
             "Sector="<< sector <<
@@ -771,13 +756,12 @@ TH2S* AliTPCCalibPulser::GetHisto(Int_t sector, TObjArray *arr,
                                   Int_t nbinsY, Float_t ymin, Float_t ymax,
                                   const Char_t *type, Bool_t force)
 {
-    //
-    // return pointer to Q histogram
-    // if force is true create a new histogram if it doesn't exist allready
-    //
+    /// return pointer to Q histogram
+    /// if force is true create a new histogram if it doesn't exist allready
+
   if ( !force || arr->UncheckedAt(sector) )
     return (TH2S*)arr->UncheckedAt(sector);
-  
+
   // if we are forced and histogram doesn't yes exist create it
   // new histogram with Q calib information. One value for each pad!
   TH2S* hist = new TH2S(Form("hCalib%s%.2d",type,sector),Form("%s calibration histogram sector %.2d",type,sector),
@@ -790,40 +774,36 @@ TH2S* AliTPCCalibPulser::GetHisto(Int_t sector, TObjArray *arr,
 //_____________________________________________________________________
 TH2S* AliTPCCalibPulser::GetHistoT0(Int_t sector, Bool_t force)
 {
-    //
-    // return pointer to T0 histogram
-    // if force is true create a new histogram if it doesn't exist allready
-    //
+    /// return pointer to T0 histogram
+    /// if force is true create a new histogram if it doesn't exist allready
+
   TObjArray *arr = &fHistoT0Array;
   return GetHisto(sector, arr, fNbinsT0, fXminT0, fXmaxT0, "T0", force);
 }
 //_____________________________________________________________________
 TH2S* AliTPCCalibPulser::GetHistoQ(Int_t sector, Bool_t force)
 {
-    //
-    // return pointer to Q histogram
-    // if force is true create a new histogram if it doesn't exist allready
-    //
+    /// return pointer to Q histogram
+    /// if force is true create a new histogram if it doesn't exist allready
+
   TObjArray *arr = &fHistoQArray;
   return GetHisto(sector, arr, fNbinsQ, fXminQ, fXmaxQ, "Q", force);
 }
 //_____________________________________________________________________
 TH2S* AliTPCCalibPulser::GetHistoRMS(Int_t sector, Bool_t force)
 {
-    //
-    // return pointer to Q histogram
-    // if force is true create a new histogram if it doesn't exist allready
-    //
+    /// return pointer to Q histogram
+    /// if force is true create a new histogram if it doesn't exist allready
+
   TObjArray *arr = &fHistoRMSArray;
   return GetHisto(sector, arr, fNbinsRMS, fXminRMS, fXmaxRMS, "RMS", force);
 }
 //_____________________________________________________________________
 TH2F* AliTPCCalibPulser::GetHistoTSec()
 {
-    //
-    // return the pointer to the abs time distribution per sector
-    // create it if it does not exist
-    //
+    /// return the pointer to the abs time distribution per sector
+    /// create it if it does not exist
+
   if ( !fHMeanTimeSector )   //!!!if you change the binning here, you should also change it in the Analyse Function!!
     fHMeanTimeSector = new TH2F("fHMeanTimeSector","Abs mean time per sector",
                                 20*(fLastTimeBin-fFirstTimeBin), fFirstTimeBin, fLastTimeBin,
@@ -833,13 +813,12 @@ TH2F* AliTPCCalibPulser::GetHistoTSec()
 //_____________________________________________________________________
 TVectorF* AliTPCCalibPulser::GetPadInfoEvent(Int_t sector, TObjArray *arr, Bool_t force)
 {
-    //
-    // return pointer to Pad Info from 'arr' for the current event and sector
-    // if force is true create it if it doesn't exist allready
-    //
+    /// return pointer to Pad Info from 'arr' for the current event and sector
+    /// if force is true create it if it doesn't exist allready
+
   if ( !force || arr->UncheckedAt(sector) )
     return (TVectorF*)arr->UncheckedAt(sector);
-  
+
   TVectorF *vect = new TVectorF(fROC->GetNChannels(sector));
   arr->AddAt(vect,sector);
   return vect;
@@ -847,59 +826,53 @@ TVectorF* AliTPCCalibPulser::GetPadInfoEvent(Int_t sector, TObjArray *arr, Bool_
 //_____________________________________________________________________
 TVectorF* AliTPCCalibPulser::GetPadTimesEvent(Int_t sector, Bool_t force)
 {
-    //
-    // return pointer to Pad Times Array for the current event and sector
-    // if force is true create it if it doesn't exist allready
-    //
+    /// return pointer to Pad Times Array for the current event and sector
+    /// if force is true create it if it doesn't exist allready
+
   TObjArray *arr = &fPadTimesArrayEvent;
   return GetPadInfoEvent(sector,arr,force);
 }
 //_____________________________________________________________________
 TVectorF* AliTPCCalibPulser::GetPadQEvent(Int_t sector, Bool_t force)
 {
-    //
-    // return pointer to Pad Q Array for the current event and sector
-    // if force is true create it if it doesn't exist allready
-    // for debugging purposes only
-    //
-  
+    /// return pointer to Pad Q Array for the current event and sector
+    /// if force is true create it if it doesn't exist allready
+    /// for debugging purposes only
+
   TObjArray *arr = &fPadQArrayEvent;
   return GetPadInfoEvent(sector,arr,force);
 }
 //_____________________________________________________________________
 TVectorF* AliTPCCalibPulser::GetPadRMSEvent(Int_t sector, Bool_t force)
 {
-    //
-    // return pointer to Pad RMS Array for the current event and sector
-    // if force is true create it if it doesn't exist allready
-    // for debugging purposes only
-    //
+    /// return pointer to Pad RMS Array for the current event and sector
+    /// if force is true create it if it doesn't exist allready
+    /// for debugging purposes only
+
   TObjArray *arr = &fPadRMSArrayEvent;
   return GetPadInfoEvent(sector,arr,force);
 }
 //_____________________________________________________________________
 TVectorF* AliTPCCalibPulser::GetPadPedestalEvent(Int_t sector, Bool_t force)
 {
-    //
-    // return pointer to Pad RMS Array for the current event and sector
-    // if force is true create it if it doesn't exist allready
-    // for debugging purposes only
-    //
+    /// return pointer to Pad RMS Array for the current event and sector
+    /// if force is true create it if it doesn't exist allready
+    /// for debugging purposes only
+
   TObjArray *arr = &fPadPedestalArrayEvent;
   return GetPadInfoEvent(sector,arr,force);
 }
 //_____________________________________________________________________
 AliTPCCalROC* AliTPCCalibPulser::GetCalRoc(Int_t sector, TObjArray* arr, Bool_t force) const
 {
-    //
-    // return pointer to ROC Calibration
-    // if force is true create a new histogram if it doesn't exist allready
-    //
+    /// return pointer to ROC Calibration
+    /// if force is true create a new histogram if it doesn't exist allready
+
   if ( !force || arr->UncheckedAt(sector) )
     return (AliTPCCalROC*)arr->UncheckedAt(sector);
-  
+
     // if we are forced and histogram doesn't yes exist create it
-  
+
     // new AliTPCCalROC for T0 information. One value for each pad!
   AliTPCCalROC *croc = new AliTPCCalROC(sector);
   arr->AddAt(croc,sector);
@@ -908,63 +881,58 @@ AliTPCCalROC* AliTPCCalibPulser::GetCalRoc(Int_t sector, TObjArray* arr, Bool_t
 //_____________________________________________________________________
 AliTPCCalROC* AliTPCCalibPulser::GetCalRocT0(Int_t sector, Bool_t force)
 {
-    //
-    // return pointer to Carge ROC Calibration
-    // if force is true create a new histogram if it doesn't exist allready
-    //
+    /// return pointer to Carge ROC Calibration
+    /// if force is true create a new histogram if it doesn't exist allready
+
   TObjArray *arr = &fCalRocArrayT0;
   return GetCalRoc(sector, arr, force);
 }
 //_____________________________________________________________________
 AliTPCCalROC* AliTPCCalibPulser::GetCalRocQ(Int_t sector, Bool_t force)
 {
-    //
-    // return pointer to T0 ROC Calibration
-    // if force is true create a new histogram if it doesn't exist allready
-    //
+    /// return pointer to T0 ROC Calibration
+    /// if force is true create a new histogram if it doesn't exist allready
+
   TObjArray *arr = &fCalRocArrayQ;
   return GetCalRoc(sector, arr, force);
 }
 //_____________________________________________________________________
 AliTPCCalROC* AliTPCCalibPulser::GetCalRocRMS(Int_t sector, Bool_t force)
 {
-    //
-    // return pointer to signal width ROC Calibration
-    // if force is true create a new histogram if it doesn't exist allready
-    //
+    /// return pointer to signal width ROC Calibration
+    /// if force is true create a new histogram if it doesn't exist allready
+
   TObjArray *arr = &fCalRocArrayRMS;
   return GetCalRoc(sector, arr, force);
 }
 //_____________________________________________________________________
 AliTPCCalROC* AliTPCCalibPulser::GetCalRocOutliers(Int_t sector, Bool_t force)
 {
-    //
-    // return pointer to Outliers
-    // if force is true create a new histogram if it doesn't exist allready
-    //
+    /// return pointer to Outliers
+    /// if force is true create a new histogram if it doesn't exist allready
+
   TObjArray *arr = &fCalRocArrayOutliers;
   return GetCalRoc(sector, arr, force);
 }
 //_____________________________________________________________________
 void AliTPCCalibPulser::ResetEvent()
 {
-    //
-    //  Reset global counters  -- Should be called before each event is processed
-    //
+    ///  Reset global counters  -- Should be called before each event is processed
+
   fLastSector=-1;
   fCurrentSector=-1;
   fCurrentRow=-1;
   fCurrentPad=-1;
   fCurrentChannel=-1;
-  
+
   ResetPad();
-  
+
   fPadTimesArrayEvent.Delete();
-  
+
   fPadQArrayEvent.Delete();
   fPadRMSArrayEvent.Delete();
   fPadPedestalArrayEvent.Delete();
-  
+
   for ( Int_t i=0; i<72; ++i ){
     fVTime0Offset[i]=0;
     fVTime0OffsetCounter[i]=0;
@@ -973,9 +941,8 @@ void AliTPCCalibPulser::ResetEvent()
 //_____________________________________________________________________
 void AliTPCCalibPulser::ResetPad()
 {
-    //
-    //  Reset pad infos -- Should be called after a pad has been processed
-    //
+    ///  Reset pad infos -- Should be called after a pad has been processed
+
   for (Int_t i=fFirstTimeBin; i<fLastTimeBin+1; ++i)
     fPadSignal[i] = 0;
   fMaxTimeBin = -1;
@@ -986,21 +953,18 @@ void AliTPCCalibPulser::ResetPad()
 //_____________________________________________________________________
 Bool_t AliTPCCalibPulser::IsEdgePad(Int_t sector, Int_t row, Int_t pad)
 {
-    //
-    // return true if pad is on the edge of a row
-    //
+    /// return true if pad is on the edge of a row
+
   Int_t edge1   = 0;
   Int_t edge2   = fROC->GetNPads(sector,row)-1;
   if ( pad == edge1 || pad == edge2 ) return kTRUE;
-  
+
   return kFALSE;
 }
 //_____________________________________________________________________
 void AliTPCCalibPulser::Merge(AliTPCCalibPulser * const sig)
 {
-  //
-  //  Merge reference histograms of sig to the current AliTPCCalibPulser
-  //
+  ///  Merge reference histograms of sig to the current AliTPCCalibPulser
 
   MergeBase(sig);
   //merge histograms
@@ -1008,8 +972,8 @@ void AliTPCCalibPulser::Merge(AliTPCCalibPulser * const sig)
     TH2S *hRefQmerge   = sig->GetHistoQ(iSec);
     TH2S *hRefT0merge  = sig->GetHistoT0(iSec);
     TH2S *hRefRMSmerge = sig->GetHistoRMS(iSec);
-    
-    
+
+
     if ( hRefQmerge ){
       TDirectory *dir = hRefQmerge->GetDirectory(); hRefQmerge->SetDirectory(0);
       TH2S *hRefQ   = GetHistoQ(iSec);
@@ -1043,7 +1007,7 @@ void AliTPCCalibPulser::Merge(AliTPCCalibPulser * const sig)
       }
       hRefRMSmerge->SetDirectory(dir);
     }
-    
+
   }
   if ( sig->fHMeanTimeSector ){
     TDirectory *dir = sig->fHMeanTimeSector->GetDirectory(); sig->fHMeanTimeSector->SetDirectory(0);
@@ -1060,16 +1024,14 @@ void AliTPCCalibPulser::Merge(AliTPCCalibPulser * const sig)
 //_____________________________________________________________________
 Long64_t AliTPCCalibPulser::Merge(TCollection * const list)
 {
-  //
-  // Merge all objects of this type in list
-  //
-  
+  /// Merge all objects of this type in list
+
   Long64_t nmerged=1;
-  
+
   TIter next(list);
   AliTPCCalibPulser *ce=0;
   TObject *o=0;
-  
+
   while ( (o=next()) ){
     ce=dynamic_cast<AliTPCCalibPulser*>(o);
     if (ce){
@@ -1077,17 +1039,15 @@ Long64_t AliTPCCalibPulser::Merge(TCollection * const list)
       ++nmerged;
     }
   }
-  
+
   return nmerged;
 }
 
 //_____________________________________________________________________
 void AliTPCCalibPulser::Analyse()
 {
-  //
-  //  Calculate calibration constants
-  //
-  
+  ///  Calculate calibration constants
+
   TVectorD paramQ(3);
   TVectorD paramT0(3);
   TVectorD paramRMS(3);
@@ -1095,7 +1055,7 @@ void AliTPCCalibPulser::Analyse()
   //calculate mean time for each sector and mean time for each side
   TH1F hMeanTsec("hMeanTsec","hMeanTsec",20*(fLastTimeBin-fFirstTimeBin),fFirstTimeBin,fLastTimeBin);
   fVMeanTimeSector.Zero();
-  
+
   for (Int_t iSec=0; iSec<72; ++iSec){
     TH2S *hT0 = GetHistoT0(iSec);
     if (!hT0 ) continue;
@@ -1113,35 +1073,35 @@ void AliTPCCalibPulser::Analyse()
       if ( entries>0 ) AliMathBase::TruncatedMean(&hMeanTsec,&paramT0,0.05,.95);
       fVMeanTimeSector[iSec]=paramT0[1];
     }
-    
+
     AliTPCCalROC *rocQ   = GetCalRocQ  (iSec,kTRUE);
     AliTPCCalROC *rocT0  = GetCalRocT0 (iSec,kTRUE);
     AliTPCCalROC *rocRMS = GetCalRocRMS(iSec,kTRUE);
     AliTPCCalROC *rocOut = GetCalRocOutliers(iSec,kTRUE);
-    
+
     TH2S *hQ   = GetHistoQ(iSec);
     TH2S *hRMS = GetHistoRMS(iSec);
-    
+
     Short_t *arrayhQ   = hQ->GetArray();
     Short_t *arrayhT0  = hT0->GetArray();
     Short_t *arrayhRMS = hRMS->GetArray();
-    
+
     UInt_t nChannels = fROC->GetNChannels(iSec);
     Float_t meanTsec = fVMeanTimeSector[iSec];
-    
+
   //debug
     Int_t row=0;
     Int_t pad=0;
     Int_t padc=0;
   //! debug
-    
+
     for (UInt_t iChannel=0; iChannel<nChannels; ++iChannel){
-      
+
       Float_t cogTime0 = -1000;
       Float_t cogQ     = -1000;
       Float_t cogRMS   = -1000;
       Float_t cogOut   = 0;
-      
+
       Int_t offsetQ = (fNbinsQ+2)*(iChannel+1)+1;
       Int_t offsetT0 = (fNbinsT0+2)*(iChannel+1)+1;
       Int_t offsetRMS = (fNbinsRMS+2)*(iChannel+1)+1;
@@ -1156,7 +1116,7 @@ void AliTPCCalibPulser::Analyse()
       cogQ     = AliMathBase::GetCOG(arrayhQ+offsetQ,fNbinsQ,fXminQ,fXmaxQ);
       cogTime0 = AliMathBase::GetCOG(arrayhT0+offsetT0,fNbinsT0,fXminT0,fXmaxT0);
       cogRMS   = AliMathBase::GetCOG(arrayhRMS+offsetRMS,fNbinsRMS,fXminRMS,fXmaxRMS);
-      
+
       /*
       if ( (cogQ < ??) && (cogTime0 > ??) && (cogTime0<??) && ( cogRMS>??) ){
     cogOut = 1;
@@ -1177,7 +1137,7 @@ void AliTPCCalibPulser::Analyse()
         rocT0->SetValue(iChannel, 0); //offset by mean time of the sector
         rocRMS->SetValue(iChannel, 0);
       }
-      
+
       //debug
       if ( GetStreamLevel() > 2 ){
         TTreeSRedirector *streamer=GetDebugStreamer();
@@ -1185,7 +1145,7 @@ void AliTPCCalibPulser::Analyse()
           while ( iChannel > (fROC->GetRowIndexes(iSec)[row]+fROC->GetNPads(iSec,row)-1) ) row++;
           pad = iChannel-fROC->GetRowIndexes(iSec)[row];
           padc = pad-(fROC->GetNPads(iSec,row)/2);
-          
+
           (*streamer) << "DataEnd" <<
             "Sector="  << iSec      <<
             "Pad="     << pad       <<
@@ -1200,8 +1160,8 @@ void AliTPCCalibPulser::Analyse()
       }
       //! debug
     }
-    
-    
+
+
   }
 }
 //_____________________________________________________________________
@@ -1209,19 +1169,18 @@ void AliTPCCalibPulser::Analyse()
 //_____________________________________________________________________
 TObjArray* AliTPCCalibPulser::TestBinning()
 {
-  //
-  //  Function to test the binning of the reference histograms
-  //  type: T0, Q or RMS
-  //  mode: 0 - number of filled bins per channel
-  //        1 - number of empty bins between filled bins in one ROC
-  //  returns TObjArray with the test histograms type*2+mode:
-  //  position 0 = T0,0 ; 1 = T0,1 ; 2 = Q,0 ...
-  
-  
+  ///  Function to test the binning of the reference histograms
+  ///  type: T0, Q or RMS
+  ///  mode: 0 - number of filled bins per channel
+  ///        1 - number of empty bins between filled bins in one ROC
+  ///  returns TObjArray with the test histograms type*2+mode:
+  ///  position 0 = T0,0 ; 1 = T0,1 ; 2 = Q,0 ...
+
+
   TObjArray *histArray = new TObjArray(6);
   const Char_t *type[] = {"T0","Q","RMS"};
   Int_t fNbins[3] = {fNbinsT0,fNbinsQ,fNbinsRMS};
-  
+
   for (Int_t itype = 0; itype<3; ++itype){
     for (Int_t imode=0; imode<2; ++imode){
       Int_t icount = itype*2+imode;
@@ -1231,8 +1190,8 @@ TObjArray* AliTPCCalibPulser::TestBinning()
                        icount);
     }
   }
-  
-  
+
+
   TH2S *hRef=0x0;
   Short_t *array=0x0;
   for (Int_t itype = 0; itype<3; ++itype){
@@ -1243,7 +1202,7 @@ TObjArray* AliTPCCalibPulser::TestBinning()
       if ( hRef == 0x0 ) continue;
       array = (hRef->GetArray());
       UInt_t nChannels = fROC->GetNChannels(iSec);
-      
+
       Int_t nempty=0;
       for (UInt_t iChannel=0; iChannel<nChannels; ++iChannel){
         Int_t nfilled=0;
@@ -1257,7 +1216,7 @@ TObjArray* AliTPCCalibPulser::TestBinning()
             else c1 = 1;
           }
           else if ( c1 ) c2 = 1;
-          
+
         }
         ((TH1F*)histArray->At(itype*2))->Fill(nfilled);
       }
diff --git a/TPC/TPCbase/AliTPCCalibPulser.h b/TPC/TPCbase/AliTPCCalibPulser.h
index a1ca3bc6b9a..b092f684b47 100644
--- a/TPC/TPCbase/AliTPCCalibPulser.h
+++ b/TPC/TPCbase/AliTPCCalibPulser.h
@@ -3,11 +3,8 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-/////////////////////////////////////////////////////////////////////////////////////////
-//                                                                                     //
-//                  Implementation of the TPC pulser calibration                       //
-//                                                                                     //
-/////////////////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCCalibPulser
+/// \brief Iplementation of the TPC pulser calibration
 
 #include <TVectorT.h>
 #include "AliTPCCalibRawBase.h"
@@ -31,12 +28,12 @@ public:
   AliTPCCalibPulser(const AliTPCCalibPulser &sig);
   AliTPCCalibPulser(const TMap *config);
   virtual ~AliTPCCalibPulser();
-  
+
   void Reset();
-  
+
   AliTPCCalibPulser& operator = (const  AliTPCCalibPulser &source);
-  
-  
+
+
   virtual Int_t Update(const Int_t isector, const Int_t iRow, const Int_t iPad,
                        const Int_t iTimeBin, const Float_t signal);
   virtual void Analyse();
@@ -45,21 +42,21 @@ public:
   AliTPCCalROC* GetCalRocQ  (Int_t sector, Bool_t force=kFALSE);  // get calibration object - sector
   AliTPCCalROC* GetCalRocRMS(Int_t sector, Bool_t force=kFALSE);  // get calibration object - sector
   AliTPCCalROC* GetCalRocOutliers(Int_t sector, Bool_t force=kFALSE);  // get calibration object - sector
-  
+
   const TObjArray* GetCalPadT0()  const { return &fCalRocArrayT0; }      // get calibration object
   const TObjArray* GetCalPadQ()   const { return &fCalRocArrayQ;  }      // get calibration object
   const TObjArray* GetCalPadRMS() const{ return &fCalRocArrayRMS;}      // get calibration object
   const TObjArray* GetCalPadOutliers() const { return &fCalRocArrayOutliers;}      // get calibration object
-  
+
   TH2S* GetHistoQ  (Int_t sector, Bool_t force=kFALSE);           // get refernce histogram
   TH2S* GetHistoT0 (Int_t sector, Bool_t force=kFALSE);           // get refernce histogram
   TH2S* GetHistoRMS(Int_t sector, Bool_t force=kFALSE);           // get refernce histogram
-  
+
   TH2F* GetHistoTSec();                                        // mean abs time distribution histogram
-  
+
   Float_t GetMeanTimeSector(Int_t sector) const {return fVMeanTimeSector[sector];}
   const TVectorF* GetMeanTimeSectorArray() const {return &fVMeanTimeSector;}
-  
+
   Short_t GetDebugLevel()     const { return fDebugLevel;    }
     //
   void  SetRangeTime (Int_t firstTimeBin, Int_t lastTimeBin) { fFirstTimeBin=firstTimeBin;   fLastTimeBin=lastTimeBin;  } //Set range in which the pulser signal is expected
@@ -68,113 +65,115 @@ public:
   void  SetRangeRefT0 (Int_t nBins, Float_t xMin, Float_t xMax){ fNbinsT0  = nBins; fXminT0  = xMin; fXmaxT0  = xMax; }   //Set range for T0 reference histograms
   void  SetRangeRefRMS(Int_t nBins, Float_t xMin, Float_t xMax){ fNbinsRMS = nBins; fXminRMS = xMin; fXmaxRMS = xMax; }   //Set range for T0 reference histograms
   void  SetRangePeakIntegral(Int_t minus, Int_t plus) { fPeakIntMinus=minus; fPeakIntPlus=plus;}
-  
+
   void  SetDebugLevel(Short_t debug=1){ fDebugLevel = debug;}
-  
+
   void  SetIsZeroSuppressed(Bool_t zs=kTRUE){ fIsZeroSuppressed=zs;}
-  
+
   void  SetPedestalDatabase(AliTPCCalPad * const pedestalTPC, AliTPCCalPad * const padNoiseTPC) {fPedestalTPC = pedestalTPC; fPadNoiseTPC = padNoiseTPC;}
   void  SetOutliers(AliTPCCalPad * const outliers)  {fOutliers = outliers;}
-  
+
   Bool_t GetIsZeroSupperssed() const { return fIsZeroSuppressed; }
 
   Float_t GetPeakIntegralMinus() const {return fPeakIntMinus;}
   Float_t GetPeakIntegralPlus() const {return fPeakIntPlus;}
-  
+
   void Merge(AliTPCCalibPulser * const sig);
   virtual Long64_t Merge(TCollection * const list);
-  
+
   //
   // Test functions
   TObjArray* TestBinning();
-  
+
 protected:
   virtual void ResetEvent();
   virtual void EndEvent();
-  
+
 private:
     // reference histogram ranges
-  Int_t   fNbinsT0;                 //  Number of bins for T0 reference histogram
-  Float_t fXminT0;                  //  xmin   of T0 reference histogram
-  Float_t fXmaxT0;                  //  xmax   of T0 reference histogram
-  Int_t   fNbinsQ;                  //  Number of bins for T0 reference histogram
-  Float_t fXminQ;                   //  xmin   of T0 reference histogram
-  Float_t fXmaxQ;                   //  xmax   of T0 reference histogram
-  Int_t   fNbinsRMS;                //  Number of bins for T0 reference histogram
-  Float_t fXminRMS;                 //  xmin   of T0 reference histogram
-  Float_t fXmaxRMS;                 //  xmax   of T0 reference histogram
-  Int_t   fPeakIntMinus;            //  Peak integral range for COG determination. Bins used before max bin
-  Int_t   fPeakIntPlus;             //  Peak integral range for COG determination. Bins used after max bin
-  
-  Bool_t  fIsZeroSuppressed;        //  if data is zero suppressed
-  
-  Int_t     fLastSector;            //! Last sector processed
-
-  AliTPCParam *fParam;              //! TPC information
-  
-  AliTPCCalPad *fPedestalTPC;       //! Pedestal Information
-  AliTPCCalPad *fPadNoiseTPC;       //! Pad noise Information whole TPC
-  AliTPCCalPad *fOutliers;          //! Outlier information. Those will not be used for calculating the T0
-  AliTPCCalROC *fPedestalROC;       //! Pedestal Information for current ROC
-  AliTPCCalROC *fPadNoiseROC;       //! Pad noise Information for current ROC
-  
-  TObjArray fCalRocArrayT0;         //  Array of AliTPCCalROC class for Time0 calibration
-  TObjArray fCalRocArrayQ;          //  Array of AliTPCCalROC class for Charge calibration
-  TObjArray fCalRocArrayRMS;        //  Array of AliTPCCalROC class for signal width calibration
-  TObjArray fCalRocArrayOutliers;  //  Array of AliTPCCalROC class for signal outliers
-  
-  TObjArray fHistoQArray;           //  Calibration histograms for Charge distribution
-  TObjArray fHistoT0Array;          //  Calibration histograms for Time0  distribution
-  TObjArray fHistoRMSArray;         //  Calibration histograms for signal width distribution
-  
-  TH2F *fHMeanTimeSector;           //  Timing distribution per sector
-  TVectorF  fVMeanTimeSector;       //  Mean time per sector from analysis of fHMeanTimeSector
-  
-  TObjArray fPadTimesArrayEvent;    //! Pad Times for the event, before mean Time0 corrections
-  TObjArray fPadQArrayEvent;        //! Charge for the event, only needed for debugging streamer
-  TObjArray fPadRMSArrayEvent;      //! Signal width for the event, only needed for debugging streamer
-  TObjArray fPadPedestalArrayEvent; //! Signal width for the event, only needed for debugging streamer
-  
-  Int_t     fCurrentChannel;         //! current channel processed
-  Int_t     fCurrentSector;          //! current sector processed
-  Int_t     fCurrentRow;             //! current row processed
-  Int_t     fCurrentPad;             //! current pad processed
-  Float_t   fMaxPadSignal;           //! maximum bin of current pad
-  Int_t     fMaxTimeBin;             //! time bin with maximum value
-  TVectorF  fPadSignal;              //! signal of current Pad
-  Float_t   fPadPedestal;            //! Pedestal Value of current pad
-  Float_t   fPadNoise;               //! Noise Value of current pad
-  
-  TVectorF  fVTime0Offset;          //!  Time0 Offset from preprocessing for each sector;
-  TVectorF  fVTime0OffsetCounter;   //!  Time0 Offset from preprocessing for each sector;
-  
-  
+  Int_t   fNbinsT0;                 ///< Number of bins for T0 reference histogram
+  Float_t fXminT0;                  ///< xmin   of T0 reference histogram
+  Float_t fXmaxT0;                  ///< xmax   of T0 reference histogram
+  Int_t   fNbinsQ;                  ///< Number of bins for T0 reference histogram
+  Float_t fXminQ;                   ///< xmin   of T0 reference histogram
+  Float_t fXmaxQ;                   ///< xmax   of T0 reference histogram
+  Int_t   fNbinsRMS;                ///< Number of bins for T0 reference histogram
+  Float_t fXminRMS;                 ///< xmin   of T0 reference histogram
+  Float_t fXmaxRMS;                 ///< xmax   of T0 reference histogram
+  Int_t   fPeakIntMinus;            ///< Peak integral range for COG determination. Bins used before max bin
+  Int_t   fPeakIntPlus;             ///< Peak integral range for COG determination. Bins used after max bin
+
+  Bool_t  fIsZeroSuppressed;        ///< if data is zero suppressed
+
+  Int_t     fLastSector;            //!< Last sector processed
+
+  AliTPCParam *fParam;              //!< TPC information
+
+  AliTPCCalPad *fPedestalTPC;       //!< Pedestal Information
+  AliTPCCalPad *fPadNoiseTPC;       //!< Pad noise Information whole TPC
+  AliTPCCalPad *fOutliers;          //!< Outlier information. Those will not be used for calculating the T0
+  AliTPCCalROC *fPedestalROC;       //!< Pedestal Information for current ROC
+  AliTPCCalROC *fPadNoiseROC;       //!< Pad noise Information for current ROC
+
+  TObjArray fCalRocArrayT0;         ///< Array of AliTPCCalROC class for Time0 calibration
+  TObjArray fCalRocArrayQ;          ///< Array of AliTPCCalROC class for Charge calibration
+  TObjArray fCalRocArrayRMS;        ///< Array of AliTPCCalROC class for signal width calibration
+  TObjArray fCalRocArrayOutliers;  ///< Array of AliTPCCalROC class for signal outliers
+
+  TObjArray fHistoQArray;           ///< Calibration histograms for Charge distribution
+  TObjArray fHistoT0Array;          ///< Calibration histograms for Time0  distribution
+  TObjArray fHistoRMSArray;         ///< Calibration histograms for signal width distribution
+
+  TH2F *fHMeanTimeSector;           ///< Timing distribution per sector
+  TVectorF  fVMeanTimeSector;       ///< Mean time per sector from analysis of fHMeanTimeSector
+
+  TObjArray fPadTimesArrayEvent;    //!< Pad Times for the event, before mean Time0 corrections
+  TObjArray fPadQArrayEvent;        //!< Charge for the event, only needed for debugging streamer
+  TObjArray fPadRMSArrayEvent;      //!< Signal width for the event, only needed for debugging streamer
+  TObjArray fPadPedestalArrayEvent; //!< Signal width for the event, only needed for debugging streamer
+
+  Int_t     fCurrentChannel;         //!< current channel processed
+  Int_t     fCurrentSector;          //!< current sector processed
+  Int_t     fCurrentRow;             //!< current row processed
+  Int_t     fCurrentPad;             //!< current pad processed
+  Float_t   fMaxPadSignal;           //!< maximum bin of current pad
+  Int_t     fMaxTimeBin;             //!< time bin with maximum value
+  TVectorF  fPadSignal;              //!< signal of current Pad
+  Float_t   fPadPedestal;            //!< Pedestal Value of current pad
+  Float_t   fPadNoise;               //!< Noise Value of current pad
+
+  TVectorF  fVTime0Offset;          //!< Time0 Offset from preprocessing for each sector;
+  TVectorF  fVTime0OffsetCounter;   //!< Time0 Offset from preprocessing for each sector;
+
+
   void   FindPedestal(Float_t part=.6);
   void FindPulserSignal(TVectorD &param, Float_t &qSum);
-  
+
   TH2S* GetHisto(Int_t sector, TObjArray *arr,
                  Int_t nbinsY, Float_t ymin, Float_t ymax,
                  const Char_t *type, Bool_t force);
-  
-  
+
+
   AliTPCCalROC* GetCalRoc(Int_t sector, TObjArray* arr, Bool_t force) const;
-  
+
   TVectorF* GetPadTimesEvent(Int_t sector, Bool_t force=kFALSE);
-  
+
   Bool_t IsEdgePad(Int_t sector, Int_t row, Int_t pad);
-  
+
   void ResetPad();
   void ProcessPad();
-  
-  
+
+
   //debug
   TVectorF* GetPadInfoEvent(Int_t sector, TObjArray *arr, Bool_t force=kFALSE);
   TVectorF* GetPadQEvent(Int_t sector, Bool_t force=kFALSE);
   TVectorF* GetPadRMSEvent(Int_t sector, Bool_t force=kFALSE);
   TVectorF* GetPadPedestalEvent(Int_t sector, Bool_t force=kFALSE);
 
-  
+
+  /// \cond CLASSIMP
   ClassDef(AliTPCCalibPulser,5)           //Implementation of the TPC pulser calibration
+  /// \endcond
 };
 
 
diff --git a/TPC/TPCbase/AliTPCCalibRaw.cxx b/TPC/TPCbase/AliTPCCalibRaw.cxx
index d438fc790c5..be55889e7e5 100644
--- a/TPC/TPCbase/AliTPCCalibRaw.cxx
+++ b/TPC/TPCbase/AliTPCCalibRaw.cxx
@@ -15,50 +15,41 @@
 
 /* $Id:  $ */
 
-////////////////////////////////////////////////////////////////////////////////////////
-//                                                                                    //
-//     Implementation of the TPC Raw drift velocity and Altro L1 Phase  calibration   //
-//                                                                                    //
-//               Origin: Jens Wiechula, J.Wiechula@gsi.de                             //
-//                                                                                    //
-////////////////////////////////////////////////////////////////////////////////////////
-//
-//
-// *************************************************************************************
-// *                                Class Description                                  *
-// *************************************************************************************
-/*
-
-----example---
-TFile f("CalibAltro.root");
-AliTPCCalibRaw *al=(AliTPCCalibRaw*)f.Get(f.GetListOfKeys()->At(0)->GetName())
-{
-TCanvas *c1=(TCanvas*)gROOT->FindObject("c1");
-if (!c1) c1=new TCanvas("c1","c1");
-c1->Clear();
-
-TH2F h2f("h2","h2;RCU;fail",216,0,216,al->GetNevents(),0,al->GetNevents());
-Bool_t first=kTRUE;
-Int_t i,iev;
-for (i=0;i<216;++i) {
-  TVectorF *v=al->GetALTROL1PhaseFailEventsRCU(i);
-  if (!v) continue;
-  for (iev=0;iev<al->GetNevents();++iev) {
-    h2f->SetBinContent(i+1,iev+1,(*v)(iev));
-  }
-//   TH1F h(*v);
-//   h.SetLineColor(i/216.*50+50);
-//   ((TH1F*)h.Clone(Form("h%d",i)))->Draw(first?"":"same");
-//   c1->Modified();
-//   c1->Update();
-  first=kFALSE;
-}
-h2f->Draw("col");
-}
-
-*/
-
-
+/// \class AliTPCCalibRaw
+/// \brief Implementation of the TPC Raw drift velocity and Altro L1 Phase  calibration
+///
+/// \author Jens Wiechula, J.Wiechula@gsi.de
+///
+/// Class Description
+/// -----------------
+///
+/// ~~~{.cpp}
+/// TFile f("CalibAltro.root");
+/// AliTPCCalibRaw *al=(AliTPCCalibRaw*)f.Get(f.GetListOfKeys()->At(0)->GetName())
+/// {
+/// TCanvas *c1=(TCanvas*)gROOT->FindObject("c1");
+/// if (!c1) c1=new TCanvas("c1","c1");
+/// c1->Clear();
+///
+/// TH2F h2f("h2","h2;RCU;fail",216,0,216,al->GetNevents(),0,al->GetNevents());
+/// Bool_t first=kTRUE;
+/// Int_t i,iev;
+/// for (i=0;i<216;++i) {
+///   TVectorF *v=al->GetALTROL1PhaseFailEventsRCU(i);
+///   if (!v) continue;
+///   for (iev=0;iev<al->GetNevents();++iev) {
+///     h2f->SetBinContent(i+1,iev+1,(*v)(iev));
+///   }
+/// //   TH1F h(*v);
+/// //   h.SetLineColor(i/216.*50+50);
+/// //   ((TH1F*)h.Clone(Form("h%d",i)))->Draw(first?"":"same");
+/// //   c1->Modified();
+/// //   c1->Update();
+///   first=kFALSE;
+/// }
+/// h2f->Draw("col");
+/// }
+/// ~~~
 
 //Root includes
 #include <TROOT.h>
@@ -76,7 +67,9 @@ h2f->Draw("col");
 //class header
 #include "AliTPCCalibRaw.h"
 
+/// \cond CLASSIMP
 ClassImp(AliTPCCalibRaw)
+/// \endcond
 
 AliTPCCalibRaw::AliTPCCalibRaw() :
   AliTPCCalibRawBase(),
@@ -156,9 +149,8 @@ fVSignalSumSenEvent(100000),
 fVNfiredPadsSenEvent(100000),
 fVTimeStampEvent(100000)
 {
-  //
-  // Default ctor
-  //
+  /// Default ctor
+
   SetNameTitle("AliTPCCalibRaw","AliTPCCalibRaw");
   CreateDVhist();
   for (Int_t ircu=0;ircu<kNRCU;++ircu) fArrCurrentPhase.GetMatrixArray()[ircu]=-1;
@@ -172,10 +164,9 @@ fVTimeStampEvent(100000)
 //_____________________________________________________________________
 AliTPCCalibRaw::~AliTPCCalibRaw()
 {
-  //
-  // dtor
-  //
-  delete fHnDrift;  
+  /// dtor
+
+  delete fHnDrift;
 }
 //_____________________________________________________________________
 // AliTPCCalibRaw& AliTPCCalibRaw::operator = (const  AliTPCCalibRaw &source)
@@ -185,7 +176,7 @@ AliTPCCalibRaw::~AliTPCCalibRaw()
 //   //
 //   if (&source == this) return *this;
 //   new (this) AliTPCCalibRaw(source);
-//   
+//
 //   return *this;
 // }
 
@@ -193,9 +184,8 @@ AliTPCCalibRaw::~AliTPCCalibRaw()
 Int_t AliTPCCalibRaw::Update(const Int_t isector, const Int_t iRow, const Int_t iPad,
              const Int_t iTimeBin, const Float_t signal)
 {
-  //
-  // Data filling method
-  //
+  /// Data filling method
+
   if (iRow<0) return 0;
   if (iPad<0) return 0;
   if (iTimeBin<0) return 0;
@@ -243,7 +233,7 @@ Int_t AliTPCCalibRaw::Update(const Int_t isector, const Int_t iRow, const Int_t
   }
 //   Double_t x2[kHnBinsDV]={2,isector,0};
 //   fHnDrift->Fill(x2);
-  
+
 
   if (signal>fLastSignal) ++fNOkPlus;
   else if(signal<fLastSignal && fNOkPlus>=fPeakDetPlus){
@@ -252,7 +242,7 @@ Int_t AliTPCCalibRaw::Update(const Int_t isector, const Int_t iRow, const Int_t
     if ( fNOkMinus>=fPeakDetMinus ) {
       Double_t x[kHnBinsDV]={static_cast<Double_t>(fPeakTimeBin),static_cast<Double_t>(isector),static_cast<Double_t>((fTimeStamp-fFirstTimeStamp)/fNSecTime)};
       fHnDrift->Fill(x);
-    } 
+    }
   } else {
     fNOkPlus=0;
     fNOkMinus=0;
@@ -267,10 +257,8 @@ Int_t AliTPCCalibRaw::Update(const Int_t isector, const Int_t iRow, const Int_t
 }
 //_____________________________________________________________________
 void AliTPCCalibRaw::UpdateDDL(){
-  //
-  // fill ALTRO L1 information
-  //
-  
+  /// fill ALTRO L1 information
+
   //set nanoseconds
   if (!fNanoSec) {
     TTimeStamp s;
@@ -282,14 +270,12 @@ void AliTPCCalibRaw::UpdateDDL(){
   fArrCurrentPhase.GetMatrixArray()[fCurrDDLNum]=phase;
   //increase phase counter
   ++((fArrCurrentPhaseDist.GetMatrixArray())[phase]);
-  
+
 }
 //_____________________________________________________________________
 void AliTPCCalibRaw::ResetEvent()
 {
-  //
-  // Reset event counters
-  //
+  /// Reset event counters
 
   fCurrentChannel=-1;
   fCurrentRow=-1;
@@ -299,11 +285,9 @@ void AliTPCCalibRaw::ResetEvent()
 //_____________________________________________________________________
 void AliTPCCalibRaw::EndEvent()
 {
-  //
-  // End event analysis
-  //
+  /// End event analysis
+
 
-  
   //find phase of the current event
   Int_t phaseMaxEntries=-1;
   Int_t maxEntries=0;
@@ -318,7 +302,7 @@ void AliTPCCalibRaw::EndEvent()
   if (fArrALTROL1Phase.GetNrows()-1<=GetNevents())
     fArrALTROL1Phase.ResizeTo(GetNevents()+10000);
   (fArrALTROL1Phase.GetMatrixArray())[GetNevents()]=phaseMaxEntries;
-  
+
   //loop over RCUs and test failures
   UInt_t fail=0;
   for (Int_t ircu=0;ircu<kNRCU;++ircu){
@@ -356,10 +340,10 @@ void AliTPCCalibRaw::EndEvent()
 //_____________________________________________________________________
 TH2C *AliTPCCalibRaw::MakeHistL1RCUEvents(Int_t type)
 {
-  // Create a 2D histo RCU:Events indicating the there was a deviation
-  // from the mean L1 phase of the event
-  //
-  //type: 0=Failures, 1=Phases
+  /// Create a 2D histo RCU:Events indicating the there was a deviation
+  /// from the mean L1 phase of the event
+  ///
+  /// type: 0=Failures, 1=Phases
 
   //number of relavant events, depending on version
   Int_t nevents=GetNevents();
@@ -404,9 +388,8 @@ TH2C *AliTPCCalibRaw::MakeHistL1RCUEvents(Int_t type)
 //_____________________________________________________________________
 TH1F *AliTPCCalibRaw::MakeHistL1PhaseDist()
 {
-  //
-  // L1 phase distribution. Should be flat in ideal case
-  //
+  /// L1 phase distribution. Should be flat in ideal case
+
   TH1F *h=new TH1F("L1phaseDist","Normalized L1 phase distribution;phase;fraction of events",4,0,4);
   h->Sumw2();
   for (Int_t iev=0;iev<GetNevents();++iev) h->Fill(fArrALTROL1Phase.GetMatrixArray()[iev]);
@@ -418,9 +401,8 @@ TH1F *AliTPCCalibRaw::MakeHistL1PhaseDist()
 //_____________________________________________________________________
 TVectorF *AliTPCCalibRaw::MakeVectL1PhaseDist()
 {
-  //
-  // L1 phase distribution. Should be flat in ideal case
-  //
+  /// L1 phase distribution. Should be flat in ideal case
+
   TVectorF *v=new TVectorF(4);
   for (Int_t iev=0;iev<GetNevents();++iev) {
     Int_t phase=(Int_t)fArrALTROL1Phase.GetMatrixArray()[iev];
@@ -431,10 +413,9 @@ TVectorF *AliTPCCalibRaw::MakeVectL1PhaseDist()
 //_____________________________________________________________________
 TH2C *AliTPCCalibRaw::MakeHistL1RCUEventsIROC(Int_t type)
 {
-  //
-  // Create a 2D histo RCU:Events indicating the there was a deviation
-  // from the mean L1 phase of the event
-  //
+  /// Create a 2D histo RCU:Events indicating the there was a deviation
+  /// from the mean L1 phase of the event
+
   TH2C *h2 = new TH2C("hL1FailRCUEventsIROC","L1 Failures IROCs;RCU;Event",72,0,36,GetNevents(),0,GetNevents());
   for (Int_t ircu=0;ircu<72;++ircu) {
     const TVectorF *v=0;
@@ -450,10 +431,9 @@ TH2C *AliTPCCalibRaw::MakeHistL1RCUEventsIROC(Int_t type)
 //_____________________________________________________________________
 TH2C *AliTPCCalibRaw::MakeHistL1RCUEventsOROC(Int_t type)
 {
-  //
-  // Create a 2D histo RCU:Events indicating the there was a deviation
-  // from the mean L1 phase of the event
-  //
+  /// Create a 2D histo RCU:Events indicating the there was a deviation
+  /// from the mean L1 phase of the event
+
   TH2C *h2 = new TH2C("hL1FailRCUEventsOROC","L1 Failures OROCs;RCU;Event",144,0,36,GetNevents(),0,GetNevents());
   for (Int_t ircu=72;ircu<kNRCU;++ircu) {
     const TVectorF *v=0;
@@ -469,9 +449,8 @@ TH2C *AliTPCCalibRaw::MakeHistL1RCUEventsOROC(Int_t type)
 //_____________________________________________________________________
 void AliTPCCalibRaw::CreateDVhist()
 {
-  //
-  // Setup the HnSparse for the drift velocity determination
-  //
+  /// Setup the HnSparse for the drift velocity determination
+
   if (fHnDrift) return;
   //HnSparse bins
   //time bin, roc, time
@@ -479,14 +458,12 @@ void AliTPCCalibRaw::CreateDVhist()
   Double_t xmin[kHnBinsDV] = {static_cast<Double_t>(fFirstTimeBin),0,0};
   Double_t xmax[kHnBinsDV] = {static_cast<Double_t>(fLastTimeBin),72,static_cast<Double_t>(fNBinsTime)};
   fHnDrift=new THnSparseI("fHnDrift",Form("Drift velocity using last time bin;time bin[#times 100ns];ROC;Time bin [#times %us]",fNSecTime),kHnBinsDV, bins, xmin, xmax);
-    
+
 }
 //_____________________________________________________________________
 void AliTPCCalibRaw::Analyse()
 {
-  //
-  // Analyse Data
-  //
+  /// Analyse Data
 
   //resize arrays
   fArrALTROL1Phase.ResizeTo(GetNevents());
@@ -515,33 +492,31 @@ void AliTPCCalibRaw::Analyse()
     fVTimeStampEvent.ResizeTo(0);
   }
   //Analyse drift velocity TODO
-  
+
 }
 //_____________________________________________________________________
 TGraph* AliTPCCalibRaw::MakeGraphOccupancy(const Int_t type, const Int_t xType)
 {
-  //
-  // create occupancy graph (of samples abouve threshold)
-  // type=0:   number of samples
-  // type=1:   mean data volume (ADC counts/sample)
-  // type=2:   data volume (ADC counts)
-  // type=3:   samples per ADC count
-  // type=4:   sample occupancy
-  //
-  // type=5: number of sample sensitive / number of samples
-  //
-  // same in sensitive regions:
-  // type=10:  number of samples
-  // type=11:  mean data volume (ADC counts/sample)
-  // type=12:  data volume (ADC counts)
-  // type=13:  samples per ADC count
-  // type=14:  sample occupancy
-  //
-  // type=16: number of samples sensitive / number of pads sensitive
-  // type=17: pad occupancy in sensitive regions
-  // xType=0:  vs. time stamp
-  // xType=1:  vs. event counter
-  //
+  /// create occupancy graph (of samples abouve threshold)
+  /// type=0:   number of samples
+  /// type=1:   mean data volume (ADC counts/sample)
+  /// type=2:   data volume (ADC counts)
+  /// type=3:   samples per ADC count
+  /// type=4:   sample occupancy
+  ///
+  /// type=5: number of sample sensitive / number of samples
+  ///
+  /// same in sensitive regions:
+  /// type=10:  number of samples
+  /// type=11:  mean data volume (ADC counts/sample)
+  /// type=12:  data volume (ADC counts)
+  /// type=13:  samples per ADC count
+  /// type=14:  sample occupancy
+  ///
+  /// type=16: number of samples sensitive / number of pads sensitive
+  /// type=17: pad occupancy in sensitive regions
+  /// xType=0:  vs. time stamp
+  /// xType=1:  vs. event counter
 
   TString title("Event occupancy");
   TString xTitle("Time");
@@ -564,7 +539,7 @@ TGraph* AliTPCCalibRaw::MakeGraphOccupancy(const Int_t type, const Int_t xType)
   }
   for (Int_t i=0;i<GetNevents(); ++i){
     Double_t nAboveThreshold=vOcc->GetMatrixArray()[i];
-    
+
     Double_t nSumADC        =1;
     Double_t timestamp      =1;
     Double_t nPads          =1;
@@ -611,18 +586,16 @@ TGraph* AliTPCCalibRaw::MakeGraphOccupancy(const Int_t type, const Int_t xType)
   //
   // Not implemented for the moment
   //
-//   return 0;  
+//   return 0;
 // }
 //_____________________________________________________________________
 TCanvas* AliTPCCalibRaw::MakeCanvasOccupancy(const Int_t xType, Bool_t sen)
 {
-  //
-  // Create a canvas with occupancy information of all 'type's (see MakeGraphOccupancy)
-  // xType=0: vs. timestamp
-  // xType=1: vs. event number
-  //
-  // sen=kTRUE: for sensitive regions
-  //
+  /// Create a canvas with occupancy information of all 'type's (see MakeGraphOccupancy)
+  /// xType=0: vs. timestamp
+  /// xType=1: vs. event number
+  ///
+  /// sen=kTRUE: for sensitive regions
 
   TString name("RawOccupancy_");
   TString title("Raw Occupancy vs. ");
@@ -652,9 +625,7 @@ TCanvas* AliTPCCalibRaw::MakeCanvasOccupancy(const Int_t xType, Bool_t sen)
 //_____________________________________________________________________
 void AliTPCCalibRaw::Merge(AliTPCCalibRaw * const sig)
 {
-  //
-  // Merge sig with this instance
-  //
+  /// Merge sig with this instance
 
   if (!sig) return;
   MergeBase(sig);
@@ -662,22 +633,20 @@ void AliTPCCalibRaw::Merge(AliTPCCalibRaw * const sig)
   fHnDrift->Add(sig->fHnDrift);
 
   //Add occupancy data
-  
+
 }
 
 //_____________________________________________________________________
 Long64_t AliTPCCalibRaw::Merge(TCollection * const list)
 {
-  //
-  // Merge all objects of this type in list
-  //
-  
+  /// Merge all objects of this type in list
+
   Long64_t nmerged=1;
-  
+
   TIter next(list);
   AliTPCCalibRaw *ce=0;
   TObject *o=0;
-  
+
   while ( (o=next()) ){
     ce=dynamic_cast<AliTPCCalibRaw*>(o);
     if (ce){
@@ -685,7 +654,7 @@ Long64_t AliTPCCalibRaw::Merge(TCollection * const list)
       ++nmerged;
     }
   }
-  
+
   return nmerged;
 }
 
diff --git a/TPC/TPCbase/AliTPCCalibRaw.h b/TPC/TPCbase/AliTPCCalibRaw.h
index 0d109f99879..284557f681c 100644
--- a/TPC/TPCbase/AliTPCCalibRaw.h
+++ b/TPC/TPCbase/AliTPCCalibRaw.h
@@ -3,11 +3,8 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-////////////////////////////////////////////////////////////////////////////////////////
-//                                                                                    //
-//                        TPC ALTRO Header analysis                                   //
-//                                                                                    //
-////////////////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCCalibRaw
+/// \brief TPC ALTRO Header analysis
 
 #include <TVectorF.h>
 #include <TObjArray.h>
@@ -77,44 +74,44 @@ public:
   virtual Long64_t Merge(TCollection * const list);
   
 private:
-  Int_t   fPeakDetMinus;             //  Consecutive timebins on rising edge to be regarded as a signal
-  Int_t   fPeakDetPlus;              //  Consecutive timebins on falling edge to be regarded as a signal
-  UInt_t  fNFailL1Phase;             //Number of failures in L1 phase
-  UInt_t  fNFailL1PhaseEvent;        //Number of events with L1 phase failures
+  Int_t   fPeakDetMinus;             ///< Consecutive timebins on rising edge to be regarded as a signal
+  Int_t   fPeakDetPlus;              ///< Consecutive timebins on falling edge to be regarded as a signal
+  UInt_t  fNFailL1Phase;             ///< Number of failures in L1 phase
+  UInt_t  fNFailL1PhaseEvent;        ///< Number of events with L1 phase failures
   //binning dv hist
-  UInt_t  fNSecTime;                 //Number of seconds per bin in time
-  UInt_t  fNBinsTime;                //Number of bin in time
+  UInt_t  fNSecTime;                 ///< Number of seconds per bin in time
+  UInt_t  fNBinsTime;                ///< Number of bin in time
   //processing information
-  Bool_t    fPadProcessed;           //! if last pead has already been filled for the current pad
-  Int_t     fCurrentChannel;         //! current channel processed
-  Int_t     fCurrentSector;          //! current sector processed
-  Int_t     fLastSector;             //! current sector processed
-  Int_t     fCurrentRow;             //! current row processed
-  Int_t     fCurrentPad;             //! current pad processed
-  Int_t     fLastTimeBinProc;        //! last time bin processed
-  Int_t     fPeakTimeBin;            //! time bin with local maximum
-  Int_t     fLastSignal;             //! last signal processed
-  Int_t     fNOkPlus;                //! number of processed time bins fullfilling peak criteria
-  Int_t     fNOkMinus;               //! number of processed time bins fullfilling peak criteria
-  Int_t     fNanoSec;                //! current nano seconds stamp
+  Bool_t    fPadProcessed;           //!< if last pead has already been filled for the current pad
+  Int_t     fCurrentChannel;         //!< current channel processed
+  Int_t     fCurrentSector;          //!< current sector processed
+  Int_t     fLastSector;             //!< current sector processed
+  Int_t     fCurrentRow;             //!< current row processed
+  Int_t     fCurrentPad;             //!< current pad processed
+  Int_t     fLastTimeBinProc;        //!< last time bin processed
+  Int_t     fPeakTimeBin;            //!< time bin with local maximum
+  Int_t     fLastSignal;             //!< last signal processed
+  Int_t     fNOkPlus;                //!< number of processed time bins fullfilling peak criteria
+  Int_t     fNOkMinus;               //!< number of processed time bins fullfilling peak criteria
+  Int_t     fNanoSec;                //!< current nano seconds stamp
 //
   //L1 phase stuff
-  TVectorF fArrCurrentPhaseDist;       //!Phase distribution of the current event
-  TVectorF fArrCurrentPhase;           //!Current phase of all RCUs
-  TVectorF fArrFailEventNumber;        //event numbers of failed events;
-  TVectorF fArrALTROL1Phase;           //Array of L1 phases on an event bases;
-  TObjArray fArrALTROL1PhaseEvent;     //L1 phase for each RCU and event
-  TObjArray fArrALTROL1PhaseFailEvent; //L1 failure for each RCU and event
+  TVectorF fArrCurrentPhaseDist;       //!< Phase distribution of the current event
+  TVectorF fArrCurrentPhase;           //!< Current phase of all RCUs
+  TVectorF fArrFailEventNumber;        ///< event numbers of failed events;
+  TVectorF fArrALTROL1Phase;           ///< Array of L1 phases on an event bases;
+  TObjArray fArrALTROL1PhaseEvent;     ///< L1 phase for each RCU and event
+  TObjArray fArrALTROL1PhaseFailEvent; ///< L1 failure for each RCU and event
   //drift velocity stuff
   enum {kHnBinsDV=3};
-  THnSparseI *fHnDrift;                //Histogram last time bin vs. ROC, Time
+  THnSparseI *fHnDrift;                ///< Histogram last time bin vs. ROC, Time
   //occupancy
-  TVectorF fVOccupancyEvent;           //occupancy per event (number of samples above threshold)
-  TVectorF fVSignalSumEvent;           //occupancy per event (sum of all adc values)
-  TVectorF fVOccupancySenEvent;        //occupancy per event (number of samples abouve threshold) in sensitive regions
-  TVectorF fVSignalSumSenEvent;        //occupancy per event (sum of all adc values) in sensitive regions
-  TVectorF fVNfiredPadsSenEvent;       //number of pads with a signal above threshold in sensitive regions
-  TVectorF fVTimeStampEvent;           //timestamp for all events
+  TVectorF fVOccupancyEvent;           ///< occupancy per event (number of samples above threshold)
+  TVectorF fVSignalSumEvent;           ///< occupancy per event (sum of all adc values)
+  TVectorF fVOccupancySenEvent;        ///< occupancy per event (number of samples abouve threshold) in sensitive regions
+  TVectorF fVSignalSumSenEvent;        ///< occupancy per event (sum of all adc values) in sensitive regions
+  TVectorF fVNfiredPadsSenEvent;       ///< number of pads with a signal above threshold in sensitive regions
+  TVectorF fVTimeStampEvent;           ///< timestamp for all events
   
   TVectorF *MakeArrL1PhaseRCU(Int_t rcu, Bool_t force=kFALSE);
   TVectorF *MakeArrL1PhaseFailRCU(Int_t rcu, Bool_t force=kFALSE);
@@ -125,7 +122,9 @@ private:
   AliTPCCalibRaw(const AliTPCCalibRaw &calib);
   AliTPCCalibRaw& operator = (const  AliTPCCalibRaw &source);
 
+  /// \cond CLASSIMP
   ClassDef(AliTPCCalibRaw,4) //  Analysis of the Altro header information
+  /// \endcond
 };
 
 //----------------------
@@ -153,9 +152,8 @@ inline TVectorF *AliTPCCalibRaw::MakeArrL1PhaseFailRCU(Int_t rcu, Bool_t force)
 //_____________________________________________________________________
 inline Bool_t AliTPCCalibRaw::IsEdgePad(Int_t sector, Int_t row, Int_t pad) const
 {
-  //
-  // return true if pad is on the edge of a row
-  //
+  /// return true if pad is on the edge of a row
+
   Int_t edge1   = 0;
   if ( pad == edge1 ) return kTRUE;
   Int_t edge2   = fROC->GetNPads(sector,row)-1;
diff --git a/TPC/TPCbase/AliTPCCalibRawBase.cxx b/TPC/TPCbase/AliTPCCalibRawBase.cxx
index fe15cb81289..cb5395df479 100644
--- a/TPC/TPCbase/AliTPCCalibRawBase.cxx
+++ b/TPC/TPCbase/AliTPCCalibRawBase.cxx
@@ -13,15 +13,10 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/* $Id: AliTPCCalibRawBase.cxx */
-
-/////////////////////////////////////////////////////////////////////////////////////////
-//                                                                                     //
-//          Base class for the calibration algorithms using raw data as input          //
-//                                                                                     //
-//   Origin: Jens Wiechula   J.Wiechula@gsi.de                                         //
-//                                                                                     //
-/////////////////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCCalibRawBase
+/// \brief Base class for the calibration algorithms using raw data as input
+///
+/// \author Jens Wiechula   J.Wiechula@gsi.de
 
 //Root includes
 #include <TDirectory.h>
@@ -41,7 +36,9 @@
 
 #include "AliTPCCalibRawBase.h"
 
+/// \cond CLASSIMP
 ClassImp(AliTPCCalibRawBase)
+/// \endcond
 
 AliTPCCalibRawBase::AliTPCCalibRawBase() :
   TNamed(),
@@ -97,25 +94,21 @@ AliTPCCalibRawBase::AliTPCCalibRawBase(const AliTPCCalibRawBase &calib) :
   fMapping(0x0),
   fROC(AliTPCROC::Instance())
 {
-    //
-    // copy ctor
-    //
-  
+    /// copy ctor
+
 }
 //_____________________________________________________________________
 AliTPCCalibRawBase::~AliTPCCalibRawBase()
 {
-  //
-  // dtor
-  //
+  /// dtor
+
   if (fDebugStreamer) delete fDebugStreamer;
 }
 //_____________________________________________________________________
   AliTPCCalibRawBase& AliTPCCalibRawBase::operator = (const  AliTPCCalibRawBase &source)
   {
-    //
-    // assignment operator
-    //
+    /// assignment operator
+
     if (&source == this) return *this;
     new (this) AliTPCCalibRawBase(source);
     
@@ -124,9 +117,8 @@ AliTPCCalibRawBase::~AliTPCCalibRawBase()
 //_____________________________________________________________________
 Bool_t AliTPCCalibRawBase::ProcessEvent(AliTPCRawStreamV3 * const rawStreamV3)
 {
-  //
-  // Event Processing loop - AliTPCRawStreamV3
-  //
+  /// Event Processing loop - AliTPCRawStreamV3
+
   ResetEvent();
   Bool_t withInput = kFALSE;
   fAltroL1Phase=0;
@@ -173,9 +165,8 @@ Bool_t AliTPCCalibRawBase::ProcessEvent(AliTPCRawStreamV3 * const rawStreamV3)
 //_____________________________________________________________________
 Bool_t AliTPCCalibRawBase::ProcessEvent(AliRawReader * const rawReader)
 {
-  //
-  //  Event processing loop - AliRawReader
-  //
+  ///  Event processing loop - AliRawReader
+
   AliRawEventHeaderBase* eventHeader = (AliRawEventHeaderBase*)rawReader->GetEventHeader();
   if (eventHeader){
     fTimeStamp   = eventHeader->Get("Timestamp");
@@ -195,9 +186,7 @@ Bool_t AliTPCCalibRawBase::ProcessEvent(AliRawReader * const rawReader)
 //_____________________________________________________________________
 Bool_t AliTPCCalibRawBase::ProcessEvent(eventHeaderStruct * const event)
 {
-  //
-  //  Event processing loop - date event
-  //
+  ///  Event processing loop - date event
 
   fRunNumber=event->eventRunNb;
   fTimeStamp=event->eventTimestamp;
@@ -215,10 +204,8 @@ Bool_t AliTPCCalibRawBase::ProcessEvent(eventHeaderStruct * const event)
 //_____________________________________________________________________
 void AliTPCCalibRawBase::DumpToFile(const Char_t *filename, const Char_t *dir, Bool_t append)
 {
-    //
-    //  Write class to file
-    //
-  
+    ///  Write class to file
+
   TString sDir(dir);
   TString option;
   
@@ -241,10 +228,9 @@ void AliTPCCalibRawBase::DumpToFile(const Char_t *filename, const Char_t *dir, B
 }
 //_____________________________________________________________________
 TTreeSRedirector *AliTPCCalibRawBase::GetDebugStreamer(){
-  //
-  // Get Debug streamer
-  // In case debug streamer not yet initialized and StreamLevel>0 create new one
-  //
+  /// Get Debug streamer
+  /// In case debug streamer not yet initialized and StreamLevel>0 create new one
+
   if (fStreamLevel==0) return 0;
   if (fDebugStreamer) return fDebugStreamer;
   TString dsName;
@@ -257,9 +243,8 @@ TTreeSRedirector *AliTPCCalibRawBase::GetDebugStreamer(){
 //_____________________________________________________________________
 void AliTPCCalibRawBase::MergeBase(const AliTPCCalibRawBase *calib)
 {
-  //
-  // merge this with base
-  //
+  /// merge this with base
+
   if (calib->fFirstTimeStamp<fFirstTimeStamp) fFirstTimeStamp=calib->fFirstTimeStamp;
   if (calib->fLastTimeStamp>fLastTimeStamp)   fLastTimeStamp =calib->fLastTimeStamp;
 }
diff --git a/TPC/TPCbase/AliTPCCalibRawBase.h b/TPC/TPCbase/AliTPCCalibRawBase.h
index 0fec89ba929..0370143197d 100644
--- a/TPC/TPCbase/AliTPCCalibRawBase.h
+++ b/TPC/TPCbase/AliTPCCalibRawBase.h
@@ -3,11 +3,8 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-/////////////////////////////////////////////////////////////////////////////////////////
-//                                                                                     //
-//                  Raw data processing base class                                     //
-//                                                                                     //
-/////////////////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCCalibRawBase
+/// \brief Raw data processing base class
 
 #include <TNamed.h>
 
@@ -31,7 +28,7 @@ public:
   AliTPCCalibRawBase& operator = (const  AliTPCCalibRawBase &source);
 
   virtual ~AliTPCCalibRawBase();
-  
+
   //uses the new decoder which is compatible with the new altro format
   Bool_t ProcessEvent(AliTPCRawStreamV3   * const rawStreamV3);
   Bool_t ProcessEvent(AliRawReader        * const rawReader);
@@ -43,10 +40,10 @@ public:
   virtual void ProcessBunch(const Int_t /*sector*/, const Int_t /*row*/, const Int_t /*pad*/,
                             const Int_t /*length*/, const UInt_t /*startTimeBin*/, const UShort_t* /*signal*/) {return; }
   virtual void Analyse(){ return; }
-  
+
   virtual Long64_t Merge(TCollection * /*list*/) {return 0;}
   void MergeBase(const AliTPCCalibRawBase *calib);
-  
+
   //Setters
   void  SetRangeTime (Int_t firstTimeBin, Int_t lastTimeBin) { fFirstTimeBin=firstTimeBin;   fLastTimeBin=lastTimeBin;  } //Set range in which the signal is expected
   void  SetAltroMapping(AliTPCAltroMapping **mapp) { fMapping = mapp; }
@@ -86,41 +83,41 @@ public:
   Int_t      GetDebugLevel() const {return fDebugLevel;}
 
 protected:
-  Int_t fFirstTimeBin;                //  First Time bin used for analysis
-  Int_t fLastTimeBin;                 //  Last Time bin used for analysis
-  
-  Int_t fNevents;                     //  Number of processed events 
-  
-  Int_t fDebugLevel;                  //! debug level
-  Int_t fStreamLevel;                 //! level of streamer output
+  Int_t fFirstTimeBin;                ///< First Time bin used for analysis
+  Int_t fLastTimeBin;                 ///< Last Time bin used for analysis
+
+  Int_t fNevents;                     ///< Number of processed events
+
+  Int_t fDebugLevel;                  //!< debug level
+  Int_t fStreamLevel;                 //!< level of streamer output
   //
-  UInt_t fRunNumber;                  // current run number from event header
-  UInt_t fFirstTimeStamp;             // First event time stamp
-  UInt_t fLastTimeStamp;              // Last event time stamp
-  UInt_t fTimeStamp;                  //! time stamp from event header
-  UInt_t fEventType;                  //! current event Type from event header
+  UInt_t fRunNumber;                  ///< current run number from event header
+  UInt_t fFirstTimeStamp;             ///< First event time stamp
+  UInt_t fLastTimeStamp;              ///< Last event time stamp
+  UInt_t fTimeStamp;                  //!< time stamp from event header
+  UInt_t fEventType;                  //!< current event Type from event header
   //
-  Double_t fAltroL1Phase;             //! L1 Phase
-  Float_t  fAltroL1PhaseTB;           //! L1 Phase in time bins
-  Int_t    fCurrRCUId;                //! Current RCU Id
-  Int_t    fPrevRCUId;                //! Previous RCU Id
-  Int_t    fCurrDDLNum;               //! Current DDL number
-  Int_t    fPrevDDLNum;               //! Current DDL number
-  Bool_t   fUseL1Phase;               //  use L1 Phase information?
+  Double_t fAltroL1Phase;             //!< L1 Phase
+  Float_t  fAltroL1PhaseTB;           //!< L1 Phase in time bins
+  Int_t    fCurrRCUId;                //!< Current RCU Id
+  Int_t    fPrevRCUId;                //!< Previous RCU Id
+  Int_t    fCurrDDLNum;               //!< Current DDL number
+  Int_t    fPrevDDLNum;               //!< Current DDL number
+  Bool_t   fUseL1Phase;               ///< use L1 Phase information?
   //
-  TTreeSRedirector *fDebugStreamer;   //! debug streamer
+  TTreeSRedirector *fDebugStreamer;   //!< debug streamer
   //
-  AliAltroRawStream *fAltroRawStream; //! pointer to the altro object
-  AliTPCAltroMapping **fMapping;      //! Altro Mapping object
+  AliAltroRawStream *fAltroRawStream; //!< pointer to the altro object
+  AliTPCAltroMapping **fMapping;      //!< Altro Mapping object
+
+  AliTPCROC *fROC;                    //!< ROC information
 
-  AliTPCROC *fROC;                    //! ROC information
-    
   virtual void EndEvent() {++fNevents; return; } //fNevents should be updated in the derived classes in a proper place
   virtual void ResetEvent(){ return; }           //Reset Event counters
-  
-  
+
+  /// \cond CLASSIMP
   ClassDef(AliTPCCalibRawBase,3)      //  Calibration base class for raw data processing
-    
+  /// \endcond
 };
 
 
diff --git a/TPC/TPCbase/AliTPCCalibVdrift.cxx b/TPC/TPCbase/AliTPCCalibVdrift.cxx
index 1ec91b0fe0b..564cb9d1f00 100644
--- a/TPC/TPCbase/AliTPCCalibVdrift.cxx
+++ b/TPC/TPCbase/AliTPCCalibVdrift.cxx
@@ -14,12 +14,11 @@
  **************************************************************************/
 
 
-///////////////////////////////////////////////////////////////////////////////
-//                                                                           //
-// Class describing the Vdrift dependencies on E,T,P and GasComposition      //
-// Authors: Stefan Rossegger, Haavard Helstrup                               //
-//                                                                           //
-///////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCCalibVdrift
+///
+/// Class describing the Vdrift dependencies on E,T,P and GasComposition
+///
+/// \author Stefan Rossegger, Haavard Helstrup
 
 #include "TSystem.h"
 #include "TObject.h"
@@ -29,7 +28,9 @@
 
 #include "AliTPCCalibVdrift.h"
 
+/// \cond CLASSIMP
 ClassImp(AliTPCCalibVdrift)
+/// \endcond
 
 namespace paramDefinitions {
     
@@ -83,9 +84,8 @@ AliTPCCalibVdrift::AliTPCCalibVdrift():
   fNominalTemp(0),    // nominal temperature in Kelvin
   fNominalPress(0)    // nominal pressure    in mbar 
 {
-  //
-  //  default constructor
-  //
+  ///  default constructor
+
 }
 
 AliTPCCalibVdrift::AliTPCCalibVdrift(AliTPCSensorTempArray *SensTemp, AliDCSSensor *SensPres, TObject *SensGasComp):
@@ -97,9 +97,7 @@ AliTPCCalibVdrift::AliTPCCalibVdrift(AliTPCSensorTempArray *SensTemp, AliDCSSens
   fNominalTemp(0),    // nominal temperature in Kelvin
   fNominalPress(0)    // nominal pressure    in mbar 
 {
-  //
-  //  Standard constructor
-  //
+  ///  Standard constructor
 
   fSensTemp = SensTemp;
   fSensPres = SensPres;
@@ -124,16 +122,14 @@ AliTPCCalibVdrift::AliTPCCalibVdrift(const AliTPCCalibVdrift& source) :
   fNominalPress(source.fNominalPress)    // nominal pressure    in mbar 
 
 {
-  //
-  //  Copy constructor
-  //
+  ///  Copy constructor
+
 }
 
 //_____________________________________________________________________________
 AliTPCCalibVdrift& AliTPCCalibVdrift::operator=(const AliTPCCalibVdrift& source){
-  //
-  // assignment operator
-  //
+  /// assignment operator
+
   if (&source == this) return *this;
   new (this) AliTPCCalibVdrift(source);
   
@@ -143,19 +139,15 @@ AliTPCCalibVdrift& AliTPCCalibVdrift::operator=(const AliTPCCalibVdrift& source)
 //_____________________________________________________________________________
 AliTPCCalibVdrift::~AliTPCCalibVdrift()
 {
-  //
-  // AliTPCCalibVdrift destructor
-  // 
+  /// AliTPCCalibVdrift destructor
 
 }
 
 //_____________________________________________________________________________
 Double_t AliTPCCalibVdrift::GetPTRelative(UInt_t absTimeSec, Int_t side){
-  //
-  // Get Relative difference of p/T for given time stamp
-  // absTimeSec - absolute time in secounds
-  // side: 0 - A side |  1 - C side
-  //
+  /// Get Relative difference of p/T for given time stamp
+  /// absTimeSec - absolute time in secounds
+  /// side: 0 - A side |  1 - C side
 
   TTimeStamp tstamp(absTimeSec);
 
@@ -183,10 +175,8 @@ Double_t AliTPCCalibVdrift::GetPTRelative(UInt_t absTimeSec, Int_t side){
 //_____________________________________________________________________________
 Double_t AliTPCCalibVdrift::VdriftLinearHyperplaneApprox(Double_t dE, Double_t dT, Double_t dP, Double_t dCco2, Double_t dCn2) 
 {
-  //
-  // Returns approximated value for the driftvelocity change (in percent)
-  // based on a Hyperplane approximation (~ Taylorapproximation of 2nd order)
-  //
+  /// Returns approximated value for the driftvelocity change (in percent)
+  /// based on a Hyperplane approximation (~ Taylorapproximation of 2nd order)
 
   Double_t termE   = dE*kdvdE + TMath::Power(dE,2)*kdvdE2nd;
   Double_t termT   = dT*kdvdT + TMath::Power(dT,2)*kdvdT2nd;
@@ -204,7 +194,8 @@ Double_t AliTPCCalibVdrift::VdriftLinearHyperplaneApprox(Double_t dE, Double_t d
 
 Double_t AliTPCCalibVdrift::GetVdriftNominal() 
 {
-  // returns nominal Driftvelocity at StandardConditions
+  /// returns nominal Driftvelocity at StandardConditions
+
   return kstdVdrift;
 }
 
@@ -212,10 +203,8 @@ Double_t AliTPCCalibVdrift::GetVdriftNominal()
 
 Double_t AliTPCCalibVdrift::GetVdriftChange(Double_t x, Double_t y, Double_t z, UInt_t absTimeSec)
 {
-  // 
-  // Calculates Vdrift change in percent of Vdrift_nominal 
-  // (under nominal conditions) at x,y,z at absolute time (in sec)
-  //
+  /// Calculates Vdrift change in percent of Vdrift_nominal
+  /// (under nominal conditions) at x,y,z at absolute time (in sec)
 
   TTimeStamp tstamp(absTimeSec);
 
@@ -260,12 +249,10 @@ Double_t AliTPCCalibVdrift::GetVdriftChange(Double_t x, Double_t y, Double_t z,
 
 Double_t AliTPCCalibVdrift::GetMeanZVdriftChange(Double_t x, Double_t y, UInt_t absTimeSec)
 {
-  // 
-  // Calculates Meanvalue in z direction of Vdrift change in percent 
-  // of Vdrift_nominal (under standard conditions) at position x,y,absTimeSec
-  // with help of 'nPopints' base points
-  //
-  
+  /// Calculates Meanvalue in z direction of Vdrift change in percent
+  /// of Vdrift_nominal (under standard conditions) at position x,y,absTimeSec
+  /// with help of 'nPopints' base points
+
   Int_t nPoints = 5;
  
   Double_t vdriftSum = 0;
@@ -285,10 +272,8 @@ Double_t AliTPCCalibVdrift::GetMeanZVdriftChange(Double_t x, Double_t y, UInt_t
 
 TGraph *AliTPCCalibVdrift::MakeGraphMeanZVdriftChange(Double_t x, Double_t y, Int_t nPoints)
 {
-  //
-  // Make graph from start time to end time of Mean Drift Velocity in 
-  // Z direction at given x and y position
-  //
+  /// Make graph from start time to end time of Mean Drift Velocity in
+  /// Z direction at given x and y position
 
   UInt_t startTime = fSensTemp->GetStartTime();
   UInt_t endTime = fSensTemp->GetEndTime();
diff --git a/TPC/TPCbase/AliTPCCalibVdrift.h b/TPC/TPCbase/AliTPCCalibVdrift.h
index 243523fb34e..8080b043560 100644
--- a/TPC/TPCbase/AliTPCCalibVdrift.h
+++ b/TPC/TPCbase/AliTPCCalibVdrift.h
@@ -3,9 +3,7 @@
 /* Copyright(c) 2006-07, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-////////////////////////////////////////////////////////////////////////
-//              Class AliTPCCalibVdrift
-////////////////////////////////////////////////////////////////////////
+/// \class AliTPCCalibVdrift
 
 
 class TObject;
@@ -41,16 +39,18 @@ public:
 
 protected:
   //
-  AliTPCSensorTempArray *fSensTemp;   // Temperature sensors 
-  AliDCSSensor          *fSensPres;   // pressure sensor (cavernpress in GRP)
-  AliTPCTempMap         *fTempMap;    // Temperature Map
-  TObject *fSensGasComp;      // placeholder for GasConzentration infos  
+  AliTPCSensorTempArray *fSensTemp;   ///< Temperature sensors
+  AliDCSSensor          *fSensPres;   ///< pressure sensor (cavernpress in GRP)
+  AliTPCTempMap         *fTempMap;    ///< Temperature Map
+  TObject *fSensGasComp;      ///< placeholder for GasConzentration infos
   //
   // Nominal values
   //
-  Float_t               fNominalTemp;    // nominal temperature in Kelvin
-  Float_t               fNominalPress;    // nominal pressure    in mbar 
+  Float_t               fNominalTemp;    ///< nominal temperature in Kelvin
+  Float_t               fNominalPress;    ///< nominal pressure    in mbar
+  /// \cond CLASSIMP
   ClassDef(AliTPCCalibVdrift,1);
+  /// \endcond
 
 };
 #endif
diff --git a/TPC/TPCbase/AliTPCCalibViewer.cxx b/TPC/TPCbase/AliTPCCalibViewer.cxx
index 7e2b57ed2ab..279f122b536 100644
--- a/TPC/TPCbase/AliTPCCalibViewer.cxx
+++ b/TPC/TPCbase/AliTPCCalibViewer.cxx
@@ -14,28 +14,24 @@
  **************************************************************************/
 
 
-///////////////////////////////////////////////////////////////////////////////
-//                                                                           //
-//  Class for viewing/visualizing TPC calibration data                       //
-//  base on  TTree functionality for visualization                           //
-//                                                                           //
-//  Create a list of AliTPCCalPads, arrange them in an TObjArray.            //
-//  Pass this TObjArray to MakeTree and create the calibration Tree          //
-//  While craating this tree some statistical information are calculated     //
-//  Open the viewer with this Tree: AliTPCCalibViewer v("CalibTree.root")    //
-//  Have fun!                                                                //
-//  EasyDraw("CETmean~-CETmean_mean", "A", "(CETmean~-CETmean_mean)>0")      //
-//                                                                           //
-//  If you like to click, we recommand you the                               //
-//    AliTPCCalibViewerGUI                                                   //
-//                                                                           //
-//    THE DOCUMENTATION IS STILL NOT COMPLETED !!!!                          //
-//                                                                           //
-///////////////////////////////////////////////////////////////////////////////
-
-//
-// ROOT includes 
-//
+/// \class AliTPCCalibViewer
+///
+///  Class for viewing/visualizing TPC calibration data
+///  base on  TTree functionality for visualization
+///
+///  Create a list of AliTPCCalPads, arrange them in an TObjArray.
+///  Pass this TObjArray to MakeTree and create the calibration Tree
+///  While craating this tree some statistical information are calculated
+///  Open the viewer with this Tree: AliTPCCalibViewer v("CalibTree.root")
+///  Have fun!
+///  EasyDraw("CETmean~-CETmean_mean", "A", "(CETmean~-CETmean_mean)>0")
+///
+///  If you like to click, we recommand you the
+///    AliTPCCalibViewerGUI
+///
+///    THE DOCUMENTATION IS STILL NOT COMPLETED !!!!
+///
+/// ROOT includes
 
 #include <fstream>
 #include <iostream>
@@ -46,7 +42,7 @@
 #include <TKey.h>
 #include <TPad.h>
 //#include <TCanvas.h>
-#include <TH1.h> 
+#include <TH1.h>
 #include <TH1F.h>
 #include <TLegend.h>
 #include <TLine.h>
@@ -71,7 +67,9 @@
 #include "AliTPCCalibViewer.h"
 
 using std::ifstream;
+/// \cond CLASSIMP
 ClassImp(AliTPCCalibViewer)
+/// \endcond
 
 
 AliTPCCalibViewer::AliTPCCalibViewer()
@@ -79,8 +77,8 @@ AliTPCCalibViewer::AliTPCCalibViewer()
                    fTree(0),
                    fFile(0),
                    fListOfObjectsToBeDeleted(0),
-                   fTreeMustBeDeleted(0), 
-                   fAbbreviation(0), 
+                   fTreeMustBeDeleted(0),
+                   fAbbreviation(0),
                    fAppendString(0)
 {
   //
@@ -96,13 +94,12 @@ AliTPCCalibViewer::AliTPCCalibViewer(const AliTPCCalibViewer &c)
                    fFile(0),
                    fListOfObjectsToBeDeleted(0),
                    fTreeMustBeDeleted(0),
-                   fAbbreviation(0), 
+                   fAbbreviation(0),
                    fAppendString(0)
 {
-  //
-  // dummy AliTPCCalibViewer copy constructor
-  // not yet working!!!
-  //
+  /// dummy AliTPCCalibViewer copy constructor
+  /// not yet working!!!
+
   fTree = c.fTree;
   fTreeMustBeDeleted = c.fTreeMustBeDeleted;
   //fFile = new TFile(*(c.fFile));
@@ -118,12 +115,11 @@ AliTPCCalibViewer::AliTPCCalibViewer(TTree *const tree)
                    fFile(0),
                    fListOfObjectsToBeDeleted(0),
                    fTreeMustBeDeleted(0),
-                   fAbbreviation(0), 
+                   fAbbreviation(0),
                    fAppendString(0)
 {
-  //
-  // Constructor that initializes the calibration viewer
-  //
+  /// Constructor that initializes the calibration viewer
+
   fTree = tree;
   fTreeMustBeDeleted = kFALSE;
   fListOfObjectsToBeDeleted = new TObjArray();
@@ -138,14 +134,13 @@ AliTPCCalibViewer::AliTPCCalibViewer(const char* fileName, const char* treeName)
                    fFile(0),
                    fListOfObjectsToBeDeleted(0),
                    fTreeMustBeDeleted(0),
-                   fAbbreviation(0), 
+                   fAbbreviation(0),
                    fAppendString(0)
-                   
+
 {
-   //
-   // Constructor to initialize the calibration viewer
-   // the file 'fileName' contains the tree 'treeName'
-   //
+   /// Constructor to initialize the calibration viewer
+   /// the file 'fileName' contains the tree 'treeName'
+
    fFile = new TFile(fileName, "read");
    fTree = (TTree*) fFile->Get(treeName);
    fTreeMustBeDeleted = kTRUE;
@@ -153,14 +148,13 @@ AliTPCCalibViewer::AliTPCCalibViewer(const char* fileName, const char* treeName)
    fAbbreviation = "~";
    fAppendString = ".fElements";
 }
-                   
+
 //____________________________________________________________________________
 AliTPCCalibViewer & AliTPCCalibViewer::operator =(const AliTPCCalibViewer & param)
 {
-   //
-   // assignment operator - dummy
-   // not yet working!!!
-   //
+   /// assignment operator - dummy
+   /// not yet working!!!
+
   if (this == &param) return (*this);
 
    fTree = param.fTree;
@@ -175,10 +169,9 @@ AliTPCCalibViewer & AliTPCCalibViewer::operator =(const AliTPCCalibViewer & para
 //_____________________________________________________________________________
 AliTPCCalibViewer::~AliTPCCalibViewer()
 {
-   //
-   // AliTPCCalibViewer destructor
-   // all objects will be deleted, the file will be closed, the pictures will disappear
-   //
+   /// AliTPCCalibViewer destructor
+   /// all objects will be deleted, the file will be closed, the pictures will disappear
+
    if (fTree && fTreeMustBeDeleted) {
       fTree->SetCacheSize(0);
       fTree->Delete();
@@ -198,12 +191,10 @@ AliTPCCalibViewer::~AliTPCCalibViewer()
 
 //_____________________________________________________________________________
 void AliTPCCalibViewer::Delete(Option_t* /*option*/) {
-   //
-   // Should be called from AliTPCCalibViewerGUI class only.
-   // If you use Delete() do not call the destructor.
-   // All objects (except those contained in fListOfObjectsToBeDeleted) will be deleted, the file will be closed.
-   //
-   
+   /// Should be called from AliTPCCalibViewerGUI class only.
+   /// If you use Delete() do not call the destructor.
+   /// All objects (except those contained in fListOfObjectsToBeDeleted) will be deleted, the file will be closed.
+
    if (fTree && fTreeMustBeDeleted) {
       fTree->SetCacheSize(0);
       fTree->Delete();
@@ -213,30 +204,30 @@ void AliTPCCalibViewer::Delete(Option_t* /*option*/) {
 }
 
 
-const char* AliTPCCalibViewer::AddAbbreviations(const Char_t *c, Bool_t printDrawCommand){ 
-   // Replace all "<variable>" with "<variable><fAbbreviation>" (Adds forgotten "~")
-   // but take care on the statistical information, like "CEQmean_Mean"
-   // and also take care on correct given variables, like "CEQmean~"
-   // 
-   // For each variable out of "listOfVariables":
-   // - 'Save' correct items:
-   //   - form <replaceString>, take <variable>'s first char, add <removeString>, add rest of <variable>, e.g. "C!#EQmean" (<removeString> = "!#")
-   //   - For each statistical information in "listOfNormalizationVariables":
-   //     - ReplaceAll <variable><statistical_Information> with <replaceString><statistical_Information>
-   //   - ReplaceAll <variable><abbreviation> with <replaceString><abbreviation>, e.g. "CEQmean~" -> "C!#EQmean~"
-   //   - ReplaceAll <variable><appendStr> with <replaceString><appendStr>, e.g. "CEQmean.fElements" -> "C!#EQmean.fElements"
-   //
-   // - Do actual replacing:
-   //   - ReplaceAll <variable> with <variable><fAbbreviation>, e.g. "CEQmean" -> "CEQmean~"
-   //
-   // - Undo saving:
-   //   - For each statistical information in "listOfNormalizationVariables":
-   //     - ReplaceAll <replaceString><statistical_Information> with <variable><statistical_Information> 
-   //   - ReplaceAll <replaceString><abbreviation> with <variable><abbreviation>, e.g. "C!#EQmean~" -> "CEQmean~"
-   //   - ReplaceAll <replaceString><appendStr> with <variable><appendStr>, e.g. "C!#EQmean.fElements" -> "CEQmean.fElements"
-   // 
-   // Now all the missing "~" should be added.
-   
+const char* AliTPCCalibViewer::AddAbbreviations(const Char_t *c, Bool_t printDrawCommand){
+   /// Replace all "<variable>" with "<variable><fAbbreviation>" (Adds forgotten "~")
+   /// but take care on the statistical information, like "CEQmean_Mean"
+   /// and also take care on correct given variables, like "CEQmean~"
+   ///
+   /// For each variable out of "listOfVariables":
+   /// - 'Save' correct items:
+   ///   - form <replaceString>, take <variable>'s first char, add <removeString>, add rest of <variable>, e.g. "C!#EQmean" (<removeString> = "!#")
+   ///   - For each statistical information in "listOfNormalizationVariables":
+   ///     - ReplaceAll <variable><statistical_Information> with <replaceString><statistical_Information>
+   ///   - ReplaceAll <variable><abbreviation> with <replaceString><abbreviation>, e.g. "CEQmean~" -> "C!#EQmean~"
+   ///   - ReplaceAll <variable><appendStr> with <replaceString><appendStr>, e.g. "CEQmean.fElements" -> "C!#EQmean.fElements"
+   ///
+   /// - Do actual replacing:
+   ///   - ReplaceAll <variable> with <variable><fAbbreviation>, e.g. "CEQmean" -> "CEQmean~"
+   ///
+   /// - Undo saving:
+   ///   - For each statistical information in "listOfNormalizationVariables":
+   ///     - ReplaceAll <replaceString><statistical_Information> with <variable><statistical_Information>
+   ///   - ReplaceAll <replaceString><abbreviation> with <variable><abbreviation>, e.g. "C!#EQmean~" -> "CEQmean~"
+   ///   - ReplaceAll <replaceString><appendStr> with <variable><appendStr>, e.g. "C!#EQmean.fElements" -> "CEQmean.fElements"
+   ///
+   /// Now all the missing "~" should be added.
+
    TString str(c);
    TString removeString = "!#";  // very unpropable combination of chars
    TString replaceString = "";
@@ -255,7 +246,7 @@ const char* AliTPCCalibViewer::AddAbbreviations(const Char_t *c, Bool_t printDra
    TObjArray *listOfNormalizationVariables = GetListOfNormalizationVariables();
    Int_t nVariables = listOfVariables->GetEntriesFast();
    Int_t nNorm = listOfNormalizationVariables->GetEntriesFast();
-   
+
    Int_t *varLengths = new Int_t[nVariables];
    for (Int_t i = 0; i < nVariables; i++) {
       varLengths[i] = ((TObjString*)listOfVariables->At(i))->String().Length();
@@ -271,7 +262,7 @@ const char* AliTPCCalibViewer::AddAbbreviations(const Char_t *c, Bool_t printDra
    TMath::Sort(nNorm, normLengths, normSort, kTRUE);
    // for (Int_t i = 0; i<nNorm; i++)  printf("normLengths: %i\n", normLengths[normSort[i]]);
    // for (Int_t i = 0; i<nVariables; i++) printf("varLengths: %i\n", varLengths[varSort[i]]);
-   
+
    for (Int_t ivar = 0; ivar < nVariables; ivar++) {
       // ***** save correct tokens *****
       // first get the next variable:
@@ -296,15 +287,15 @@ const char* AliTPCCalibViewer::AddAbbreviations(const Char_t *c, Bool_t printDra
       // like: str.ReplaceAll("CEQmean~", "C!EQmean~");
       str.ReplaceAll(searchString + fAppendString,    replaceString + fAppendString);
       // like: str.ReplaceAll("CEQmean.fElements", "C!EQmean.fElements");
-      
+
       // ***** add missing extensions *****
       str.ReplaceAll(searchString, replaceString + fAbbreviation);
       // like: str.ReplaceAll("CEQmean", "C!EQmean~");
    }
-   
+
    // ***** undo saving *****
    str.ReplaceAll(removeString, "");
-  
+
    if (printDrawCommand) std::cout << "The string looks now like: " << str.Data() << std::endl;
    delete [] varLengths;
    delete [] normLengths;
@@ -318,16 +309,14 @@ const char* AliTPCCalibViewer::AddAbbreviations(const Char_t *c, Bool_t printDra
 
 //_____________________________________________________________________________
 Int_t AliTPCCalibViewer::EasyDraw(const char* drawCommand, const char* sector, const char* cuts, const char* drawOptions, Bool_t writeDrawCommand) const {
-  //
-  // easy drawing of data, use '~' for abbreviation of '.fElements'
-  // example: EasyDraw("CETmean~-CETmean_mean", "A", "(CETmean~-CETmean_mean)>0")
- // sector: sector-number - only the specified sector will be drwawn
-  //         'A'/'C' or 'a'/'c' - side A/C will be drawn
-  //         'ALL' - whole TPC will be drawn, projected on one side
-  // cuts: specifies cuts
-  // drawOptions: draw options like 'same'
-  // writeDrawCommand: write the command, that is passed to TTree::Draw
-  //
+ /// easy drawing of data, use '~' for abbreviation of '.fElements'
+ /// example: EasyDraw("CETmean~-CETmean_mean", "A", "(CETmean~-CETmean_mean)>0")
+ /// sector: sector-number - only the specified sector will be drwawn
+ ///         'A'/'C' or 'a'/'c' - side A/C will be drawn
+ ///         'ALL' - whole TPC will be drawn, projected on one side
+ /// cuts: specifies cuts
+ /// drawOptions: draw options like 'same'
+ /// writeDrawCommand: write the command, that is passed to TTree::Draw
 
    TString drawStr(drawCommand);
    TString sectorStr(sector);
@@ -412,14 +401,13 @@ Int_t AliTPCCalibViewer::EasyDraw(const char* drawCommand, const char* sector, c
 
 
 Int_t AliTPCCalibViewer::EasyDraw(const char* drawCommand, Int_t sector, const char* cuts, const char* drawOptions, Bool_t writeDrawCommand) const {
-  //
-  // easy drawing of data, use '~' for abbreviation of '.fElements'
-  // example: EasyDraw("CETmean~-CETmean_mean", 34, "(CETmean~-CETmean_mean)>0")
-  // sector: sector-number - only the specified sector will be drwawn
-  // cuts: specifies cuts
-  // drawOptions: draw options like 'same'
-  // writeDrawCommand: write the command, that is passed to TTree::Draw
-  //
+  /// easy drawing of data, use '~' for abbreviation of '.fElements'
+  /// example: EasyDraw("CETmean~-CETmean_mean", 34, "(CETmean~-CETmean_mean)>0")
+  /// sector: sector-number - only the specified sector will be drwawn
+  /// cuts: specifies cuts
+  /// drawOptions: draw options like 'same'
+  /// writeDrawCommand: write the command, that is passed to TTree::Draw
+
    if (sector >= 0 && sector < 72) {
       return EasyDraw(drawCommand, Form("%i", sector), cuts, drawOptions, writeDrawCommand);
    }
@@ -430,16 +418,14 @@ Int_t AliTPCCalibViewer::EasyDraw(const char* drawCommand, Int_t sector, const c
 
 //_____________________________________________________________________________
 Int_t AliTPCCalibViewer::EasyDraw1D(const char* drawCommand, const char* sector, const char* cuts, const char* drawOptions, Bool_t writeDrawCommand) const {
-  //
-  // easy drawing of data, use '~' for abbreviation of '.fElements'
-  // example: EasyDraw("CETmean~-CETmean_mean", "A", "(CETmean~-CETmean_mean)>0")
-  // sector: sector-number - the specified sector will be drwawn
-  //         'A'/'C' or 'a'/'c' - side A/C will be drawn
-  //         'ALL' - whole TPC will be drawn, projected on one side
-  // cuts: specifies cuts
-  // drawOptions: draw options like 'same'
-  // writeDrawCommand: write the command, that is passed to TTree::Draw
-  //
+  /// easy drawing of data, use '~' for abbreviation of '.fElements'
+  /// example: EasyDraw("CETmean~-CETmean_mean", "A", "(CETmean~-CETmean_mean)>0")
+  /// sector: sector-number - the specified sector will be drwawn
+  ///         'A'/'C' or 'a'/'c' - side A/C will be drawn
+  ///         'ALL' - whole TPC will be drawn, projected on one side
+  /// cuts: specifies cuts
+  /// drawOptions: draw options like 'same'
+  /// writeDrawCommand: write the command, that is passed to TTree::Draw
 
    TString drawStr(drawCommand);
    TString sectorStr(sector);
@@ -479,8 +465,8 @@ Int_t AliTPCCalibViewer::EasyDraw1D(const char* drawCommand, const char* sector,
    if (writeDrawCommand) std::cout << "fTree->Draw(\"" << drawStr << "\", \"" <<  cutStr << "\", \"" << drawOptionsStr << "\");" << std::endl;
    Int_t returnValue = fTree->Draw(drawStr.Data(), cutStr.Data(), drawOptionsStr.Data());
    if (returnValue == -1) return -1;
-   
-   TObject *obj = (gPad) ? gPad->GetPrimitive("htemp") : 0; 
+
+   TObject *obj = (gPad) ? gPad->GetPrimitive("htemp") : 0;
    if (!obj) obj = (TH1F*)gDirectory->Get("htemp");
    if (!obj) obj = gPad->GetPrimitive("tempHist");
    if (!obj) obj = (TH1F*)gDirectory->Get("tempHist");
@@ -492,14 +478,12 @@ Int_t AliTPCCalibViewer::EasyDraw1D(const char* drawCommand, const char* sector,
 
 
 Int_t AliTPCCalibViewer::EasyDraw1D(const char* drawCommand, Int_t sector, const char* cuts, const char* drawOptions, Bool_t writeDrawCommand) const {
-  //
-  // easy drawing of data, use '~' for abbreviation of '.fElements'
-  // example: EasyDraw("CETmean~-CETmean_mean", 34, "(CETmean~-CETmean_mean)>0")
-  // sector: sector-number - the specified sector will be drwawn
-  // cuts: specifies cuts
-  // drawOptions: draw options like 'same'
-  // writeDrawCommand: write the command, that is passed to TTree::Draw
-  //
+  /// easy drawing of data, use '~' for abbreviation of '.fElements'
+  /// example: EasyDraw("CETmean~-CETmean_mean", 34, "(CETmean~-CETmean_mean)>0")
+  /// sector: sector-number - the specified sector will be drwawn
+  /// cuts: specifies cuts
+  /// drawOptions: draw options like 'same'
+  /// writeDrawCommand: write the command, that is passed to TTree::Draw
 
    if (sector >= 0 && sector < 72) {
       return EasyDraw1D(drawCommand, Form("%i",sector), cuts, drawOptions, writeDrawCommand);
@@ -510,10 +494,9 @@ Int_t AliTPCCalibViewer::EasyDraw1D(const char* drawCommand, Int_t sector, const
 
 
 void AliTPCCalibViewer::FormatHistoLabels(TH1 *histo) const {
-   // 
-   // formats title and axis labels of histo 
-   // removes '.fElements'
-   // 
+   /// formats title and axis labels of histo
+   /// removes '.fElements'
+
    if (!histo) return;
    TString replaceString(fAppendString.Data());
    TString *str = new TString(histo->GetTitle());
@@ -542,34 +525,32 @@ void AliTPCCalibViewer::FormatHistoLabels(TH1 *histo) const {
 
 
 Int_t  AliTPCCalibViewer::DrawHisto1D(const char* drawCommand, Int_t sector, const char* cuts, const char *sigmas, Bool_t plotMean, Bool_t plotMedian, Bool_t plotLTM) const {
-   // 
-   // Easy drawing of data, in principle the same as EasyDraw1D
-   // Difference: A line for the mean / median / LTM is drawn 
-   // in 'sigmas' you can specify in which distance to the mean/median/LTM you want to see a line in sigma-units, separated by ';'
-   // example: sigmas = "2; 4; 6;"  at Begin_Latex 2 #sigma End_Latex, Begin_Latex 4 #sigma End_Latex and Begin_Latex 6 #sigma End_Latex  a line is drawn.
-   // "plotMean", "plotMedian" and "plotLTM": what kind of lines do you want to see?
-   // 
+   /// Easy drawing of data, in principle the same as EasyDraw1D
+   /// Difference: A line for the mean / median / LTM is drawn
+   /// in 'sigmas' you can specify in which distance to the mean/median/LTM you want to see a line in sigma-units, separated by ';'
+   /// example: sigmas = "2; 4; 6;"  at \f$2 \sigma\f$, \f$4 \sigma\f$ and \f$6 \sigma\f$  a line is drawn.
+   /// "plotMean", "plotMedian" and "plotLTM": what kind of lines do you want to see?
+
    if (sector >= 0 && sector < 72) {
       return DrawHisto1D(drawCommand, Form("%i", sector), cuts, sigmas, plotMean, plotMedian, plotLTM);
    }
    Error("DrawHisto1D","The TPC contains only sectors between 0 and 71.");
    return -1;
-}   
+}
 
 
 Int_t  AliTPCCalibViewer::DrawHisto1D(const char* drawCommand, const char* sector, const char* cuts, const char *sigmas, Bool_t plotMean, Bool_t plotMedian, Bool_t plotLTM) const {
-   // 
-   // Easy drawing of data, in principle the same as EasyDraw1D
-   // Difference: A line for the mean / median / LTM is drawn 
-   // in 'sigmas' you can specify in which distance to the mean/median/LTM you want to see a line in sigma-units, separated by ';'
-   // example: sigmas = "2; 4; 6;"  at Begin_Latex 2 #sigma End_Latex, Begin_Latex 4 #sigma End_Latex and Begin_Latex 6 #sigma End_Latex  a line is drawn.
-   // "plotMean", "plotMedian" and "plotLTM": what kind of lines do you want to see?
-   // 
+   /// Easy drawing of data, in principle the same as EasyDraw1D
+   /// Difference: A line for the mean / median / LTM is drawn
+   /// in 'sigmas' you can specify in which distance to the mean/median/LTM you want to see a line in sigma-units, separated by ';'
+   /// example: sigmas = "2; 4; 6;"  at \f$2 \sigma\f$, \f$4 \sigma\f$ and \f$6 \sigma\f$  a line is drawn.
+   /// "plotMean", "plotMedian" and "plotLTM": what kind of lines do you want to see?
+
    Int_t oldOptStat = gStyle->GetOptStat();
    gStyle->SetOptStat(0000000);
    Double_t ltmFraction = 0.8;
-   
-   TObjArray *sigmasTokens = TString(sigmas).Tokenize(";");  
+
+   TObjArray *sigmasTokens = TString(sigmas).Tokenize(";");
    TVectorF nsigma(sigmasTokens->GetEntriesFast());
    for (Int_t i = 0; i < sigmasTokens->GetEntriesFast(); i++) {
       TString str(((TObjString*)sigmasTokens->At(i))->GetString());
@@ -589,12 +570,12 @@ Int_t  AliTPCCalibViewer::DrawHisto1D(const char* drawCommand, const char* secto
    TH1F *htemp = (TH1F*)gDirectory->Get("tempHist");
    // FIXME is this histogram deleted automatically?
    Double_t *values = fTree->GetV1();  // value is the array containing 'entries' numbers
-   
+
    Double_t mean = TMath::Mean(entries, values);
    Double_t median = TMath::Median(entries, values);
    Double_t sigma = TMath::RMS(entries, values);
    Double_t maxY = htemp->GetMaximum();
-   
+
    TLegend * legend = new TLegend(.7,.7, .99, .99, "Statistical information");
    //fListOfObjectsToBeDeleted->Add(legend);
 
@@ -664,7 +645,7 @@ Int_t  AliTPCCalibViewer::DrawHisto1D(const char* drawCommand, const char* secto
          linePlusSigma->SetLineColor(kGreen+2);
          linePlusSigma->SetLineStyle(2+i);
          linePlusSigma->Draw();
-   
+
          TLine* lineMinusSigma = new TLine(ltm - nsigma[i] * ltmRms, 0, ltm - nsigma[i] * ltmRms, maxY);
          //fListOfObjectsToBeDeleted->Add(lineMinusSigma);
          lineMinusSigma->SetLineColor(kGreen+2);
@@ -681,25 +662,23 @@ Int_t  AliTPCCalibViewer::DrawHisto1D(const char* drawCommand, const char* secto
 
 
 Int_t AliTPCCalibViewer::SigmaCut(const char* drawCommand, Int_t sector, const char* cuts, Float_t sigmaMax, Bool_t plotMean, Bool_t plotMedian, Bool_t plotLTM, Bool_t pm, const char *sigmas, Float_t sigmaStep) const {
-   //
-   // Creates a histogram Begin_Latex S(t, #mu, #sigma) End_Latex, where you can see, how much of the data are inside sigma-intervals around the mean value
-   // The data of the distribution Begin_Latex f(x, #mu, #sigma) End_Latex are given in 'array', 'n' specifies the length of the array
-   // 'mean' and 'sigma' are Begin_Latex #mu End_Latex and  Begin_Latex #sigma End_Latex of the distribution in 'array', to be specified by the user
-   // 'nbins': number of bins, 'binLow': first bin, 'binUp': last bin
-   // sigmaMax: up to which sigma around the mean/median/LTM the histogram is generated (in units of sigma, Begin_Latex t #sigma End_Latex)
-   // sigmaStep: the binsize of the generated histogram
-   // Begin_Latex 
-   // f(x, #mu, #sigma)     #Rightarrow       S(t, #mu, #sigma) = (#int_{#mu}^{#mu + t #sigma} f(x, #mu, #sigma) dx + #int_{#mu}^{#mu - t #sigma} f(x, #mu, #sigma) dx) / (#int_{-#infty}^{+#infty} f(x, #mu, #sigma) dx)
-   // End_Latex
-   // 
-   //
-   // Creates a histogram, where you can see, how much of the data are inside sigma-intervals 
-   // around the mean/median/LTM
-   // with drawCommand, sector and cuts you specify your input data, see EasyDraw
-   // sigmaMax: up to which sigma around the mean/median/LTM the histogram is generated (in units of sigma)
-   // sigmaStep: the binsize of the generated histogram
-   // plotMean/plotMedian/plotLTM: specifies where to put the center
-   //
+   /// Creates a histogram \f$S(t, \mu, \sigma)\f$, where you can see, how much of the data are inside sigma-intervals around the mean value
+   /// The data of the distribution \f$f(x, \mu, \sigma)\f$ are given in 'array', 'n' specifies the length of the array
+   /// 'mean' and 'sigma' are \f$\mu\f$ and  \f$\sigma\f$ of the distribution in 'array', to be specified by the user
+   /// 'nbins': number of bins, 'binLow': first bin, 'binUp': last bin
+   /// sigmaMax: up to which sigma around the mean/median/LTM the histogram is generated (in units of sigma, \f$t \sigma\f$)
+   /// sigmaStep: the binsize of the generated histogram
+   /// \f[
+   /// f(x, \mu, \sigma)     \Rightarrow       S(t, \mu, \sigma) = (\int_{\mu}^{\mu + t \sigma} f(x, \mu, \sigma) dx + \int_{\mu}^{\mu - t \sigma} f(x, \mu, \sigma) dx) / (\int_{-\infty}^{+\infty} f(x, \mu, \sigma) dx)
+   /// \f]
+   ///
+   /// Creates a histogram, where you can see, how much of the data are inside sigma-intervals
+   /// around the mean/median/LTM
+   /// with drawCommand, sector and cuts you specify your input data, see EasyDraw
+   /// sigmaMax: up to which sigma around the mean/median/LTM the histogram is generated (in units of sigma)
+   /// sigmaStep: the binsize of the generated histogram
+   /// plotMean/plotMedian/plotLTM: specifies where to put the center
+
    if (sector >= 0 && sector < 72) {
       return SigmaCut(drawCommand, Form("%i", sector), cuts, sigmaMax, plotMean, plotMedian, plotLTM, pm, sigmas, sigmaStep);
    }
@@ -709,17 +688,15 @@ Int_t AliTPCCalibViewer::SigmaCut(const char* drawCommand, Int_t sector, const c
 
 
 Int_t AliTPCCalibViewer::SigmaCut(const char* drawCommand, const char* sector, const char* cuts, Float_t sigmaMax, Bool_t plotMean, Bool_t plotMedian, Bool_t plotLTM, Bool_t pm, const char *sigmas, Float_t sigmaStep) const {
-   //
-   // Creates a histogram, where you can see, how much of the data are inside sigma-intervals 
-   // around the mean/median/LTM
-   // with drawCommand, sector and cuts you specify your input data, see EasyDraw
-   // sigmaMax: up to which sigma around the mean/median/LTM the histogram is generated (in units of sigma)
-   // sigmaStep: the binsize of the generated histogram
-   // plotMean/plotMedian/plotLTM: specifies where to put the center
-   //
-  
+   /// Creates a histogram, where you can see, how much of the data are inside sigma-intervals
+   /// around the mean/median/LTM
+   /// with drawCommand, sector and cuts you specify your input data, see EasyDraw
+   /// sigmaMax: up to which sigma around the mean/median/LTM the histogram is generated (in units of sigma)
+   /// sigmaStep: the binsize of the generated histogram
+   /// plotMean/plotMedian/plotLTM: specifies where to put the center
+
    Double_t ltmFraction = 0.8;
-   
+
    TString drawStr(drawCommand);
    Bool_t dangerousToDraw = drawStr.Contains(":") || drawStr.Contains(">>");
    if (dangerousToDraw) {
@@ -727,23 +704,23 @@ Int_t AliTPCCalibViewer::SigmaCut(const char* drawCommand, const char* sector, c
       return -1;
    }
    drawStr += " >> tempHist";
-   
+
    Int_t entries = EasyDraw1D(drawStr.Data(), sector, cuts, "goff");
    TH1F *htemp = (TH1F*)gDirectory->Get("tempHist");
    // FIXME is this histogram deleted automatically?
    Double_t *values = fTree->GetV1();  // value is the array containing 'entries' numbers
-   
+
    Double_t mean = TMath::Mean(entries, values);
    Double_t median = TMath::Median(entries, values);
    Double_t sigma = TMath::RMS(entries, values);
-   
+
    TLegend * legend = new TLegend(.7,.7, .99, .99, "Cumulative");
    //fListOfObjectsToBeDeleted->Add(legend);
    TH1F *cutHistoMean = 0;
    TH1F *cutHistoMedian = 0;
    TH1F *cutHistoLTM = 0;
-   
-   TObjArray *sigmasTokens = TString(sigmas).Tokenize(";");  
+
+   TObjArray *sigmasTokens = TString(sigmas).Tokenize(";");
    TVectorF nsigma(sigmasTokens->GetEntriesFast());
    for (Int_t i = 0; i < sigmasTokens->GetEntriesFast(); i++) {
       TString str(((TObjString*)sigmasTokens->At(i))->GetString());
@@ -762,7 +739,7 @@ Int_t AliTPCCalibViewer::SigmaCut(const char* drawCommand, const char* sector, c
          cutHistoMean->Draw();
          DrawLines(cutHistoMean, nsigma, legend, kRed, pm);
       } // if (cutHistoMean)
-       
+
    }
    if (plotMedian) {
       cutHistoMedian = AliTPCCalibViewer::SigmaCut(htemp, median, sigma, sigmaMax, sigmaStep, pm);
@@ -797,20 +774,18 @@ Int_t AliTPCCalibViewer::SigmaCut(const char* drawCommand, const char* sector, c
 
 
 Int_t AliTPCCalibViewer::SigmaCutNew(const char* drawCommand, const char* sector, const char* cuts, Float_t /*sigmaMax*/, Bool_t plotMean, Bool_t plotMedian, Bool_t plotLTM, Bool_t /*pm*/, const char *sigmas, Float_t /*sigmaStep*/) const {
-   //
-   // Creates a histogram, where you can see, how much of the data are inside sigma-intervals 
-   // around the mean/median/LTM
-   // with drawCommand, sector and cuts you specify your input data, see EasyDraw
-   // sigmaMax: up to which sigma around the mean/median/LTM the histogram is generated (in units of sigma)
-   // sigmaStep: the binsize of the generated histogram
-   // plotMean/plotMedian/plotLTM: specifies where to put the center
-   //
-  
+   /// Creates a histogram, where you can see, how much of the data are inside sigma-intervals
+   /// around the mean/median/LTM
+   /// with drawCommand, sector and cuts you specify your input data, see EasyDraw
+   /// sigmaMax: up to which sigma around the mean/median/LTM the histogram is generated (in units of sigma)
+   /// sigmaStep: the binsize of the generated histogram
+   /// plotMean/plotMedian/plotLTM: specifies where to put the center
+
    // Double_t ltmFraction = 0.8;  //unused
-   
+
    TString drawStr(drawCommand);
    drawStr += " >> tempHist";
-   
+
    Int_t entries = EasyDraw1D(drawStr.Data(), sector, cuts, "goff");
    TH1F *htemp = (TH1F*)gDirectory->Get("tempHist");
    TGraph *cutGraphMean   = 0;
@@ -821,16 +796,16 @@ Int_t AliTPCCalibViewer::SigmaCutNew(const char* drawCommand, const char* sector
    Float_t  *xarray = new Float_t[entries];
    Float_t  *yarray = new Float_t[entries];
    TMath::Sort(entries, values, index, kFALSE);
-   
+
    Double_t mean = TMath::Mean(entries, values);
    // Double_t median = TMath::Median(entries, values);
    Double_t sigma = TMath::RMS(entries, values);
-   
+
    TLegend * legend = new TLegend(.7,.7, .99, .99, "Cumulative");
    //fListOfObjectsToBeDeleted->Add(legend);
-   
+
    // parse sigmas string
-   TObjArray *sigmasTokens = TString(sigmas).Tokenize(";");  
+   TObjArray *sigmasTokens = TString(sigmas).Tokenize(";");
    TVectorF nsigma(sigmasTokens->GetEntriesFast());
    for (Int_t i = 0; i < sigmasTokens->GetEntriesFast(); i++) {
       TString str(((TObjString*)sigmasTokens->At(i))->GetString());
@@ -838,10 +813,10 @@ Int_t AliTPCCalibViewer::SigmaCutNew(const char* drawCommand, const char* sector
       nsigma[i] = sig;
    }
    delete sigmasTokens;
-   
+
    if (plotMean) {
       for (Int_t i = 0; i < entries; i++) {
-         xarray[i] = TMath::Abs(values[index[i]] - mean) / sigma; 
+         xarray[i] = TMath::Abs(values[index[i]] - mean) / sigma;
          yarray[i] = float(i) / float(entries);
       }
       cutGraphMean = new TGraph(entries, xarray, yarray);
@@ -891,54 +866,54 @@ Int_t AliTPCCalibViewer::SigmaCutNew(const char* drawCommand, const char* sector
 
 
 Int_t AliTPCCalibViewer::Integrate(const char* drawCommand,       Int_t sector, const char* cuts, Float_t sigmaMax, Bool_t plotMean, Bool_t plotMedian, Bool_t plotLTM, const char *sigmas, Float_t sigmaStep) const {
-   //
-   // Creates an integrated histogram Begin_Latex S(t, #mu, #sigma) End_Latex, out of the input distribution distribution Begin_Latex f(x, #mu, #sigma) End_Latex, given in "histogram"   
-   // "mean" and "sigma" are Begin_Latex #mu End_Latex and  Begin_Latex #sigma End_Latex of the distribution in "histogram", to be specified by the user
-   // sigmaMax: up to which sigma around the mean/median/LTM you want to integrate 
-   // if "igma == 0" and "sigmaMax == 0" the whole histogram is integrated
-   // "sigmaStep": the binsize of the generated histogram, -1 means, that the maximal reasonable stepsize is used
-   // The actual work is done on the array.
-   /* Begin_Latex 
+   /// Creates an integrated histogram \f$S(t, \mu, \sigma)\f$, out of the input distribution distribution \f$f(x, \mu, \sigma)\f$, given in "histogram"
+   /// "mean" and "sigma" are \f$\mu\f$ and  \f$\sigma\f$ of the distribution in "histogram", to be specified by the user
+   /// sigmaMax: up to which sigma around the mean/median/LTM you want to integrate
+   /// if "igma == 0" and "sigmaMax == 0" the whole histogram is integrated
+   /// "sigmaStep": the binsize of the generated histogram, -1 means, that the maximal reasonable stepsize is used
+   /// The actual work is done on the array.
+
+   /* Begin_Latex
          f(x, #mu, #sigma)     #Rightarrow       S(t, #mu, #sigma) = #int_{-#infty}^{#mu + t #sigma} f(x, #mu, #sigma) dx / #int_{-#infty}^{+#infty} f(x, #mu, #sigma) dx
-      End_Latex  
+      End_Latex
    */
    if (sector >= 0 && sector < 72) {
       return Integrate(drawCommand, Form("%i", sector), cuts, sigmaMax, plotMean, plotMedian, plotLTM, sigmas, sigmaStep);
    }
    Error("Integrate","The TPC contains only sectors between 0 and 71.");
    return -1;
-   
+
 }
 
 
 Int_t AliTPCCalibViewer::IntegrateOld(const char* drawCommand, const char* sector, const char* cuts, Float_t sigmaMax, Bool_t plotMean, Bool_t plotMedian, Bool_t plotLTM, const char *sigmas, Float_t sigmaStep) const {
-   //
-   // Creates an integrated histogram Begin_Latex S(t, #mu, #sigma) End_Latex, out of the input distribution distribution Begin_Latex f(x, #mu, #sigma) End_Latex, given in "histogram"   
-   // "mean" and "sigma" are Begin_Latex #mu End_Latex and  Begin_Latex #sigma End_Latex of the distribution in "histogram", to be specified by the user
-   // sigmaMax: up to which sigma around the mean/median/LTM you want to integrate 
-   // if "igma == 0" and "sigmaMax == 0" the whole histogram is integrated
-   // "sigmaStep": the binsize of the generated histogram, -1 means, that the maximal reasonable stepsize is used
-   // The actual work is done on the array.
-   /* Begin_Latex 
+   /// Creates an integrated histogram \f$S(t, \mu, \sigma)\f$, out of the input distribution distribution \f$f(x, \mu, \sigma)\f$, given in "histogram"
+   /// "mean" and "sigma" are \f$\mu\f$ and  \f$\sigma\f$ of the distribution in "histogram", to be specified by the user
+   /// sigmaMax: up to which sigma around the mean/median/LTM you want to integrate
+   /// if "igma == 0" and "sigmaMax == 0" the whole histogram is integrated
+   /// "sigmaStep": the binsize of the generated histogram, -1 means, that the maximal reasonable stepsize is used
+   /// The actual work is done on the array.
+
+   /* Begin_Latex
          f(x, #mu, #sigma)     #Rightarrow       S(t, #mu, #sigma) = #int_{-#infty}^{#mu + t #sigma} f(x, #mu, #sigma) dx / #int_{-#infty}^{+#infty} f(x, #mu, #sigma) dx
-      End_Latex  
+      End_Latex
    */
-   
+
    Double_t ltmFraction = 0.8;
-   
+
    TString drawStr(drawCommand);
    drawStr += " >> tempHist";
-   
+
    Int_t entries = EasyDraw1D(drawStr.Data(), sector, cuts, "goff");
    TH1F *htemp = (TH1F*)gDirectory->Get("tempHist");
    // FIXME is this histogram deleted automatically?
    Double_t *values = fTree->GetV1();  // value is the array containing 'entries' numbers
-   
+
    Double_t mean = TMath::Mean(entries, values);
    Double_t median = TMath::Median(entries, values);
    Double_t sigma = TMath::RMS(entries, values);
-    
-   TObjArray *sigmasTokens = TString(sigmas).Tokenize(";");  
+
+   TObjArray *sigmasTokens = TString(sigmas).Tokenize(";");
    TVectorF nsigma(sigmasTokens->GetEntriesFast());
    for (Int_t i = 0; i < sigmasTokens->GetEntriesFast(); i++) {
       TString str(((TObjString*)sigmasTokens->At(i))->GetString());
@@ -952,7 +927,7 @@ Int_t AliTPCCalibViewer::IntegrateOld(const char* drawCommand, const char* secto
    TH1F *integralHistoMean = 0;
    TH1F *integralHistoMedian = 0;
    TH1F *integralHistoLTM = 0;
-  
+
    if (plotMean) {
       integralHistoMean = AliTPCCalibViewer::Integrate(htemp, mean, sigma, sigmaMax, sigmaStep);
       if (integralHistoMean) {
@@ -997,20 +972,20 @@ Int_t AliTPCCalibViewer::IntegrateOld(const char* drawCommand, const char* secto
 
 
 Int_t AliTPCCalibViewer::Integrate(const char* drawCommand, const char* sector, const char* cuts, Float_t /*sigmaMax*/, Bool_t plotMean, Bool_t plotMedian, Bool_t plotLTM, const char *sigmas, Float_t /*sigmaStep*/) const {
-   //
-   // Creates an integrated histogram Begin_Latex S(t, #mu, #sigma) End_Latex, out of the input distribution distribution Begin_Latex f(x, #mu, #sigma) End_Latex, given in "histogram"   
-   // "mean" and "sigma" are Begin_Latex #mu End_Latex and  Begin_Latex #sigma End_Latex of the distribution in "histogram", to be specified by the user
-   // sigmaMax: up to which sigma around the mean/median/LTM you want to integrate 
-   // if "igma == 0" and "sigmaMax == 0" the whole histogram is integrated
-   // "sigmaStep": the binsize of the generated histogram, -1 means, that the maximal reasonable stepsize is used
-   // The actual work is done on the array.
-   /* Begin_Latex 
+   /// Creates an integrated histogram \f$S(t, \mu, \sigma)\f$, out of the input distribution distribution \f$f(x, \mu, \sigma)\f$, given in "histogram"
+   /// "mean" and "sigma" are \f$\mu\f$ and  \f$\sigma\f$ of the distribution in "histogram", to be specified by the user
+   /// sigmaMax: up to which sigma around the mean/median/LTM you want to integrate
+   /// if "igma == 0" and "sigmaMax == 0" the whole histogram is integrated
+   /// "sigmaStep": the binsize of the generated histogram, -1 means, that the maximal reasonable stepsize is used
+   /// The actual work is done on the array.
+
+   /* Begin_Latex
          f(x, #mu, #sigma)     #Rightarrow       S(t, #mu, #sigma) = #int_{-#infty}^{#mu + t #sigma} f(x, #mu, #sigma) dx / #int_{-#infty}^{+#infty} f(x, #mu, #sigma) dx
-      End_Latex  
+      End_Latex
    */
-   
+
    Double_t ltmFraction = 0.8;
-   
+
    TString drawStr(drawCommand);
    Bool_t dangerousToDraw = drawStr.Contains(":") || drawStr.Contains(">>");
    if (dangerousToDraw) {
@@ -1018,7 +993,7 @@ Int_t AliTPCCalibViewer::Integrate(const char* drawCommand, const char* sector,
       return -1;
    }
    drawStr += " >> tempHist";
-   
+
    Int_t entries = EasyDraw1D(drawStr.Data(), sector, cuts, "goff");
    TH1F *htemp = (TH1F*)gDirectory->Get("tempHist");
    TGraph *integralGraphMean   = 0;
@@ -1029,13 +1004,13 @@ Int_t AliTPCCalibViewer::Integrate(const char* drawCommand, const char* sector,
    Float_t  *xarray = new Float_t[entries];
    Float_t  *yarray = new Float_t[entries];
    TMath::Sort(entries, values, index, kFALSE);
-   
+
    Double_t mean = TMath::Mean(entries, values);
    Double_t median = TMath::Median(entries, values);
    Double_t sigma = TMath::RMS(entries, values);
-   
+
    // parse sigmas string
-   TObjArray *sigmasTokens = TString(sigmas).Tokenize(";");  
+   TObjArray *sigmasTokens = TString(sigmas).Tokenize(";");
    TVectorF nsigma(sigmasTokens->GetEntriesFast());
    for (Int_t i = 0; i < sigmasTokens->GetEntriesFast(); i++) {
       TString str(((TObjString*)sigmasTokens->At(i))->GetString());
@@ -1046,10 +1021,10 @@ Int_t AliTPCCalibViewer::Integrate(const char* drawCommand, const char* sector,
 
    TLegend * legend = new TLegend(.7,.7, .99, .99, "Integrated histogram");
    //fListOfObjectsToBeDeleted->Add(legend);
-  
+
    if (plotMean) {
       for (Int_t i = 0; i < entries; i++) {
-         xarray[i] = (values[index[i]] - mean) / sigma; 
+         xarray[i] = (values[index[i]] - mean) / sigma;
          yarray[i] = float(i) / float(entries);
       }
       integralGraphMean = new TGraph(entries, xarray, yarray);
@@ -1064,7 +1039,7 @@ Int_t AliTPCCalibViewer::Integrate(const char* drawCommand, const char* sector,
    }
    if (plotMedian) {
       for (Int_t i = 0; i < entries; i++) {
-         xarray[i] = (values[index[i]] - median) / sigma; 
+         xarray[i] = (values[index[i]] - median) / sigma;
          yarray[i] = float(i) / float(entries);
       }
       integralGraphMedian = new TGraph(entries, xarray, yarray);
@@ -1082,7 +1057,7 @@ Int_t AliTPCCalibViewer::Integrate(const char* drawCommand, const char* sector,
       Double_t ltmRms = 0;
       Double_t ltm = GetLTM(entries, values, &ltmRms, ltmFraction);
       for (Int_t i = 0; i < entries; i++) {
-         xarray[i] = (values[index[i]] - ltm) / ltmRms; 
+         xarray[i] = (values[index[i]] - ltm) / ltmRms;
          yarray[i] = float(i) / float(entries);
       }
       integralGraphLTM = new TGraph(entries, xarray, yarray);
@@ -1099,7 +1074,7 @@ Int_t AliTPCCalibViewer::Integrate(const char* drawCommand, const char* sector,
    delete [] index;
    delete [] xarray;
    delete [] yarray;
-  
+
    if (!plotMean && !plotMedian && !plotLTM) return -1;
    legend->Draw();
    return entries;
@@ -1107,14 +1082,12 @@ Int_t AliTPCCalibViewer::Integrate(const char* drawCommand, const char* sector,
 
 
 void AliTPCCalibViewer::DrawLines(TH1F *histogram, TVectorF nsigma, TLegend *legend, Int_t color, Bool_t pm) const {
-   // 
-   // Private function for SigmaCut(...) and Integrate(...)
-   // Draws lines into the given histogram, specified by "nsigma", the lines are addeed to the legend
-   // 
-   
+   /// Private function for SigmaCut(...) and Integrate(...)
+   /// Draws lines into the given histogram, specified by "nsigma", the lines are addeed to the legend
+
    // start to draw the lines, loop over requested sigmas
    for (Int_t i = 0; i < nsigma.GetNoElements(); i++) {
-      if (!pm) { 
+      if (!pm) {
          Int_t bin = histogram->GetXaxis()->FindBin(nsigma[i]);
          TLine* lineUp = new TLine(nsigma[i], 0, nsigma[i], histogram->GetBinContent(bin));
          //fListOfObjectsToBeDeleted->Add(lineUp);
@@ -1154,19 +1127,17 @@ void AliTPCCalibViewer::DrawLines(TH1F *histogram, TVectorF nsigma, TLegend *leg
          lineLeft2->Draw();
          legend->AddEntry(lineLeft2, Form("Fraction(-%f #sigma) = %f",nsigma[i], histogram->GetBinContent(bin)), "l");
       }
-   }  // for (Int_t i = 0; i < nsigma.GetNoElements(); i++)   
+   }  // for (Int_t i = 0; i < nsigma.GetNoElements(); i++)
 }
 
 
 void AliTPCCalibViewer::DrawLines(TGraph *graph, TVectorF nsigma, TLegend *legend, Int_t color, Bool_t pm) const {
-   // 
-   // Private function for SigmaCut(...) and Integrate(...)
-   // Draws lines into the given histogram, specified by "nsigma", the lines are addeed to the legend
-   // 
-   
+   /// Private function for SigmaCut(...) and Integrate(...)
+   /// Draws lines into the given histogram, specified by "nsigma", the lines are addeed to the legend
+
    // start to draw the lines, loop over requested sigmas
    for (Int_t i = 0; i < nsigma.GetNoElements(); i++) {
-      if (!pm) { 
+      if (!pm) {
          TLine* lineUp = new TLine(nsigma[i], 0, nsigma[i], graph->Eval(nsigma[i]));
          //fListOfObjectsToBeDeleted->Add(lineUp);
          lineUp->SetLineColor(color);
@@ -1203,7 +1174,7 @@ void AliTPCCalibViewer::DrawLines(TGraph *graph, TVectorF nsigma, TLegend *legen
          lineLeft2->Draw();
          legend->AddEntry(lineLeft2, Form("Fraction(-%f #sigma) = %f",nsigma[i], graph->Eval(-nsigma[i])), "l");
       }
-   }  // for (Int_t i = 0; i < nsigma.GetNoElements(); i++)   
+   }  // for (Int_t i = 0; i < nsigma.GetNoElements(); i++)
 }
 
 
@@ -1216,27 +1187,27 @@ void AliTPCCalibViewer::DrawLines(TGraph *graph, TVectorF nsigma, TLegend *legen
 
 
 Int_t AliTPCCalibViewer::GetBin(Float_t value, Int_t nbins, Double_t binLow, Double_t binUp){
-   // Returns the 'bin' for 'value'
-   // The interval between 'binLow' and 'binUp' is divided into 'nbins' equidistant bins
-   // avoid index out of bounds error: 'if (bin < binLow) bin = binLow' and vice versa
+   /// Returns the 'bin' for 'value'
+   /// The interval between 'binLow' and 'binUp' is divided into 'nbins' equidistant bins
+   /// avoid index out of bounds error: 'if (bin < binLow) bin = binLow' and vice versa
+
    /* Begin_Latex
          GetBin(value) = #frac{nbins - 1}{binUp - binLow} #upoint (value - binLow) +1
       End_Latex
    */
-   
+
    Int_t bin =  TMath::Nint( (Float_t)(value - binLow) / (Float_t)(binUp - binLow) * (nbins-1) ) + 1;
-   // avoid index out of bounds:   
+   // avoid index out of bounds:
    if (value < binLow) bin = 0;
    if (value > binUp)  bin = nbins + 1;
    return bin;
-   
-}   
+
+}
 
 
 Double_t AliTPCCalibViewer::GetLTM(Int_t n, const Double_t *const array, Double_t *const sigma, Double_t fraction){
-   //
-   //  returns the LTM and sigma
-   //
+   ///  returns the LTM and sigma
+
    Double_t *ddata = new Double_t[n];
    Double_t mean = 0, lsigma = 0;
    UInt_t nPoints = 0;
@@ -1253,19 +1224,19 @@ Double_t AliTPCCalibViewer::GetLTM(Int_t n, const Double_t *const array, Double_
 
 
 TH1F* AliTPCCalibViewer::SigmaCut(TH1F *const histogram, Float_t mean, Float_t sigma, Float_t sigmaMax, Float_t sigmaStep, Bool_t pm) {
-   //
-   // Creates a cumulative histogram Begin_Latex S(t, #mu, #sigma) End_Latex, where you can see, how much of the data are inside sigma-intervals around the mean value
-   // The data of the distribution Begin_Latex f(x, #mu, #sigma) End_Latex are given in 'histogram'
-   // 'mean' and 'sigma' are Begin_Latex #mu End_Latex and  Begin_Latex #sigma End_Latex of the distribution in 'histogram', to be specified by the user
-   // sigmaMax: up to which sigma around the mean/median/LTM the histogram is generated (in units of sigma, Begin_Latex t #sigma End_Latex)
-   // sigmaStep: the binsize of the generated histogram, -1 means, that the maximal reasonable stepsize is used
-   // pm: Decide weather Begin_Latex t > 0 End_Latex (first case) or Begin_Latex t End_Latex arbitrary (secound case)
-   // The actual work is done on the array.
-   /* Begin_Latex 
-         f(x, #mu, #sigma)     #Rightarrow       S(t, #mu, #sigma) = (#int_{#mu}^{#mu + t #sigma} f(x, #mu, #sigma) dx + #int_{#mu}^{#mu - t #sigma} f(x, #mu, #sigma) dx) / (#int_{-#infty}^{+#infty} f(x, #mu, #sigma) dx),    for  t > 0    
-         or      
+   /// Creates a cumulative histogram \f$S(t, \mu, \sigma)\f$, where you can see, how much of the data are inside sigma-intervals around the mean value
+   /// The data of the distribution \f$f(x, \mu, \sigma)\f$ are given in 'histogram'
+   /// 'mean' and 'sigma' are \f$\mu\f$ and  \f$\sigma\f$ of the distribution in 'histogram', to be specified by the user
+   /// sigmaMax: up to which sigma around the mean/median/LTM the histogram is generated (in units of sigma, \f$t \sigma\f$)
+   /// sigmaStep: the binsize of the generated histogram, -1 means, that the maximal reasonable stepsize is used
+   /// pm: Decide weather \f$t > 0\f$ (first case) or \f$t\f$ arbitrary (secound case)
+   /// The actual work is done on the array.
+
+   /* Begin_Latex
+         f(x, #mu, #sigma)     #Rightarrow       S(t, #mu, #sigma) = (#int_{#mu}^{#mu + t #sigma} f(x, #mu, #sigma) dx + #int_{#mu}^{#mu - t #sigma} f(x, #mu, #sigma) dx) / (#int_{-#infty}^{+#infty} f(x, #mu, #sigma) dx),    for  t > 0
+         or
          f(x, #mu, #sigma)     #Rightarrow       S(t, #mu, #sigma) = #int_{#mu}^{#mu + t #sigma} f(x, #mu, #sigma) dx / #int_{-#infty}^{+#infty} f(x, #mu, #sigma) dx
-      End_Latex  
+      End_Latex
       Begin_Macro(source)
       {
          Float_t mean = 0;
@@ -1276,7 +1247,7 @@ TH1F* AliTPCCalibViewer::SigmaCut(TH1F *const histogram, Float_t mean, Float_t s
          TRandom rand(23);
          for (Int_t i = 0; i <50000;i++) distribution->Fill(rand.Gaus(mean, sigma));
          Float_t *ar = distribution->GetArray();
-         
+
          TCanvas* macro_example_canvas = new TCanvas("cAliTPCCalibViewer1", "", 350, 350);
          macro_example_canvas->Divide(0,3);
          TVirtualPad *pad1 = macro_example_canvas->cd(1);
@@ -1286,38 +1257,37 @@ TH1F* AliTPCCalibViewer::SigmaCut(TH1F *const histogram, Float_t mean, Float_t s
          TVirtualPad *pad2 = macro_example_canvas->cd(2);
          pad2->SetGridy();
          pad2->SetGridx();
-         
+
          TH1F *shist = AliTPCCalibViewer::SigmaCut(distribution, mean, sigma, sigmaMax);
          shist->SetNameTitle("Cumulative","Cumulative S(t, #mu, #sigma)");
-         shist->Draw();  
+         shist->Draw();
          TVirtualPad *pad3 = macro_example_canvas->cd(3);
          pad3->SetGridy();
          pad3->SetGridx();
          TH1F *shistPM = AliTPCCalibViewer::SigmaCut(distribution, mean, sigma, sigmaMax, -1, kTRUE);
-         shistPM->Draw();   
+         shistPM->Draw();
          return macro_example_canvas;
-      }  
+      }
       End_Macro
-   */ 
-   
+   */
+
    Float_t *array = histogram->GetArray();
    Int_t    nbins = histogram->GetXaxis()->GetNbins();
    Float_t binLow = histogram->GetXaxis()->GetXmin();
    Float_t binUp  = histogram->GetXaxis()->GetXmax();
    return AliTPCCalibViewer::SigmaCut(nbins, array, mean, sigma, nbins, binLow, binUp, sigmaMax, sigmaStep, pm);
-}   
-   
+}
+
 
 TH1F* AliTPCCalibViewer::SigmaCut(Int_t n, const Float_t *array, Float_t mean, Float_t sigma, Int_t nbins, Float_t binLow, Float_t binUp, Float_t sigmaMax, Float_t sigmaStep, Bool_t pm){
-   //
-   // Creates a histogram Begin_Latex S(t, #mu, #sigma) End_Latex, where you can see, how much of the data are inside sigma-intervals around the mean value
-   // The data of the distribution Begin_Latex f(x, #mu, #sigma) End_Latex are given in 'array', 'n' specifies the length of the array
-   // 'mean' and 'sigma' are Begin_Latex #mu End_Latex and  Begin_Latex #sigma End_Latex of the distribution in 'array', to be specified by the user
-   // 'nbins': number of bins, 'binLow': first bin, 'binUp': last bin
-   // sigmaMax: up to which sigma around the mean/median/LTM the histogram is generated (in units of sigma, Begin_Latex t #sigma End_Latex)
-   // sigmaStep: the binsize of the generated histogram
-   // Here the actual work is done.
-   
+   /// Creates a histogram \f$S(t, \mu, \sigma)\f$, where you can see, how much of the data are inside sigma-intervals around the mean value
+   /// The data of the distribution \f$f(x, \mu, \sigma)\f$ are given in 'array', 'n' specifies the length of the array
+   /// 'mean' and 'sigma' are \f$\mu\f$ and  \f$\sigma\f$ of the distribution in 'array', to be specified by the user
+   /// 'nbins': number of bins, 'binLow': first bin, 'binUp': last bin
+   /// sigmaMax: up to which sigma around the mean/median/LTM the histogram is generated (in units of sigma, \f$t \sigma\f$)
+   /// sigmaStep: the binsize of the generated histogram
+   /// Here the actual work is done.
+
    if (sigma == 0) return 0;
    Float_t binWidth = (binUp-binLow)/(nbins - 1);
    if (sigmaStep <= 0) sigmaStep = binWidth;
@@ -1325,22 +1295,22 @@ TH1F* AliTPCCalibViewer::SigmaCut(Int_t n, const Float_t *array, Float_t mean, F
    if (pm) kbins = 2 * (Int_t)(sigmaMax * sigma / sigmaStep) + 1;
    Float_t kbinLow = !pm ? 0 : -sigmaMax;
    Float_t kbinUp  = sigmaMax;
-   TH1F *hist = new TH1F("sigmaCutHisto","Cumulative; Multiples of #sigma; Fraction of included data", kbins, kbinLow, kbinUp); 
+   TH1F *hist = new TH1F("sigmaCutHisto","Cumulative; Multiples of #sigma; Fraction of included data", kbins, kbinLow, kbinUp);
    hist->SetDirectory(0);
    hist->Reset();
-   
+
    // calculate normalization
    Double_t normalization = 0;
    for (Int_t i = 0; i <= n; i++) {
         normalization += array[i];
    }
-   
+
    // given units: units from given histogram
    // sigma units: in units of sigma
    // iDelta: integrate in interval (mean +- iDelta), given units
    // x:      ofset from mean for integration, given units
-   // hist:   needs 
-   
+   // hist:   needs
+
 //    printf("nbins: %i, binLow: %f, binUp: %f \n", nbins, binLow, binUp);
    // fill histogram
    for (Float_t iDelta = 0; iDelta <= sigmaMax * sigma; iDelta += sigmaStep) {
@@ -1351,8 +1321,8 @@ TH1F* AliTPCCalibViewer::SigmaCut(Int_t n, const Float_t *array, Float_t mean, F
 //       printf("++ adding bins: ");
       for (Float_t x = binWidth; x <= iDelta; x += binWidth) {
          valueP += (mean + x <= binUp)  ? array[GetBin(mean + x, nbins, binLow, binUp)] : 0;
-         valueM += (mean-binWidth - x >= binLow) ? array[GetBin(mean-binWidth - x, nbins, binLow, binUp)] : 0; 
-//          printf("%i, ", GetBin(mean + x, nbins, binLow, binUp));        
+         valueM += (mean-binWidth - x >= binLow) ? array[GetBin(mean-binWidth - x, nbins, binLow, binUp)] : 0;
+//          printf("%i, ", GetBin(mean + x, nbins, binLow, binUp));
       }
 //       printf("\n");
       if (valueP / normalization > 100) printf("+++ Error, value to big: %f, normalization with %f will fail  +++ \n", valueP, normalization);
@@ -1382,27 +1352,26 @@ TH1F* AliTPCCalibViewer::SigmaCut(Int_t n, const Float_t *array, Float_t mean, F
 
 
 TH1F* AliTPCCalibViewer::SigmaCut(Int_t /*n*/, const Double_t */*array*/, Double_t /*mean*/, Double_t /*sigma*/, Int_t /*nbins*/, const Double_t */*xbins*/, Double_t /*sigmaMax*/){
-   // 
-   // SigmaCut for variable binsize
-   // NOT YET IMPLEMENTED !!!
-   // 
+   /// SigmaCut for variable binsize
+   /// NOT YET IMPLEMENTED !!!
+
    printf("SigmaCut with variable binsize, Not yet implemented\n");
-   
+
    return 0;
-}   
+}
 
 
 TH1F* AliTPCCalibViewer::Integrate(TH1F *const histogram, Float_t mean, Float_t sigma, Float_t sigmaMax, Float_t sigmaStep){
-   //
-   // Creates an integrated histogram Begin_Latex S(t, #mu, #sigma) End_Latex, out of the input distribution distribution Begin_Latex f(x, #mu, #sigma) End_Latex, given in "histogram"   
-   // "mean" and "sigma" are Begin_Latex #mu End_Latex and  Begin_Latex #sigma End_Latex of the distribution in "histogram", to be specified by the user
-   // sigmaMax: up to which sigma around the mean/median/LTM you want to integrate 
-   // if "igma == 0" and "sigmaMax == 0" the whole histogram is integrated
-   // "sigmaStep": the binsize of the generated histogram, -1 means, that the maximal reasonable stepsize is used
-   // The actual work is done on the array.
-   /* Begin_Latex 
+   /// Creates an integrated histogram \f$S(t, \mu, \sigma)\f$, out of the input distribution distribution \f$f(x, \mu, \sigma)\f$, given in "histogram"
+   /// "mean" and "sigma" are \f$\mu\f$ and  \f$\sigma\f$ of the distribution in "histogram", to be specified by the user
+   /// sigmaMax: up to which sigma around the mean/median/LTM you want to integrate
+   /// if "igma == 0" and "sigmaMax == 0" the whole histogram is integrated
+   /// "sigmaStep": the binsize of the generated histogram, -1 means, that the maximal reasonable stepsize is used
+   /// The actual work is done on the array.
+
+   /* Begin_Latex
          f(x, #mu, #sigma)     #Rightarrow       S(t, #mu, #sigma) = #int_{-#infty}^{#mu + t #sigma} f(x, #mu, #sigma) dx / #int_{-#infty}^{+#infty} f(x, #mu, #sigma) dx
-      End_Latex  
+      End_Latex
       Begin_Macro(source)
       {
          Float_t mean = 0;
@@ -1413,7 +1382,7 @@ TH1F* AliTPCCalibViewer::Integrate(TH1F *const histogram, Float_t mean, Float_t
          TRandom rand(23);
          for (Int_t i = 0; i <50000;i++) distribution->Fill(rand.Gaus(mean, sigma));
          Float_t *ar = distribution->GetArray();
-         
+
          TCanvas* macro_example_canvas = new TCanvas("cAliTPCCalibViewer2", "", 350, 350);
          macro_example_canvas->Divide(0,2);
          TVirtualPad *pad1 = macro_example_canvas->cd(1);
@@ -1425,47 +1394,47 @@ TH1F* AliTPCCalibViewer::Integrate(TH1F *const histogram, Float_t mean, Float_t
          pad2->SetGridx();
          TH1F *shist = AliTPCCalibViewer::Integrate(distribution, mean, sigma, sigmaMax);
          shist->SetNameTitle("Cumulative","Cumulative S(t, #mu, #sigma)");
-         shist->Draw();  
-         
-      }  
+         shist->Draw();
+
+      }
       End_Macro
-   */ 
+   */
+
 
-   
    Float_t *array = histogram->GetArray();
    Int_t    nbins = histogram->GetXaxis()->GetNbins();
    Float_t binLow = histogram->GetXaxis()->GetXmin();
    Float_t binUp  = histogram->GetXaxis()->GetXmax();
    return AliTPCCalibViewer::Integrate(nbins, array, nbins, binLow, binUp, mean, sigma, sigmaMax, sigmaStep);
-}   
+}
 
 
 TH1F* AliTPCCalibViewer::Integrate(Int_t n, const Float_t *const array, Int_t nbins, Float_t binLow, Float_t binUp, Float_t mean, Float_t sigma, Float_t sigmaMax, Float_t sigmaStep){
-   // Creates an integrated histogram Begin_Latex S(t, #mu, #sigma) End_Latex, out of the input distribution distribution Begin_Latex f(x, #mu, #sigma) End_Latex, given in "histogram"   
-   // "mean" and "sigma" are Begin_Latex #mu End_Latex and  Begin_Latex #sigma End_Latex of the distribution in "histogram", to be specified by the user
-   // sigmaMax: up to which sigma around the mean/median/LTM you want to integrate 
-   // if "igma == 0" and "sigmaMax == 0" the whole histogram is integrated
-   // "sigmaStep": the binsize of the generated histogram, -1 means, that the maximal reasonable stepsize is used
-   // Here the actual work is done.
-      
+   /// Creates an integrated histogram \f$S(t, \mu, \sigma)\f$, out of the input distribution distribution \f$f(x, \mu, \sigma)\f$, given in "histogram"
+   /// "mean" and "sigma" are \f$\mu\f$ and  \f$\sigma\f$ of the distribution in "histogram", to be specified by the user
+   /// sigmaMax: up to which sigma around the mean/median/LTM you want to integrate
+   /// if "igma == 0" and "sigmaMax == 0" the whole histogram is integrated
+   /// "sigmaStep": the binsize of the generated histogram, -1 means, that the maximal reasonable stepsize is used
+   /// Here the actual work is done.
+
    Bool_t givenUnits = kTRUE;
    if (sigma != 0 && sigmaMax != 0) givenUnits = kFALSE;
    if (givenUnits) {
       sigma = 1;
       sigmaMax = (binUp - binLow) / 2.;
    }
-   
+
    Float_t binWidth = (binUp-binLow)/(nbins - 1);
    if (sigmaStep <= 0) sigmaStep = binWidth;
    Int_t kbins =  (Int_t)(sigmaMax * sigma / sigmaStep) + 1;  // + 1  due to overflow bin in histograms
    Float_t kbinLow = givenUnits ? binLow : -sigmaMax;
    Float_t kbinUp  = givenUnits ? binUp  : sigmaMax;
-   TH1F *hist = 0; 
-   if (givenUnits)  hist = new TH1F("integratedHisto","Integrated Histogram; Given x; Fraction of included data", kbins, kbinLow, kbinUp); 
-   if (!givenUnits) hist = new TH1F("integratedHisto","Integrated Histogram; Multiples of #sigma; Fraction of included data", kbins, kbinLow, kbinUp); 
+   TH1F *hist = 0;
+   if (givenUnits)  hist = new TH1F("integratedHisto","Integrated Histogram; Given x; Fraction of included data", kbins, kbinLow, kbinUp);
+   if (!givenUnits) hist = new TH1F("integratedHisto","Integrated Histogram; Multiples of #sigma; Fraction of included data", kbins, kbinLow, kbinUp);
    hist->SetDirectory(0);
    hist->Reset();
-   
+
    // calculate normalization
  //  printf("calculating normalization, integrating from bin 1 to %i \n", n);
    Double_t normalization = 0;
@@ -1473,13 +1442,13 @@ TH1F* AliTPCCalibViewer::Integrate(Int_t n, const Float_t *const array, Int_t nb
         normalization += array[i];
    }
  //  printf("normalization: %f \n", normalization);
-   
+
    // given units: units from given histogram
    // sigma units: in units of sigma
    // iDelta: integrate in interval (mean +- iDelta), given units
    // x:      ofset from mean for integration, given units
-   // hist:   needs 
-   
+   // hist:   needs
+
    // fill histogram
    for (Float_t iDelta = mean - sigmaMax * sigma; iDelta <= mean + sigmaMax * sigma; iDelta += sigmaStep) {
       // integrate array
@@ -1510,12 +1479,11 @@ TH1F* AliTPCCalibViewer::Integrate(Int_t n, const Float_t *const array, Int_t nb
 
 //_____________________________________________________________________________
 AliTPCCalPad* AliTPCCalibViewer::GetCalPadOld(const char* desiredData, const char* cuts, const char* calPadName) const {
-  //
-  // creates a AliTPCCalPad out of the 'desiredData'
-  // the functionality of EasyDraw1D is used
-  // calPadName specifies the name of the created AliTPCCalPad
-  //  - this takes a while -
-  //
+  /// creates a AliTPCCalPad out of the 'desiredData'
+  /// the functionality of EasyDraw1D is used
+  /// calPadName specifies the name of the created AliTPCCalPad
+  ///  - this takes a while -
+
    TString drawStr(desiredData);
    drawStr.Append(":channel");
    drawStr.Append(fAbbreviation);
@@ -1527,21 +1495,20 @@ AliTPCCalPad* AliTPCCalibViewer::GetCalPadOld(const char* desiredData, const cha
       if (entries == -1) return 0;
       const Double_t *pchannel = fTree->GetV2();
       const Double_t *pvalue   = fTree->GetV1();
-      for (Int_t i = 0; i < entries; i++) 
+      for (Int_t i = 0; i < entries; i++)
          roc->SetValue((UInt_t)(pchannel[i]), (Float_t)(pvalue[i]));
    }
-   return createdCalPad;   
+   return createdCalPad;
 }
 
 
 //_____________________________________________________________________________
 AliTPCCalPad* AliTPCCalibViewer::GetCalPad(const char* desiredData, const char* cuts, const char* calPadName) const {
-  //
-  // creates a AliTPCCalPad out of the 'desiredData'
-  // the functionality of EasyDraw1D is used
-  // calPadName specifies the name of the created AliTPCCalPad
-  //  - this takes a while -
-  //
+  /// creates a AliTPCCalPad out of the 'desiredData'
+  /// the functionality of EasyDraw1D is used
+  /// calPadName specifies the name of the created AliTPCCalPad
+  ///  - this takes a while -
+
    TString drawStr(desiredData);
    drawStr.Append(":channel.fElements:sector");
    AliTPCCalPad * createdCalPad = new AliTPCCalPad(calPadName, calPadName);
@@ -1561,36 +1528,34 @@ AliTPCCalPad* AliTPCCalibViewer::GetCalPad(const char* desiredData, const char*
 //      AliTPCCalROC * roc = createdCalPad->GetCalROC(sec);
 //       entries = EasyDraw1D(drawStr.Data(), (Int_t)sec, cuts, "goff");
 //       if (entries == -1) return 0;
-//       for (Int_t i = 0; i < entries; i++) 
+//       for (Int_t i = 0; i < entries; i++)
 //          roc->SetValue((UInt_t)(pchannel[i]), (Float_t)(pvalue[i]));
 //    }
-   return createdCalPad;   
+   return createdCalPad;
 }
 
 //_____________________________________________________________________________
 AliTPCCalROC* AliTPCCalibViewer::GetCalROC(const char* desiredData, UInt_t sector, const char* cuts) const {
-  //
-  // creates a AliTPCCalROC out of the desiredData
-  // the functionality of EasyDraw1D is used
-  // sector specifies the sector of the created AliTPCCalROC
-  //
+  /// creates a AliTPCCalROC out of the desiredData
+  /// the functionality of EasyDraw1D is used
+  /// sector specifies the sector of the created AliTPCCalROC
+
    TString drawStr(desiredData);
    drawStr.Append(":channel");
    drawStr.Append(fAbbreviation);
    Int_t entries = EasyDraw1D(drawStr.Data(), (Int_t)sector, cuts, "goff");
    if (entries == -1) return 0;
    AliTPCCalROC * createdROC = new AliTPCCalROC(sector);
-   for (Int_t i = 0; i < entries; i++) 
+   for (Int_t i = 0; i < entries; i++)
       createdROC->SetValue((UInt_t)(fTree->GetV2()[i]), fTree->GetV1()[i]);
    return createdROC;
 }
 
 
 TObjArray* AliTPCCalibViewer::GetListOfVariables(Bool_t printList) {
-  //
-  // scan the tree  - produces a list of available variables in the tree
-  // printList: print the list to the screen, after the scan is done
-  //
+  /// scan the tree  - produces a list of available variables in the tree
+  /// printList: print the list to the screen, after the scan is done
+
    TObjArray* arr = new TObjArray();
    TObjString* str = 0;
    if (!fTree) return 0;
@@ -1603,13 +1568,13 @@ TObjArray* AliTPCCalibViewer::GetListOfVariables(Bool_t printList) {
       str->String().ReplaceAll("_LTM", "");
       str->String().ReplaceAll("_OutlierCutted", "");
       str->String().ReplaceAll(".", "");
-      if (!arr->FindObject(str) && 
-          !(str->String() == "channel" || str->String() == "gx" || str->String() == "gy" || 
-            str->String() == "lx" || str->String() == "ly" || str->String() == "pad" || 
+      if (!arr->FindObject(str) &&
+          !(str->String() == "channel" || str->String() == "gx" || str->String() == "gy" ||
+            str->String() == "lx" || str->String() == "ly" || str->String() == "pad" ||
             str->String() == "row" || str->String() == "rpad" || str->String() == "sector"  ))
          arr->Add(str);
    }
-   
+
    // loop over all friends (if there are some) and add them to the list
    if (fTree->GetListOfFriends()) {
       for (Int_t ifriend = 0; ifriend < fTree->GetListOfFriends()->GetEntries(); ifriend++){
@@ -1628,8 +1593,8 @@ TObjArray* AliTPCCalibViewer::GetListOfVariables(Bool_t printList) {
             str->String().ReplaceAll("_LTM", "");
             str->String().ReplaceAll("_OutlierCutted", "");
             str->String().ReplaceAll(".", "");
-            if (!(str->String() == "channel" || str->String() == "gx" || str->String() == "gy" || 
-                  str->String() == "lx" || str->String() == "ly" || str->String() == "pad" || 
+            if (!(str->String() == "channel" || str->String() == "gx" || str->String() == "gy" ||
+                  str->String() == "lx" || str->String() == "ly" || str->String() == "pad" ||
                   str->String() == "row" || str->String() == "rpad" || str->String() == "sector"  )){
                // insert "<friendName>." at the beginning: (<friendName> is per default "R")
                str->String().Insert(0, ".");
@@ -1640,7 +1605,7 @@ TObjArray* AliTPCCalibViewer::GetListOfVariables(Bool_t printList) {
          }
       }
    } // if (fTree->GetListOfFriends())
-   
+
    arr->Sort();
 //   ((TFriendElement*)gui->GetViewer()->GetTree()->GetListOfFriends()->At(0))->GetTree()->GetListOfBranches()->At(0)->GetName()
 // ((TFriendElement*)gui->GetViewer()->GetTree()->GetListOfFriends()->At(0))->GetTree()->GetListOfBranches()
@@ -1660,10 +1625,9 @@ TObjArray* AliTPCCalibViewer::GetListOfVariables(Bool_t printList) {
 
 
 TObjArray* AliTPCCalibViewer::GetListOfNormalizationVariables(Bool_t printList) const{
-  //
-  // produces a list of available variables for normalization in the tree
-  // printList: print the list to the screen, after the scan is done
-  //
+  /// produces a list of available variables for normalization in the tree
+  /// printList: print the list to the screen, after the scan is done
+
    TObjArray* arr = new TObjArray();
    arr->Add(new TObjString("_Mean"));
    arr->Add(new TObjString("_Mean_OutlierCutted"));
@@ -1693,10 +1657,9 @@ TObjArray* AliTPCCalibViewer::GetListOfNormalizationVariables(Bool_t printList)
 
 
 TFriendElement* AliTPCCalibViewer::AddReferenceTree(const char* filename, const char* treename, const char* refname){
-  //
-  // add a reference tree to the current tree
-  // by default the treename is 'calPads' and the reference treename is 'R'
-  //
+  /// add a reference tree to the current tree
+  /// by default the treename is 'calPads' and the reference treename is 'R'
+
    TFile *file = new TFile(filename);
    fListOfObjectsToBeDeleted->Add(file);
    TTree * tree = (TTree*)file->Get(treename);
@@ -1705,10 +1668,9 @@ TFriendElement* AliTPCCalibViewer::AddReferenceTree(const char* filename, const
 
 
 TObjArray* AliTPCCalibViewer::GetArrayOfCalPads(){
-  //
-  // Returns a TObjArray with all AliTPCCalPads that are stored in the tree
-  //  - this takes a while - 
-  //
+  /// Returns a TObjArray with all AliTPCCalPads that are stored in the tree
+  ///  - this takes a while -
+
    TObjArray *listOfCalPads = GetListOfVariables();
    TObjArray *calPadsArray = new TObjArray();
    Int_t numberOfCalPads = listOfCalPads->GetEntries();
@@ -1717,8 +1679,8 @@ TObjArray* AliTPCCalibViewer::GetArrayOfCalPads(){
       char* calPadName = (char*)((TObjString*)(listOfCalPads->At(i)))->GetString().Data();
       TString drawCommand = ((TObjString*)(listOfCalPads->At(i)))->GetString();
       drawCommand.Append(fAbbreviation.Data());
-      AliTPCCalPad* calPad = GetCalPad(drawCommand.Data(), "", calPadName); 
-      calPadsArray->Add(calPad); 
+      AliTPCCalPad* calPad = GetCalPad(drawCommand.Data(), "", calPadName);
+      calPadsArray->Add(calPad);
    }
    std::cout << std::endl;
    listOfCalPads->Delete();
@@ -1728,53 +1690,51 @@ TObjArray* AliTPCCalibViewer::GetArrayOfCalPads(){
 
 
 TString* AliTPCCalibViewer::Fit(const char* drawCommand, const char* formula, const char* cuts, Double_t & chi2, TVectorD &fitParam, TMatrixD &covMatrix){
-   //
-   // fit an arbitrary function, specified by formula into the data, specified by drawCommand and cuts
-   // returns chi2, fitParam and covMatrix
-   // returns TString with fitted formula
-   //
-   
-   TString formulaStr(formula); 
+   /// fit an arbitrary function, specified by formula into the data, specified by drawCommand and cuts
+   /// returns chi2, fitParam and covMatrix
+   /// returns TString with fitted formula
+
+   TString formulaStr(formula);
    TString drawStr(drawCommand);
    TString cutStr(cuts);
-   
+
    // abbreviations:
    drawStr.ReplaceAll(fAbbreviation, fAppendString);
    cutStr.ReplaceAll(fAbbreviation, fAppendString);
    formulaStr.ReplaceAll(fAbbreviation, fAppendString);
-   
+
    formulaStr.ReplaceAll("++", fAbbreviation);
-   TObjArray* formulaTokens = formulaStr.Tokenize(fAbbreviation.Data()); 
+   TObjArray* formulaTokens = formulaStr.Tokenize(fAbbreviation.Data());
    Int_t dim = formulaTokens->GetEntriesFast();
-   
+
    fitParam.ResizeTo(dim);
    covMatrix.ResizeTo(dim,dim);
-   
+
    TLinearFitter* fitter = new TLinearFitter(dim+1, Form("hyp%d",dim));
-   fitter->StoreData(kTRUE);   
+   fitter->StoreData(kTRUE);
    fitter->ClearPoints();
-   
+
    Int_t entries = Draw(drawStr.Data(), cutStr.Data(), "goff");
    if (entries == -1) {
      delete formulaTokens;
      return new TString("An ERROR has occured during fitting!");
    }
-   Double_t **values = new Double_t*[dim+1] ; 
-   
+   Double_t **values = new Double_t*[dim+1] ;
+
    for (Int_t i = 0; i < dim + 1; i++){
       Int_t centries = 0;
       if (i < dim) centries = fTree->Draw(((TObjString*)formulaTokens->At(i))->GetName(), cutStr.Data(), "goff");
       else  centries = fTree->Draw(drawStr.Data(), cutStr.Data(), "goff");
-      
+
       if (entries != centries) {
         delete [] values;
 	delete formulaTokens;
         return new TString("An ERROR has occured during fitting!");
       }
       values[i] = new Double_t[entries];
-      memcpy(values[i],  fTree->GetV1(), entries*sizeof(Double_t)); 
+      memcpy(values[i],  fTree->GetV1(), entries*sizeof(Double_t));
    }
-   
+
    // add points to the fitter
    for (Int_t i = 0; i < entries; i++){
       Double_t x[1000];
@@ -1787,9 +1747,9 @@ TString* AliTPCCalibViewer::Fit(const char* drawCommand, const char* formula, co
    fitter->GetCovarianceMatrix(covMatrix);
    chi2 = fitter->GetChisquare();
 //    chi2 = chi2;
-   
+
    TString *preturnFormula = new TString(Form("( %e+",fitParam[0])), &returnFormula = *preturnFormula;
-   
+
    for (Int_t iparam = 0; iparam < dim; iparam++) {
      returnFormula.Append(Form("%s*(%e)",((TObjString*)formulaTokens->At(iparam))->GetName(),fitParam[iparam+1]));
      if (iparam < dim-1) returnFormula.Append("+");
@@ -1806,12 +1766,11 @@ TString* AliTPCCalibViewer::Fit(const char* drawCommand, const char* formula, co
 
 
 void AliTPCCalibViewer::MakeTreeWithObjects(const char *fileName, const TObjArray *const array, const char * mapFileName) {
-  //
-  // Write tree with all available information
-  // im mapFileName is speciefied, the Map information are also written to the tree
-  // AliTPCCalPad-Objects are written directly to the tree, so that they can be accessd later on
-  // (does not work!!!)
-  //
+  /// Write tree with all available information
+  /// im mapFileName is speciefied, the Map information are also written to the tree
+  /// AliTPCCalPad-Objects are written directly to the tree, so that they can be accessd later on
+  /// (does not work!!!)
+
    AliTPCROC* tpcROCinstance = AliTPCROC::Instance();
 
    TObjArray* mapIROCs = 0;
@@ -1820,17 +1779,17 @@ void AliTPCCalibViewer::MakeTreeWithObjects(const char *fileName, const TObjArra
    TVectorF *mapOROCArray = 0;
    Int_t mapEntries = 0;
    TString* mapNames = 0;
-   
+
    if (mapFileName) {
       TFile mapFile(mapFileName, "read");
-      
+
       TList* listOfROCs = mapFile.GetListOfKeys();
       mapEntries = listOfROCs->GetEntries()/2;
       mapIROCs = new TObjArray(mapEntries*2);
       mapOROCs = new TObjArray(mapEntries*2);
       mapIROCArray = new TVectorF[mapEntries];
       mapOROCArray = new TVectorF[mapEntries];
-      
+
       mapNames = new TString[mapEntries];
       for (Int_t ivalue = 0; ivalue < mapEntries; ivalue++) {
          TString rocName(((TKey*)(listOfROCs->At(ivalue*2)))->GetName());
@@ -1839,11 +1798,11 @@ void AliTPCCalibViewer::MakeTreeWithObjects(const char *fileName, const TObjArra
          mapOROCs->AddAt((AliTPCCalROC*)mapFile.Get((rocName + "OROC").Data()), ivalue);
          mapNames[ivalue].Append(rocName);
       }
-      
+
       for (Int_t ivalue = 0; ivalue < mapEntries; ivalue++) {
          mapIROCArray[ivalue].ResizeTo(tpcROCinstance->GetNChannels(0));
          mapOROCArray[ivalue].ResizeTo(tpcROCinstance->GetNChannels(36));
-      
+
          for (UInt_t ichannel = 0; ichannel < tpcROCinstance->GetNChannels(0); ichannel++)
             (mapIROCArray[ivalue])[ichannel] = ((AliTPCCalROC*)(mapIROCs->At(ivalue)))->GetValue(ichannel);
          for (UInt_t ichannel = 0; ichannel < tpcROCinstance->GetNChannels(36); ichannel++)
@@ -1851,22 +1810,22 @@ void AliTPCCalibViewer::MakeTreeWithObjects(const char *fileName, const TObjArra
       }
 
    } //  if (mapFileName)
-  
+
    TTreeSRedirector cstream(fileName);
    Int_t arrayEntries = array->GetEntries();
-   
+
    // Read names of AliTPCCalPads and save them in names[]
    TString* names = new TString[arrayEntries];
    for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++)
       names[ivalue].Append(((AliTPCCalPad*)array->At(ivalue))->GetName());
 
    for (UInt_t isector = 0; isector < tpcROCinstance->GetNSectors(); isector++) {
-      
+
       TVectorF *vectorArray = new TVectorF[arrayEntries];
       for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++)
          vectorArray[ivalue].ResizeTo(tpcROCinstance->GetNChannels(isector));
-            
-      
+
+
       //
       // fill vectors of variable per pad
       //
@@ -1889,7 +1848,7 @@ void AliTPCCalibViewer::MakeTreeWithObjects(const char *fileName, const TObjArra
             posArray[5][ichannel] = posG[1];
             posArray[6][ichannel] = (Int_t)(ipad - (Double_t)(tpcROCinstance->GetNPads(isector, irow))/2);
             posArray[7][ichannel] = ichannel;
-            
+
             // loop over array containing AliTPCCalPads
             for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++) {
                AliTPCCalPad* calPad = (AliTPCCalPad*) array->At(ivalue);
@@ -1908,7 +1867,7 @@ void AliTPCCalibViewer::MakeTreeWithObjects(const char *fileName, const TObjArra
          if (!roc) roc = &dummyROC;
          cstream << "calPads" <<
             (Char_t*)((names[ivalue] + ".=").Data()) << &vectorArray[ivalue];
-         cstream << "calPads" << 
+         cstream << "calPads" <<
             (Char_t*)((names[ivalue] + "Pad.=").Data()) << roc;
       }
 
@@ -1922,7 +1881,7 @@ void AliTPCCalibViewer::MakeTreeWithObjects(const char *fileName, const TObjArra
                   (Char_t*)((mapNames[ivalue] + ".=").Data()) << &mapOROCArray[ivalue];
          }
       }
-      
+
       cstream << "calPads" <<
          "sector=" << isector;
 
@@ -1955,18 +1914,17 @@ void AliTPCCalibViewer::MakeTreeWithObjects(const char *fileName, const TObjArra
 
 
 void AliTPCCalibViewer::MakeTree(const char * fileName, TObjArray * array, const char * mapFileName, AliTPCCalPad *const outlierPad, Float_t ltmFraction) {
-  //
-  // Write a tree with all available information
-  // if mapFileName is speciefied, the Map information are also written to the tree
-  // pads specified in outlierPad are not used for calculating statistics
-  // The following statistical information on the basis of a ROC are calculated: 
-  // "_Median", "_Mean", "_LTM", "_RMS_LTM"
-  // "_Median_OutlierCutted", "_Mean_OutlierCutted", "_RMS_OutlierCutted", "_LTM_OutlierCutted", "_RMS_LTM_OutlierCutted"
-  // The following position variables are available:
-  // "row", "pad", "lx", "ly", "gx", "gy", "rpad", "channel"
-  // 
-  // The tree out of this function is the basis for the AliTPCCalibViewer and the AliTPCCalibViewerGUI.
-   
+  /// Write a tree with all available information
+  /// if mapFileName is speciefied, the Map information are also written to the tree
+  /// pads specified in outlierPad are not used for calculating statistics
+  /// The following statistical information on the basis of a ROC are calculated:
+  /// "_Median", "_Mean", "_LTM", "_RMS_LTM"
+  /// "_Median_OutlierCutted", "_Mean_OutlierCutted", "_RMS_OutlierCutted", "_LTM_OutlierCutted", "_RMS_LTM_OutlierCutted"
+  /// The following position variables are available:
+  /// "row", "pad", "lx", "ly", "gx", "gy", "rpad", "channel"
+  ///
+  /// The tree out of this function is the basis for the AliTPCCalibViewer and the AliTPCCalibViewerGUI.
+
   AliTPCROC* tpcROCinstance = AliTPCROC::Instance();
 
   TObjArray* mapIROCs = 0;
@@ -1975,17 +1933,17 @@ void AliTPCCalibViewer::MakeTree(const char * fileName, TObjArray * array, const
   TVectorF *mapOROCArray = 0;
   Int_t mapEntries = 0;
   TString* mapNames = 0;
-  
+
   if (mapFileName) {
     TFile mapFile(mapFileName, "read");
-    
+
     TList* listOfROCs = mapFile.GetListOfKeys();
     mapEntries = listOfROCs->GetEntries()/2;
     mapIROCs = new TObjArray(mapEntries*2);
     mapOROCs = new TObjArray(mapEntries*2);
     mapIROCArray = new TVectorF[mapEntries];
     mapOROCArray = new TVectorF[mapEntries];
-    
+
     mapNames = new TString[mapEntries];
     for (Int_t ivalue = 0; ivalue < mapEntries; ivalue++) {
       TString rocName(((TKey*)(listOfROCs->At(ivalue*2)))->GetName());
@@ -1994,27 +1952,27 @@ void AliTPCCalibViewer::MakeTree(const char * fileName, TObjArray * array, const
       mapOROCs->AddAt((AliTPCCalROC*)mapFile.Get((rocName + "OROC").Data()), ivalue);
       mapNames[ivalue].Append(rocName);
     }
-    
+
     for (Int_t ivalue = 0; ivalue < mapEntries; ivalue++) {
       mapIROCArray[ivalue].ResizeTo(tpcROCinstance->GetNChannels(0));
       mapOROCArray[ivalue].ResizeTo(tpcROCinstance->GetNChannels(36));
-      
+
       for (UInt_t ichannel = 0; ichannel < tpcROCinstance->GetNChannels(0); ichannel++)
         (mapIROCArray[ivalue])[ichannel] = ((AliTPCCalROC*)(mapIROCs->At(ivalue)))->GetValue(ichannel);
       for (UInt_t ichannel = 0; ichannel < tpcROCinstance->GetNChannels(36); ichannel++)
         (mapOROCArray[ivalue])[ichannel] = ((AliTPCCalROC*)(mapOROCs->At(ivalue)))->GetValue(ichannel);
     }
-    
+
   } //  if (mapFileName)
-  
+
   TTreeSRedirector cstream(fileName,"recreate");
   Int_t arrayEntries = 0;
   if (array) arrayEntries = array->GetEntries();
-  
+
   TString* names = new TString[arrayEntries];
   for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++)
     names[ivalue].Append(((AliTPCCalPad*)array->At(ivalue))->GetName());
-  
+
   for (UInt_t isector = 0; isector < tpcROCinstance->GetNSectors(); isector++) {
       //
       // get statistic for given sector
@@ -2029,14 +1987,14 @@ void AliTPCCalibViewer::MakeTree(const char * fileName, TObjArray * array, const
     TVectorF rmsWithOut(arrayEntries);
     TVectorF ltmWithOut(arrayEntries);
     TVectorF ltmrmsWithOut(arrayEntries);
-    
+
     TVectorF *vectorArray = new TVectorF[arrayEntries];
     for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++){
       vectorArray[ivalue].ResizeTo(tpcROCinstance->GetNChannels(isector));
       vectorArray[ivalue].SetUniqueID(array->UncheckedAt(ivalue)->GetUniqueID());
 //       printf("UniqueID: %d\n",vectorArray[ivalue].GetUniqueID());
     }
-    
+
     for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++) {
       AliTPCCalPad* calPad = (AliTPCCalPad*) array->At(ivalue);
       AliTPCCalROC* calROC = calPad->GetCalROC(isector);
@@ -2071,14 +2029,14 @@ void AliTPCCalibViewer::MakeTree(const char * fileName, TObjArray * array, const
         ltmrmsWithOut[ivalue] = 0.;
       }
     }
-    
+
       //
       // fill vectors of variable per pad
       //
     TVectorF *posArray = new TVectorF[8];
     for (Int_t ivalue = 0; ivalue < 8; ivalue++)
       posArray[ivalue].ResizeTo(tpcROCinstance->GetNChannels(isector));
-    
+
     Float_t posG[3] = {0};
     Float_t posL[3] = {0};
     Int_t ichannel = 0;
@@ -2094,7 +2052,7 @@ void AliTPCCalibViewer::MakeTree(const char * fileName, TObjArray * array, const
         posArray[5][ichannel] = posG[1];
         posArray[6][ichannel] = (Int_t)(ipad - (Double_t)(tpcROCinstance->GetNPads(isector, irow))/2);
         posArray[7][ichannel] = ichannel;
-        
+
             // loop over array containing AliTPCCalPads
         for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++) {
           AliTPCCalPad* calPad = (AliTPCCalPad*) array->At(ivalue);
@@ -2107,10 +2065,10 @@ void AliTPCCalibViewer::MakeTree(const char * fileName, TObjArray * array, const
         ichannel++;
       }
     }
-    
+
     cstream << "calPads" <<
       "sector=" << isector;
-    
+
     for  (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++) {
       if (outlierPad==0) {
 	cstream << "calPads" <<
@@ -2146,14 +2104,14 @@ void AliTPCCalibViewer::MakeTree(const char * fileName, TObjArray * array, const
 	      }
 	      }
 	      delete arrtitle;*/
-      
+
     }
-    
+
     for  (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++) {
       cstream << "calPads" <<
         (Char_t*)((names[ivalue] + ".=").Data()) << &vectorArray[ivalue];
     }
-    
+
     if (mapFileName) {
           for  (Int_t ivalue = 0; ivalue < mapEntries; ivalue++) {
             if (isector < 36)
@@ -2174,10 +2132,10 @@ void AliTPCCalibViewer::MakeTree(const char * fileName, TObjArray * array, const
       "gy.=" << &posArray[5] <<
       "rpad.=" << &posArray[6] <<
       "channel.=" << &posArray[7];
-    
+
     cstream << "calPads" <<
       "\n";
-    
+
     delete[] posArray;
     delete[] vectorArray;
   }
@@ -2200,15 +2158,14 @@ void AliTPCCalibViewer::MakeTree(const char * fileName, TObjArray * array, const
   }
 }
 void AliTPCCalibViewer::MakeCalPadAliases(TTree * tree){
-  //
-  // make standard aliases for standard calibration trees
-  //
+  /// make standard aliases for standard calibration trees
+
   tree->SetAlias("Pad0","MapPadLength.fElements==7.5");   // pad types
   tree->SetAlias("Pad1","MapPadLength.fElements==10.0");
   tree->SetAlias("Pad2","MapPadLength.fElements==15.0");
   tree->SetAlias("ly","(ly.fElements+((sector<36)*(2*((sector%36)<18)-1)*0.2)+((sector>=36)*(2*((sector%36)<18)-1)*0.3))"); // correction for bug in tpcROCinstance->GetPositionLocal(isector, irow, ipad, posL);
   tree->SetAlias("dRowNorm0","(row.fElements/32-1)");      // normalized distance to the center of the chamber in lx (-1,1)
-  tree->SetAlias("dRowNorm1","(row.fElements/32-1)");      // 
+  tree->SetAlias("dRowNorm1","(row.fElements/32-1)");      //
   tree->SetAlias("dRowNorm2","((row.fElements-63)/16-1)"); //
   tree->SetAlias("dRowNorm","(row.fElements<63)*(row.fElements/32-1)+(row.fElements>63)*((row.fElements-63)/16-1)");
   tree->SetAlias("dPhiNorm","(ly/lx.fElements)/(pi/18)"); // normalized distance to the center of the chamber in phi (-1,1)
@@ -2219,56 +2176,50 @@ void AliTPCCalibViewer::MakeCalPadAliases(TTree * tree){
 }
 
 void AliTPCCalibViewer::MakeTree(const char *outPutFileName, const Char_t *inputFileName, AliTPCCalPad *outlierPad, Float_t ltmFraction, const char *mapFileName ){
-   // 
-   // Function to create a calibration Tree with all available information.
-   // See also documentation to MakeTree   
-   // the file "inputFileName" must be in the following format (see also CreateObjectList):
-   // (each colum separated by tabs, "dependingOnType" can have 2 or 3 colums)
-   // 
-   // type	path	dependingOnType
-   // 
-   // type == "CE":
-   // dependingOnType = CETmean	CEQmean	CETrms
-   // 
-   // type == "Pulser":
-   // dependingOnType = PulserTmean	PulsterQmean	PulserTrms
-   // 
-   // type == "Pedestals":
-   // dependingOnType = Pedestals	Noise
-   // 
-   // type == "CalPad":
-   // dependingOnType = NameInFile	NameToWriteToFile
-   // 
-   // 
+   /// Function to create a calibration Tree with all available information.
+   /// See also documentation to MakeTree
+   /// the file "inputFileName" must be in the following format (see also CreateObjectList):
+   /// (each colum separated by tabs, "dependingOnType" can have 2 or 3 colums)
+   ///
+   /// type	path	dependingOnType
+   ///
+   /// type == "CE":
+   /// dependingOnType = CETmean	CEQmean	CETrms
+   ///
+   /// type == "Pulser":
+   /// dependingOnType = PulserTmean	PulsterQmean	PulserTrms
+   ///
+   /// type == "Pedestals":
+   /// dependingOnType = Pedestals	Noise
+   ///
+   /// type == "CalPad":
+   /// dependingOnType = NameInFile	NameToWriteToFile
+
    TObjArray objArray;
    CreateObjectList(inputFileName, &objArray);
-   MakeTree(outPutFileName, &objArray, mapFileName, outlierPad, ltmFraction);   
+   MakeTree(outPutFileName, &objArray, mapFileName, outlierPad, ltmFraction);
 }
 
 
 void AliTPCCalibViewer::CreateObjectList(const Char_t *filename, TObjArray *calibObjects){
-   // 
-   // Function to create a TObjArray out of a given file
-   // the file must be in the following format:
-   // (each colum separated by tabs, "dependingOnType" can have 2 or 3 colums)
-   // 
-   // 
-   // type	path	dependingOnType
-   // 
-   // type == "CE":
-   // dependingOnType = CETmean	CEQmean	CETrms
-   // 
-   // type == "Pulser":
-   // dependingOnType = PulserTmean	PulsterQmean	PulserTrms
-   // 
-   // type == "Pedestals":
-   // dependingOnType = Pedestals	Noise
-   // 
-   // type == "CalPad":
-   // dependingOnType = NameInFile	NameToWriteToFile
-   // 
-   // 
-   // 
+   /// Function to create a TObjArray out of a given file
+   /// the file must be in the following format:
+   /// (each colum separated by tabs, "dependingOnType" can have 2 or 3 colums)
+   ///
+   /// type	path	dependingOnType
+   ///
+   /// type == "CE":
+   /// dependingOnType = CETmean	CEQmean	CETrms
+   ///
+   /// type == "Pulser":
+   /// dependingOnType = PulserTmean	PulsterQmean	PulserTrms
+   ///
+   /// type == "Pedestals":
+   /// dependingOnType = Pedestals	Noise
+   ///
+   /// type == "CalPad":
+   /// dependingOnType = NameInFile	NameToWriteToFile
+
    if ( calibObjects == 0x0 ) return;
    ifstream in;
    in.open(filename);
@@ -2276,27 +2227,27 @@ void AliTPCCalibViewer::CreateObjectList(const Char_t *filename, TObjArray *cali
       fprintf(stderr,"Error: cannot open list file '%s'", filename);
       return;
    }
-   
+
    AliTPCCalPad *calPad=0x0;
-   
+
    TString sFile;
    sFile.ReadFile(in);
    in.close();
-   
+
    TObjArray *arrFileLine = sFile.Tokenize("\n");
    TIter nextLine(arrFileLine);
-   
+
    TObjString *sObjLine = 0x0;
    while ( (sObjLine = (TObjString*)nextLine()) ){
       TString sLine(sObjLine->GetString());
-      
+
       TObjArray *arrCol = sLine.Tokenize("\t");
       Int_t nCols = arrCol->GetEntriesFast();
-      
+
       TObjString *sObjType     = (TObjString*)(arrCol->At(0));
       TObjString *sObjFileName = (TObjString*)(arrCol->At(1));
       TObjString *sObjName = 0x0;
-      
+
       if ( !sObjType || !sObjFileName ) continue;
       TString sType(sObjType->GetString());
       TString sFileName(sObjFileName->GetString());
@@ -2306,79 +2257,79 @@ void AliTPCCalibViewer::CreateObjectList(const Char_t *filename, TObjArray *cali
          fprintf(stderr,"File not found: '%s'", sFileName.Data());
          continue;
       }
-      
+
       if ( sType == "CE" ){  // next three colums are the names for CETmean, CEQmean and CETrms
          AliTPCCalibCE *ce = (AliTPCCalibCE*)fIn->Get("AliTPCCalibCE");
-         calPad = new AliTPCCalPad((TObjArray*)ce->GetCalPadT0());         
+         calPad = new AliTPCCalPad((TObjArray*)ce->GetCalPadT0());
          if (nCols > 2) {  // check, if the name is provided
             sObjName = (TObjString*)(arrCol->At(2));
             calPad->SetNameTitle(sObjName->GetString().Data(), sObjName->GetString().Data());
          }
          else calPad->SetNameTitle("CETmean","CETmean");
          calibObjects->Add(calPad);
-         
-         calPad = new AliTPCCalPad((TObjArray*)ce->GetCalPadQ());         
+
+         calPad = new AliTPCCalPad((TObjArray*)ce->GetCalPadQ());
          if (nCols > 3) {  // check, if the name is provided
             sObjName = (TObjString*)(arrCol->At(3));
             calPad->SetNameTitle(sObjName->GetString().Data(), sObjName->GetString().Data());
          }
          else calPad->SetNameTitle("CEQmean","CEQmean");
-         calibObjects->Add(calPad);        
-         
+         calibObjects->Add(calPad);
+
          calPad = new AliTPCCalPad((TObjArray*)ce->GetCalPadRMS());
          if (nCols > 4) {  // check, if the name is provided
             sObjName = (TObjString*)(arrCol->At(4));
             calPad->SetNameTitle(sObjName->GetString().Data(), sObjName->GetString().Data());
          }
          else calPad->SetNameTitle("CETrms","CETrms");
-         calibObjects->Add(calPad);         
-                  
+         calibObjects->Add(calPad);
+
       } else if ( sType == "Pulser") {
          AliTPCCalibPulser *sig = (AliTPCCalibPulser*)fIn->Get("AliTPCCalibPulser");
-         
-         calPad = new AliTPCCalPad((TObjArray*)sig->GetCalPadT0());         
+
+         calPad = new AliTPCCalPad((TObjArray*)sig->GetCalPadT0());
          if (nCols > 2) {
             sObjName = (TObjString*)(arrCol->At(2));
             calPad->SetNameTitle(sObjName->GetString().Data(), sObjName->GetString().Data());
          }
          else calPad->SetNameTitle("PulserTmean","PulserTmean");
          calibObjects->Add(calPad);
-         
-         calPad = new AliTPCCalPad((TObjArray*)sig->GetCalPadQ());         
+
+         calPad = new AliTPCCalPad((TObjArray*)sig->GetCalPadQ());
          if (nCols > 3) {
             sObjName = (TObjString*)(arrCol->At(3));
             calPad->SetNameTitle(sObjName->GetString().Data(), sObjName->GetString().Data());
          }
          else calPad->SetNameTitle("PulserQmean","PulserQmean");
-         calibObjects->Add(calPad);        
-         
+         calibObjects->Add(calPad);
+
          calPad = new AliTPCCalPad((TObjArray*)sig->GetCalPadRMS());
          if (nCols > 4) {
             sObjName = (TObjString*)(arrCol->At(4));
             calPad->SetNameTitle(sObjName->GetString().Data(), sObjName->GetString().Data());
          }
          else calPad->SetNameTitle("PulserTrms","PulserTrms");
-         calibObjects->Add(calPad);         
-      
+         calibObjects->Add(calPad);
+
       } else if ( sType == "Pedestals") {
          AliTPCCalibPedestal *ped = (AliTPCCalibPedestal*)fIn->Get("AliTPCCalibPedestal");
-         
-         calPad = new AliTPCCalPad((TObjArray*)ped->GetCalPadPedestal());         
+
+         calPad = new AliTPCCalPad((TObjArray*)ped->GetCalPadPedestal());
          if (nCols > 2) {
             sObjName = (TObjString*)(arrCol->At(2));
             calPad->SetNameTitle(sObjName->GetString().Data(), sObjName->GetString().Data());
          }
          else calPad->SetNameTitle("Pedestals","Pedestals");
          calibObjects->Add(calPad);
-         
-         calPad = new AliTPCCalPad((TObjArray*)ped->GetCalPadRMS());         
+
+         calPad = new AliTPCCalPad((TObjArray*)ped->GetCalPadRMS());
          if (nCols > 3) {
             sObjName = (TObjString*)(arrCol->At(3));
             calPad->SetNameTitle(sObjName->GetString().Data(), sObjName->GetString().Data());
          }
          else calPad->SetNameTitle("Noise","Noise");
-         calibObjects->Add(calPad);        
-     
+         calibObjects->Add(calPad);
+
       } else if ( sType == "CalPad") {
          if (nCols > 2) sObjName = (TObjString*)(arrCol->At(2));
          else continue;
diff --git a/TPC/TPCbase/AliTPCCalibViewer.h b/TPC/TPCbase/AliTPCCalibViewer.h
index a84e499ebb3..f8bbdd27df6 100644
--- a/TPC/TPCbase/AliTPCCalibViewer.h
+++ b/TPC/TPCbase/AliTPCCalibViewer.h
@@ -5,11 +5,10 @@
 
 /* $Id: AliTPCCalibViewer.h,v */
 
-///////////////////////////////////////////////////
-//                                               //
-//  TPC calibration viewer/visualization class   //
-//  use Tree for visualization                   //
-///////////////////////////////////////////////////
+/// \class AliTPCCalibViewer
+///
+/// \brief TPC calibration viewer/visualization class
+///  use Tree for visualization
 
 class TFile;
 class TLegend;
@@ -98,18 +97,20 @@ public:
    
          
 protected:
-   TTree* fTree;     // tree containing visualization data (e.g. written by AliTPCCalPad::MakeTree(...)
-   TFile* fFile;     // file that contains a calPads tree (e.g. written by AliTPCCalPad::MakeTree(...)
-   TObjArray* fListOfObjectsToBeDeleted;  //Objects, that will be deleted when the destructor ist called
-   Bool_t fTreeMustBeDeleted;  // decides weather the tree must be deleted in destructor or not 
-   TString fAbbreviation;       // the abreviation for '.fElements'
-   TString fAppendString;      // '.fElements', stored in a TStrig
+   TTree* fTree;     ///< tree containing visualization data (e.g. written by AliTPCCalPad::MakeTree(...)
+   TFile* fFile;     ///< file that contains a calPads tree (e.g. written by AliTPCCalPad::MakeTree(...)
+   TObjArray* fListOfObjectsToBeDeleted;  ///< Objects, that will be deleted when the destructor ist called
+   Bool_t fTreeMustBeDeleted;  ///< decides weather the tree must be deleted in destructor or not
+   TString fAbbreviation;       ///< the abreviation for '.fElements'
+   TString fAppendString;      ///< '.fElements', stored in a TStrig
    
    void DrawLines(TH1F *cutHistoMean, TVectorF nsigma, TLegend *legend, Int_t color, Bool_t pm) const;
    void DrawLines(TGraph *graph, TVectorF nsigma, TLegend *legend, Int_t color, Bool_t pm) const;
   
    
+   /// \cond CLASSIMP
    ClassDef(AliTPCCalibViewer,1)    //  TPC calibration viewer class
+   /// \endcond
 };
 
 #endif
diff --git a/TPC/TPCbase/AliTPCCalibViewerGUI.cxx b/TPC/TPCbase/AliTPCCalibViewerGUI.cxx
index 4cf271ab228..45df667f049 100644
--- a/TPC/TPCbase/AliTPCCalibViewerGUI.cxx
+++ b/TPC/TPCbase/AliTPCCalibViewerGUI.cxx
@@ -14,22 +14,16 @@
  **************************************************************************/
 
 
-///////////////////////////////////////////////////////////////////////////////
-//                                                                           //
-//  GUI for the AliTPCCalibViewer                                            //
-//  used for the calibration monitor                                         //
-//  All functionalities of the AliTPCCalibViewer are here available
-//  
-//  Example usage:                                                           //
-/*
-  aliroot
-  AliTPCCalibViewerGUI::ShowGUI("CalibTree.root")
-  
-*/
-//                         //
-//                                                                           //
-///////////////////////////////////////////////////////////////////////////////
-
+/// \class AliTPCCalibViewerGUI
+/// \brief GUI for the AliTPCCalibViewer
+///  used for the calibration monitor
+///  All functionalities of the AliTPCCalibViewer are here available
+///
+/// Example usage:
+/// ~~~
+/// aliroot
+/// AliTPCCalibViewerGUI::ShowGUI("CalibTree.root")
+/// ~~~
 
 #include "AliTPCCalibViewerGUI.h"
 #include "AliTPCCalPad.h"
@@ -68,7 +62,9 @@
 
 
 
+/// \cond CLASSIMP
 ClassImp(AliTPCCalibViewerGUI)
+/// \endcond
 
 AliTPCCalibViewerGUI::AliTPCCalibViewerGUI(const TGWindow *p, UInt_t w, UInt_t h, char* fileName)
   : TGCompositeFrame(p, w, h),
@@ -215,13 +211,10 @@ AliTPCCalibViewerGUI::AliTPCCalibViewerGUI(const TGWindow *p, UInt_t w, UInt_t h
 
 
 void AliTPCCalibViewerGUI::DrawGUI(const TGWindow */*p*/, UInt_t w, UInt_t h) {
-   // 
-   // draw the GUI
-   // 
-   // ======================================================================   
+   /// draw the GUI
+
    // ************************* Display everything *************************
-   // ======================================================================
-   
+
    SetCleanup(kDeepCleanup);
 
    // *****************************************************************************
@@ -897,9 +890,8 @@ void AliTPCCalibViewerGUI::DrawGUI(const TGWindow */*p*/, UInt_t w, UInt_t h) {
 
 
 void AliTPCCalibViewerGUI::SetInitialValues() {
-   // 
-   // Set the default button states
-   // 
+   /// Set the default button states
+
    fChkAuto->SetState(kButtonUp);
    fRadioPredefined->SetState(kButtonDown);
    fRadioRaw->SetState(kButtonDown);
@@ -1192,24 +1184,21 @@ AliTPCCalibViewerGUI::AliTPCCalibViewerGUI(const AliTPCCalibViewerGUI &c)
     fTxtRefName(0),
     fInitialized(0)
 {
-  //
-  // dummy AliTPCCalibViewerGUI copy constructor
-  //
+  /// dummy AliTPCCalibViewerGUI copy constructor
+
 }
 
 
 AliTPCCalibViewerGUI & AliTPCCalibViewerGUI::operator =(const AliTPCCalibViewerGUI & /*param*/) {
-   //
-   // dummy assignment operator
-   //
+   /// dummy assignment operator
+
    return (*this);
 }
 
 
 AliTPCCalibViewerGUI::~AliTPCCalibViewerGUI() {
-   // 
-   // Destructor
-   // 
+   /// Destructor
+
    if (fCanvMain && fCanvMain->GetCanvas()) {
       for (Int_t i = 0; i < fCanvMain->GetCanvas()->GetListOfPrimitives()->GetEntries(); i++) {
          if (strcmp(fCanvMain->GetCanvas()->GetListOfPrimitives()->At(i)->ClassName(), "TFrame") != 0)
@@ -1230,10 +1219,8 @@ void AliTPCCalibViewerGUI::CloseWindow() {
 
 
 void AliTPCCalibViewerGUI::Initialize(const char* fileName, const char* treeName) {
-   // 
-   // initialize the GUI with a calibrationTree from fileName
-   // 
-   
+   /// initialize the GUI with a calibrationTree from fileName
+
    // create AliTPCCalibViewer object, which will be used for generating all drawings
    if (fViewer) delete fViewer;
    fViewer = new AliTPCCalibViewer(fileName, treeName);
@@ -1242,10 +1229,8 @@ void AliTPCCalibViewerGUI::Initialize(const char* fileName, const char* treeName
 
 
 void AliTPCCalibViewerGUI::Initialize(AliTPCCalibViewer *viewer) {
-   //
-   // initializes the GUI with default settings and opens tree for drawing
-   //
-   
+   /// initializes the GUI with default settings and opens tree for drawing
+
    fViewer = viewer;
    TString selectedVariable("");
    TString selectedNormalization("");
@@ -1319,9 +1304,8 @@ void AliTPCCalibViewerGUI::Initialize(AliTPCCalibViewer *viewer) {
 }
 
 void AliTPCCalibViewerGUI::Reset(){
-  //
-  // reset variables, delete calib viewer
-  //
+  /// reset variables, delete calib viewer
+
   if (fViewer) delete fViewer;
   fListVariables->RemoveAll();
   fListNormalization->RemoveAll();
@@ -1329,10 +1313,9 @@ void AliTPCCalibViewerGUI::Reset(){
 }
 
 void AliTPCCalibViewerGUI::HandleButtonsGeneral(Int_t id) {
-   //
-   // handles mutual radio button exclusions
-   // for general Tab
-   //
+   /// handles mutual radio button exclusions
+   /// for general Tab
+
    if (id == -1) {
       TGButton *btn = (TGButton *) gTQSender;
       id = btn->WidgetId();
@@ -1385,11 +1368,9 @@ void AliTPCCalibViewerGUI::HandleButtonsGeneral(Int_t id) {
 
 
 void AliTPCCalibViewerGUI::HandleButtons1D(Int_t id) {
-   //
-   // handles mutual radio button exclusions
-   // 1D-Tab buttons
-   //
-   
+   /// handles mutual radio button exclusions
+   /// 1D-Tab buttons
+
    if (id == -1) {
       TGButton *btn = (TGButton *) gTQSender;
       id = btn->WidgetId();
@@ -1425,12 +1406,11 @@ void AliTPCCalibViewerGUI::HandleButtons1D(Int_t id) {
 
 
 void AliTPCCalibViewerGUI::HandleButtonsStat(Int_t id) {
-   // 
-   // handles statistic check boxes 
-   // checks each checkbox if checked
-   // if the checkbox is checked, appends 'n' for name, 'e' for entries, ...
-   // to a TString, passes this TString to gStyle->SetOptStat(...)
-   // 
+   /// handles statistic check boxes
+   /// checks each checkbox if checked
+   /// if the checkbox is checked, appends 'n' for name, 'e' for entries, ...
+   /// to a TString, passes this TString to gStyle->SetOptStat(...)
+
    if (id == -1) {
       TGButton *btn = (TGButton *) gTQSender;
       id = btn->WidgetId();
@@ -1456,10 +1436,9 @@ void AliTPCCalibViewerGUI::HandleButtonsStat(Int_t id) {
 
 
 void AliTPCCalibViewerGUI::HandleButtonsCuts(Int_t id) {
-   //
-   // handles mutual radio button exclusions
-   // right side buttons
-   //
+   /// handles mutual radio button exclusions
+   /// right side buttons
+
     if (id == -1) {
       TGButton *btn = (TGButton *) gTQSender;
       id = btn->WidgetId();
@@ -1505,10 +1484,9 @@ void AliTPCCalibViewerGUI::HandleButtonsCuts(Int_t id) {
 
 
 void AliTPCCalibViewerGUI::HandleButtonsNoRedraw(Int_t id) {
-   //
-   // handles label & scaling checkboxes 
-   // without redrawing (not necessary, faster like this)
-   //
+   /// handles label & scaling checkboxes
+   /// without redrawing (not necessary, faster like this)
+
     if (id == -1) {
       TGButton *btn = (TGButton *) gTQSender;
       id = btn->WidgetId();
@@ -1536,9 +1514,8 @@ void AliTPCCalibViewerGUI::HandleButtonsNoRedraw(Int_t id) {
 
 void AliTPCCalibViewerGUI::ReplacePlaceHolders(TString &str)
 {
-    //
-    // replace the defined placeholders in the custom draw string and cut string
-    //
+    /// replace the defined placeholders in the custom draw string and cut string
+
     TString drawPlaceHolder("#draw#");
     TString normPlaceHolder("#norm#");
 
@@ -1563,18 +1540,15 @@ void AliTPCCalibViewerGUI::ReplacePlaceHolders(TString &str)
 }
 
 void AliTPCCalibViewerGUI::DoNewSelection() {
-   //
-   // decides whether to redraw if user makes another selection
-   //
+   /// decides whether to redraw if user makes another selection
+
    if (fChkAuto->GetState() == kButtonDown) DoDraw();
 }
 
 
 TString* AliTPCCalibViewerGUI::GetDrawString() {
-   // 
-   // create the draw string out of selection
-   // 
-   
+   /// create the draw string out of selection
+
    // specify data to plot
    TString desiredData("");
    if (!fListVariables->GetSelectedEntry()) return 0;
@@ -1657,9 +1631,7 @@ TString* AliTPCCalibViewerGUI::GetDrawString() {
 
   
 TString* AliTPCCalibViewerGUI::GetSectorString() {
-   // 
-   // create the sector string out of selection
-   // 
+   /// create the sector string out of selection
 
    TString sectorStr("");
    if (fRadioTPC->GetState() == kButtonDown)
@@ -1682,10 +1654,8 @@ TString* AliTPCCalibViewerGUI::GetSectorString() {
   
  
  TString* AliTPCCalibViewerGUI::GetCutString() {
-   // 
-   // create the cut string out of selection
-   // 
-  
+   /// create the cut string out of selection
+
    TString cutsStr("");
    if (fChkCutZero->GetState() == kButtonDown) {
       TString cutZerosStr(GetDrawString()->Data());
@@ -1713,10 +1683,8 @@ TString* AliTPCCalibViewerGUI::GetSectorString() {
 
 
 void AliTPCCalibViewerGUI::DoDraw() {
-   //
-   // main method for drawing according to user selection
-   //
-   
+   /// main method for drawing according to user selection
+
    // specify data to plot:
   if (!GetDrawString()) return;
    TString desiredData(GetDrawString()->Data());
@@ -1772,10 +1740,8 @@ void AliTPCCalibViewerGUI::DoDraw() {
 
 
 void AliTPCCalibViewerGUI::DoFit() {
-   //
-   // main method for fitting
-   //
-   
+   /// main method for fitting
+
    Double_t chi2 = 0;
    TVectorD fitParam(0);
    TMatrixD covMatrix(0,0);
@@ -1830,9 +1796,8 @@ void AliTPCCalibViewerGUI::DoFit() {
 
 
 void AliTPCCalibViewerGUI::DoExport() {
-   //
-   // function to export a CalPad to Cint
-   //
+   /// function to export a CalPad to Cint
+
    if ( fRadio2D->GetState() != kButtonDown){
       Error("ExportCalPad", "Export of AliTPCCalPad to CINT works only in 2D mode.");
       return;
@@ -1853,10 +1818,8 @@ void AliTPCCalibViewerGUI::DoExport() {
 
 
 void AliTPCCalibViewerGUI::DoExportNorm() {
-   //
-   // function to export a CalPad to Cint
-   //
-   
+   /// function to export a CalPad to Cint
+
    if ( fRadio2D->GetState() != kButtonDown){
       Error("ExportCalPad", "Adding an AliTPCCalPad to the normalization works only in 2D mode.");
       return;
@@ -1885,9 +1848,8 @@ void AliTPCCalibViewerGUI::DoExportNorm() {
 
 
 void AliTPCCalibViewerGUI::GetMinMax() {
-   //
-   // Read current Min & Max from the plot and set it to fTxtSetMin & fTxtSetMax
-   //
+   /// Read current Min & Max from the plot and set it to fTxtSetMin & fTxtSetMax
+
    if (fChkGetMinMaxAuto->GetState() == kButtonUp) return;
    TList* listOfPrimitives = fCanvMain->GetCanvas()->GetListOfPrimitives();
    TObject* ptr = 0;
@@ -1919,11 +1881,9 @@ void AliTPCCalibViewerGUI::GetMinMax() {
 
 
 void AliTPCCalibViewerGUI::SetMinMaxLabel() {
-   // 
-   // Set Minimum, Maximum and labels without redrawing the plot
-   // (faster)
-   // 
-   
+   /// Set Minimum, Maximum and labels without redrawing the plot
+   /// (faster)
+
    // search for histogram
    TList* listOfPrimitives = fCanvMain->GetCanvas()->GetListOfPrimitives();
    TObject* ptr = 0;
@@ -1986,10 +1946,9 @@ void AliTPCCalibViewerGUI::SetMinMaxLabel() {
    
    
 void AliTPCCalibViewerGUI::ChangeSector(){
-   // 
-   // function that is called, when the number of the sector is changed
-   // to change the sector label
-   //
+   /// function that is called, when the number of the sector is changed
+   /// to change the sector label
+
    if ( fRadioROC->GetState()!=kButtonDown && fRadioSector->GetState()!=kButtonDown ){
        fLblSector->SetText("not used");
        return;
@@ -2018,17 +1977,15 @@ void AliTPCCalibViewerGUI::ChangeSector(){
 
 
 void AliTPCCalibViewerGUI::AddFitFunction() const { 
-   //
-   // adds the last fit function to the normalization list
-   // 
+   /// adds the last fit function to the normalization list
+
    std::cout << "Not yet implemented." << std::endl;
 }
 
 
 void AliTPCCalibViewerGUI::UnchekAllStat() {
-   // 
-   // Disable all statistical legend entries, no statistical legend.
-   // 
+   /// Disable all statistical legend entries, no statistical legend.
+
    fChkStatName->SetState(kButtonUp);
    fChkStatEntries->SetState(kButtonUp);
    fChkStatMean->SetState(kButtonUp);
@@ -2048,10 +2005,9 @@ void AliTPCCalibViewerGUI::UnchekAllStat() {
 
 
 void AliTPCCalibViewerGUI::MouseMove(Int_t event, Int_t x, Int_t y, TObject *selectedObject) { 
-   //
-   // mouse move
-   // zoom to sector works ONLY in 2D mode, if one side is specified
-   // 
+   /// mouse move
+   /// zoom to sector works ONLY in 2D mode, if one side is specified
+
    Double_t pi = TMath::Pi();
    if (event != kButton1Double )
       return;
@@ -2117,29 +2073,28 @@ void AliTPCCalibViewerGUI::MouseMove(Int_t event, Int_t x, Int_t y, TObject *sel
 
 
 void AliTPCCalibViewerGUI::SavePicture() {
-   // 
-   // saves the current picture
-   // 
-   // use the following combination of file type and save options:
-   // (see also TCanvas::Print)
-   // 
-   //       "ps"  - Postscript file is produced (see special cases below)
-   //    "Portrait" - Postscript file is produced (Portrait)
-   // "Landscape" - Postscript file is produced (Landscape)
-   //       "eps" - an Encapsulated Postscript file is produced
-   //    "Preview" - an Encapsulated Postscript file with preview is produced.
-   //       "pdf" - a PDF file is produced
-   //       "svg" - a SVG file is produced
-   //       "gif" - a GIF file is produced
-   //       "gif+NN" - an animated GIF file is produced, where NN is delay in 10ms units
-   //       "xpm" - a XPM file is produced
-   //       "png" - a PNG file is produced
-   //       "jpg" - a JPEG file is produced
-   //       "tiff" - a TIFF file is produced
-   //       "cxx" - a C++ macro file is produced
-   //       "xml" - a XML file
-   //       "root" - a ROOT binary file
-   
+   /// saves the current picture
+   ///
+   /// use the following combination of file type and save options:
+   /// (see also TCanvas::Print)
+   ///
+   ///       "ps"  - Postscript file is produced (see special cases below)
+   ///    "Portrait" - Postscript file is produced (Portrait)
+   /// "Landscape" - Postscript file is produced (Landscape)
+   ///       "eps" - an Encapsulated Postscript file is produced
+   ///    "Preview" - an Encapsulated Postscript file with preview is produced.
+   ///       "pdf" - a PDF file is produced
+   ///       "svg" - a SVG file is produced
+   ///       "gif" - a GIF file is produced
+   ///       "gif+NN" - an animated GIF file is produced, where NN is delay in 10ms units
+   ///       "xpm" - a XPM file is produced
+   ///       "png" - a PNG file is produced
+   ///       "jpg" - a JPEG file is produced
+   ///       "tiff" - a TIFF file is produced
+   ///       "cxx" - a C++ macro file is produced
+   ///       "xml" - a XML file
+   ///       "root" - a ROOT binary file
+
    const char *kSaveAsTypes[] = {
       "Postscript",  "*.ps",
       "Encapsulated Postscript",   "*.eps",
@@ -2185,11 +2140,10 @@ void AliTPCCalibViewerGUI::SavePicture() {
    
 
 void AliTPCCalibViewerGUI::DoDumpToFile() {
-   // 
-   // This function is called, when the "Dump to File" button is pressed. 
-   // All the exported CalPads will be written into an new CalibTree, 
-   // a Save File dialog will appear to specify the filename
-   // 
+   /// This function is called, when the "Dump to File" button is pressed.
+   /// All the exported CalPads will be written into an new CalibTree,
+   /// a Save File dialog will appear to specify the filename
+
    const char *kSaveAsTypes[] = {
       "ROOT file",   "*.root",
        0,              0
@@ -2208,9 +2162,8 @@ void AliTPCCalibViewerGUI::DoDumpToFile() {
 
 
 void AliTPCCalibViewerGUI::DoLoadTree() {
-   // function to load a new calib tree
-   // 
-   // 
+   /// function to load a new calib tree
+
    const char *kFileTypes[] = {
       "ROOT file",   "*.root",
        0,              0
diff --git a/TPC/TPCbase/AliTPCCalibViewerGUI.h b/TPC/TPCbase/AliTPCCalibViewerGUI.h
index 93dd9385a78..b98d6774183 100644
--- a/TPC/TPCbase/AliTPCCalibViewerGUI.h
+++ b/TPC/TPCbase/AliTPCCalibViewerGUI.h
@@ -6,12 +6,10 @@
 
 /* $Id: AliTPCCalibViewerGUI.h,v */
 
-///////////////////////////////////////////////////////////////////////////////
-//                                                                           //
-//  GUI for the AliTPCCalibViewer                                            //
-//  used for the calibration monitor                                         //
-//                                                                           //
-///////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCCalibViewerGUI
+///
+///  GUI for the AliTPCCalibViewer
+///  used for the calibration monitor
 
 #ifndef ROOT_TGButton
 #include "TGWidget.h"
@@ -100,136 +98,138 @@ public:
    void UnchekAllStat();                     // Disable all statistical legend entries, no statistical legend.
    
 protected:   
-   AliTPCCalibViewer   *fViewer;             // CalibViewer object used for drawing
-   AliTPCPreprocessorOnline *fPreprocessor;  // PreprocessorOnline object, used to collect the exported CalPads and to save them into a new calibTree
+   AliTPCCalibViewer   *fViewer;             ///< CalibViewer object used for drawing
+   AliTPCPreprocessorOnline *fPreprocessor;  ///< PreprocessorOnline object, used to collect the exported CalPads and to save them into a new calibTree
 
-   TGCompositeFrame    *fContTopBottom;      // container for all GUI elements, vertical divided
-   TGCompositeFrame    *fContLCR;            // container for all GUI elements, horizontal divided
-   TGCompositeFrame    *fContLeft;           // container for GUI elements on left side
-   TGTab               *ftabLeft;            // Tabs on the left side for plot options
-   TGCompositeFrame    *ftabLeft0;           // Tab 0 on the left side for general plot options
-   TGCompositeFrame    *ftabLeft1;           // Tab 1 on the left side for 1D plot options
-   TGTab               *ftabRight;           // Tabs on the right side
-   TGCompositeFrame    *fTabRight0;          // Tab 0 on the right side for basic
-   TGCompositeFrame    *fTabRight1;          // Tab 1 on the right side for advanced
-   TGCompositeFrame    *fContRight;          // container for GUI elements on right side
-   TGCompositeFrame    *fContCenter;         // container for GUI elements at the center
-   TGCompositeFrame    *fContPlotOpt;        // container for plot options GUI elements
-   TGCompositeFrame    *fContDrawOpt;        // container for draw options GUI elements
-   TGCompositeFrame    *fContDrawOptSub1D2D; // container for 1D and 2D radio-button
-   TGCompositeFrame    *fContNormalized;     // container for normalization options GUI elements
-   TGCompositeFrame    *fContCustom;         // container for custom draw command GUI elements
-   TGCompositeFrame    *fContCuts;           // container for cut options GUI elements
-   TGCompositeFrame    *fContSector;         // container for sector GUI elements
-   TGCompositeFrame    *fContAddCuts;        // container for additional cut command GUI elements
-   TGCompositeFrame    *fContFit;            // container for fit GUI elements
-   TGCompositeFrame    *fContAddFit;         // container for additional fit GUI elements
-   TGCompositeFrame    *fContScaling;        // container for scaling GUI elements
-   TGCompositeFrame    *fContSetMax;         // container for SetMaximum elements
-   TGCompositeFrame    *fContSetMin;         // container for SetMinimum elements
-   TGCompositeFrame    *fContAddDrawOpt;     // additional draw options container
-   TGListBox           *fListVariables;      // listbox with possible variables
-   TGTextButton        *fBtnDraw;            // draw button
-   TGTextButton        *fBtnFit;             // fit button
-   TGTextButton        *fBtnAddFitFunction;  // button to add fit function to normalization
-   TGTextButton        *fBtnGetMinMax;       // GetMinMax-button
-   TRootEmbeddedCanvas *fCanvMain;           // main drawing canvas
-   TGRadioButton       *fRadioRaw;           // raw radio button
-   TGRadioButton       *fRadioNormalized;    // normalized radio button
-   TGRadioButton       *fRadioPredefined;    // predefined plot radio button
-   TGRadioButton       *fRadioCustom;        // custom radio button
-   TGRadioButton       *fRadio1D;            // 1D radio button
-   TGRadioButton       *fRadio2D;            // 2D radio button
-   TGRadioButton       *fRadioTPC;           // TPC radio button
-   TGRadioButton       *fRadioSideA;         // side A radio button
-   TGRadioButton       *fRadioSideC;         // side C radio button
-   TGRadioButton       *fRadioROC;           // ROC radio button
-   TGRadioButton       *fRadioSector;        // sector radio button
-   TGComboBox          *fComboAddDrawOpt;    // additional draw options combo box
-   TGCheckButton       *fChkAuto;            // automatic redraw checkbox
-   TGCheckButton       *fChkAutoAppend;      // automatic appendign of "~" checkbox
-   TGComboBox          *fComboMethod;        // normalization methods dropdown box
-   TGListBox           *fListNormalization;  // listbox with possible normalization variables
-   TGComboBox          *fComboCustom;        // combo box for custom draw commands
-   TGLabel             *fLblCustomDraw;      // custom draw labal
-   TGCheckButton       *fChkAddDrawOpt;      // additional draw options check box
-   TGNumberEntry       *fNmbSector;          // number entry box for specifying the sector
-   TGLabel             *fLblSector;          // label that shows the active sector
-   TGCheckButton       *fChkCutZero;         // cut zeros check box
-   TGCheckButton       *fChkAddCuts;         // additional cuts check box
-   TGLabel             *fLblAddCuts;         // additional cuts label
-   TGComboBox          *fComboAddCuts;       // additional cuts combo box
-   TGComboBox          *fComboCustomFit;     // custom fit combo box
-   TGCheckButton       *fChkSetMax;          // Set maximum check box
-   TGCheckButton       *fChkSetMin;          // Set maximum check box
-   TGCheckButton       *fChkGetMinMaxAuto;   // Get Min & Max automatically from plot
-   TGTextEntry         *fTxtSetMax;          // custom maximum text box
-   TGTextEntry         *fTxtSetMin;          // custom minimum text box
-   TGGroupFrame        *fContDrawOpt1D;      // container in tabLeft1 
-   TGCompositeFrame    *fcontDrawOpt1DSubLR; // container in tabLeft1 to divide L/R
-   TGCompositeFrame    *fContDrawOpt1DSubNSC; // container in tabLeft1 for following radio buttons 
-   TGRadioButton       *fRadioNorm;          // radio button for normal 1D drawing
-   TGRadioButton       *fRadioSigma;         // radio button for sigma 1D drawing
-   TGTextEntry         *fTxtSigmas;          // text box to specify sigmas
-   TGCompositeFrame    *fContCumuLR;         // container in tabLeft1 for two colums for cumulative and integrative
-   TGCompositeFrame    *fContCumLeft;        // container in tabLeft1 for cumulative, left
-   TGCompositeFrame    *fContCumRight;       // container in tabLeft1 for cumulative, right
-   TGLabel             *fLblSigmaMax;        // label to indicate sigmaMax
-   TGTextEntry         *fTxtSigmaMax;        // text box to specify sigmaMax
-   TGRadioButton       *fRadioCumulative;    // radio button for cumulative 1D drawing
-   TGCheckButton       *fCheckCumulativePM;  // checkbox for plus/minus cumulative 1D drawing
-   TGRadioButton       *fRadioIntegrate;     // radio button for integral 1D drawing
-   TGCompositeFrame    *fContDrawOpt1DSubMML; // container in tabLeft1 for following check boxes
-   TGCheckButton       *fChkMean;            // checkbox to plot mean
-   TGCheckButton       *fChkMedian;          // checkbox to plot median
-   TGCheckButton       *fChkLTM;             // checkbox to plot LTM
-   TGGroupFrame        *fContStatOpt;        // container for statistic options in tabLeft1 
-   TGCheckButton       *fChkStatName;        // checkbox to display histogram name in statistic legend
-   TGCheckButton       *fChkStatEntries;     // checkbox to display entries in statistic legend
-   TGCompositeFrame    *fContStatMean;       // container for mean and its error in stat opt
-   TGCheckButton       *fChkStatMean;        // checkbox to display mean in statistic legend
-   TGCheckButton       *fChkStatMeanPM;      // checkbox to display mean error in statistic legend
-   TGCompositeFrame    *fContStatRMS;        // container for RMS and its error in stat opt
-   TGCheckButton       *fChkStatRMS;         // checkbox to display RMS in statistic legend
-   TGCheckButton       *fChkStatRMSPM;       // checkbox to display RMS error in statistic legend
-   TGCheckButton       *fChkStatUnderflow;   // checkbox to display underflow error in statistic legend
-   TGCheckButton       *fChkStatOverflow;    // checkbox to display overflow error in statistic legend
-   TGCheckButton       *fChkStatIntegral;    // checkbox to display integral in statistic legend
-   TGCompositeFrame    *fContStatSkew;       // container for skewness and its error in stat opt
-   TGCheckButton       *fChkStatSkewness;    // checkbox to display skewness in statistic legend
-   TGCheckButton       *fChkStatSkewnessPM;  // checkbox to display skewness error in statistic legend
-   TGCompositeFrame    *fContStatKurt;       // container for kurtosis and its error in stat opt
-   TGCheckButton       *fChkStatKurtosis;    // checkbox to display kurtosis in statistic legend
-   TGCheckButton       *fChkStatKurtosisPM;  // checkbox to display kurtosis error in statistic legend
-   TGButton            *fBtnUnchekAll;       // Button to uncheck all statistic entries
-   TGGroupFrame        *fContLabeling;       // groupframe container for labeling
-   TGCheckButton       *fChkLabelTitle;      // checkbox to display specified title
-   TGTextEntry         *fTxtLabelTitle;      // text box to specify title
-   TGCheckButton       *fChkLabelXaxis;      // checkbox to display specified xaxis label
-   TGTextEntry         *fTxtLabelXaxis;      // text box to specify xaxis label
-   TGCheckButton       *fChkLabelYaxis;      // checkbox to display specified yaxis label
-   TGTextEntry         *fTxtLabelYaxis;      // text box to specify yaxis label
-   TGCheckButton       *fChkLabelGetAuto;    // checkbox to get labels atuomatically from plot
-   TGGroupFrame        *fContSave;           // container for save-button
-   TGButton            *fBtnSave;            // Save button
-   TGCompositeFrame    *fContAddSaveOpt;     // container for additional save options
-   TGCheckButton       *fChkAddSaveOpt;      // checkbox for additional save options
-   TGComboBox          *fComboAddSaveOpt;    // combobox for additional save options
-   TGGroupFrame        *fContExport;         // container for cint-export
-   TGCompositeFrame    *fContAddExport;      // container for dropdown list to enter export name
-   TGComboBox          *fComboExportName;    // dropdownbox to enter a name for the exported CalPad
-   TGTextButton        *fBtnExport;          // button to export a CalPad
-   TGTextButton        *fBtnAddNorm;         // button to add a CalPad to the normalization
-   TGCompositeFrame    *fContTree;           // container for tree functions
-   TGTextButton        *fBtnDumpToFile;      // button to dump a new CalibTree to file
-   TGTextButton        *fBtnLoadTree;        // button to load a new tree
-   TGCheckButton       *fChkAddAsReference;  // checkbox to add a new tree as referenceTree
-   TGTextEntry         *fTxtRefName;         // text box to specify the referenceTree's name
+   TGCompositeFrame    *fContTopBottom;      ///< container for all GUI elements, vertical divided
+   TGCompositeFrame    *fContLCR;            ///< container for all GUI elements, horizontal divided
+   TGCompositeFrame    *fContLeft;           ///< container for GUI elements on left side
+   TGTab               *ftabLeft;            ///< Tabs on the left side for plot options
+   TGCompositeFrame    *ftabLeft0;           ///< Tab 0 on the left side for general plot options
+   TGCompositeFrame    *ftabLeft1;           ///< Tab 1 on the left side for 1D plot options
+   TGTab               *ftabRight;           ///< Tabs on the right side
+   TGCompositeFrame    *fTabRight0;          ///< Tab 0 on the right side for basic
+   TGCompositeFrame    *fTabRight1;          ///< Tab 1 on the right side for advanced
+   TGCompositeFrame    *fContRight;          ///< container for GUI elements on right side
+   TGCompositeFrame    *fContCenter;         ///< container for GUI elements at the center
+   TGCompositeFrame    *fContPlotOpt;        ///< container for plot options GUI elements
+   TGCompositeFrame    *fContDrawOpt;        ///< container for draw options GUI elements
+   TGCompositeFrame    *fContDrawOptSub1D2D; ///< container for 1D and 2D radio-button
+   TGCompositeFrame    *fContNormalized;     ///< container for normalization options GUI elements
+   TGCompositeFrame    *fContCustom;         ///< container for custom draw command GUI elements
+   TGCompositeFrame    *fContCuts;           ///< container for cut options GUI elements
+   TGCompositeFrame    *fContSector;         ///< container for sector GUI elements
+   TGCompositeFrame    *fContAddCuts;        ///< container for additional cut command GUI elements
+   TGCompositeFrame    *fContFit;            ///< container for fit GUI elements
+   TGCompositeFrame    *fContAddFit;         ///< container for additional fit GUI elements
+   TGCompositeFrame    *fContScaling;        ///< container for scaling GUI elements
+   TGCompositeFrame    *fContSetMax;         ///< container for SetMaximum elements
+   TGCompositeFrame    *fContSetMin;         ///< container for SetMinimum elements
+   TGCompositeFrame    *fContAddDrawOpt;     ///< additional draw options container
+   TGListBox           *fListVariables;      ///< listbox with possible variables
+   TGTextButton        *fBtnDraw;            ///< draw button
+   TGTextButton        *fBtnFit;             ///< fit button
+   TGTextButton        *fBtnAddFitFunction;  ///< button to add fit function to normalization
+   TGTextButton        *fBtnGetMinMax;       ///< GetMinMax-button
+   TRootEmbeddedCanvas *fCanvMain;           ///< main drawing canvas
+   TGRadioButton       *fRadioRaw;           ///< raw radio button
+   TGRadioButton       *fRadioNormalized;    ///< normalized radio button
+   TGRadioButton       *fRadioPredefined;    ///< predefined plot radio button
+   TGRadioButton       *fRadioCustom;        ///< custom radio button
+   TGRadioButton       *fRadio1D;            ///< 1D radio button
+   TGRadioButton       *fRadio2D;            ///< 2D radio button
+   TGRadioButton       *fRadioTPC;           ///< TPC radio button
+   TGRadioButton       *fRadioSideA;         ///< side A radio button
+   TGRadioButton       *fRadioSideC;         ///< side C radio button
+   TGRadioButton       *fRadioROC;           ///< ROC radio button
+   TGRadioButton       *fRadioSector;        ///< sector radio button
+   TGComboBox          *fComboAddDrawOpt;    ///< additional draw options combo box
+   TGCheckButton       *fChkAuto;            ///< automatic redraw checkbox
+   TGCheckButton       *fChkAutoAppend;      ///< automatic appendign of "~" checkbox
+   TGComboBox          *fComboMethod;        ///< normalization methods dropdown box
+   TGListBox           *fListNormalization;  ///< listbox with possible normalization variables
+   TGComboBox          *fComboCustom;        ///< combo box for custom draw commands
+   TGLabel             *fLblCustomDraw;      ///< custom draw labal
+   TGCheckButton       *fChkAddDrawOpt;      ///< additional draw options check box
+   TGNumberEntry       *fNmbSector;          ///< number entry box for specifying the sector
+   TGLabel             *fLblSector;          ///< label that shows the active sector
+   TGCheckButton       *fChkCutZero;         ///< cut zeros check box
+   TGCheckButton       *fChkAddCuts;         ///< additional cuts check box
+   TGLabel             *fLblAddCuts;         ///< additional cuts label
+   TGComboBox          *fComboAddCuts;       ///< additional cuts combo box
+   TGComboBox          *fComboCustomFit;     ///< custom fit combo box
+   TGCheckButton       *fChkSetMax;          ///< Set maximum check box
+   TGCheckButton       *fChkSetMin;          ///< Set maximum check box
+   TGCheckButton       *fChkGetMinMaxAuto;   ///< Get Min & Max automatically from plot
+   TGTextEntry         *fTxtSetMax;          ///< custom maximum text box
+   TGTextEntry         *fTxtSetMin;          ///< custom minimum text box
+   TGGroupFrame        *fContDrawOpt1D;      ///< container in tabLeft1
+   TGCompositeFrame    *fcontDrawOpt1DSubLR; ///< container in tabLeft1 to divide L/R
+   TGCompositeFrame    *fContDrawOpt1DSubNSC; ///< container in tabLeft1 for following radio buttons
+   TGRadioButton       *fRadioNorm;          ///< radio button for normal 1D drawing
+   TGRadioButton       *fRadioSigma;         ///< radio button for sigma 1D drawing
+   TGTextEntry         *fTxtSigmas;          ///< text box to specify sigmas
+   TGCompositeFrame    *fContCumuLR;         ///< container in tabLeft1 for two colums for cumulative and integrative
+   TGCompositeFrame    *fContCumLeft;        ///< container in tabLeft1 for cumulative, left
+   TGCompositeFrame    *fContCumRight;       ///< container in tabLeft1 for cumulative, right
+   TGLabel             *fLblSigmaMax;        ///< label to indicate sigmaMax
+   TGTextEntry         *fTxtSigmaMax;        ///< text box to specify sigmaMax
+   TGRadioButton       *fRadioCumulative;    ///< radio button for cumulative 1D drawing
+   TGCheckButton       *fCheckCumulativePM;  ///< checkbox for plus/minus cumulative 1D drawing
+   TGRadioButton       *fRadioIntegrate;     ///< radio button for integral 1D drawing
+   TGCompositeFrame    *fContDrawOpt1DSubMML; ///< container in tabLeft1 for following check boxes
+   TGCheckButton       *fChkMean;            ///< checkbox to plot mean
+   TGCheckButton       *fChkMedian;          ///< checkbox to plot median
+   TGCheckButton       *fChkLTM;             ///< checkbox to plot LTM
+   TGGroupFrame        *fContStatOpt;        ///< container for statistic options in tabLeft1
+   TGCheckButton       *fChkStatName;        ///< checkbox to display histogram name in statistic legend
+   TGCheckButton       *fChkStatEntries;     ///< checkbox to display entries in statistic legend
+   TGCompositeFrame    *fContStatMean;       ///< container for mean and its error in stat opt
+   TGCheckButton       *fChkStatMean;        ///< checkbox to display mean in statistic legend
+   TGCheckButton       *fChkStatMeanPM;      ///< checkbox to display mean error in statistic legend
+   TGCompositeFrame    *fContStatRMS;        ///< container for RMS and its error in stat opt
+   TGCheckButton       *fChkStatRMS;         ///< checkbox to display RMS in statistic legend
+   TGCheckButton       *fChkStatRMSPM;       ///< checkbox to display RMS error in statistic legend
+   TGCheckButton       *fChkStatUnderflow;   ///< checkbox to display underflow error in statistic legend
+   TGCheckButton       *fChkStatOverflow;    ///< checkbox to display overflow error in statistic legend
+   TGCheckButton       *fChkStatIntegral;    ///< checkbox to display integral in statistic legend
+   TGCompositeFrame    *fContStatSkew;       ///< container for skewness and its error in stat opt
+   TGCheckButton       *fChkStatSkewness;    ///< checkbox to display skewness in statistic legend
+   TGCheckButton       *fChkStatSkewnessPM;  ///< checkbox to display skewness error in statistic legend
+   TGCompositeFrame    *fContStatKurt;       ///< container for kurtosis and its error in stat opt
+   TGCheckButton       *fChkStatKurtosis;    ///< checkbox to display kurtosis in statistic legend
+   TGCheckButton       *fChkStatKurtosisPM;  ///< checkbox to display kurtosis error in statistic legend
+   TGButton            *fBtnUnchekAll;       ///< Button to uncheck all statistic entries
+   TGGroupFrame        *fContLabeling;       ///< groupframe container for labeling
+   TGCheckButton       *fChkLabelTitle;      ///< checkbox to display specified title
+   TGTextEntry         *fTxtLabelTitle;      ///< text box to specify title
+   TGCheckButton       *fChkLabelXaxis;      ///< checkbox to display specified xaxis label
+   TGTextEntry         *fTxtLabelXaxis;      ///< text box to specify xaxis label
+   TGCheckButton       *fChkLabelYaxis;      ///< checkbox to display specified yaxis label
+   TGTextEntry         *fTxtLabelYaxis;      ///< text box to specify yaxis label
+   TGCheckButton       *fChkLabelGetAuto;    ///< checkbox to get labels atuomatically from plot
+   TGGroupFrame        *fContSave;           ///< container for save-button
+   TGButton            *fBtnSave;            ///< Save button
+   TGCompositeFrame    *fContAddSaveOpt;     ///< container for additional save options
+   TGCheckButton       *fChkAddSaveOpt;      ///< checkbox for additional save options
+   TGComboBox          *fComboAddSaveOpt;    ///< combobox for additional save options
+   TGGroupFrame        *fContExport;         ///< container for cint-export
+   TGCompositeFrame    *fContAddExport;      ///< container for dropdown list to enter export name
+   TGComboBox          *fComboExportName;    ///< dropdownbox to enter a name for the exported CalPad
+   TGTextButton        *fBtnExport;          ///< button to export a CalPad
+   TGTextButton        *fBtnAddNorm;         ///< button to add a CalPad to the normalization
+   TGCompositeFrame    *fContTree;           ///< container for tree functions
+   TGTextButton        *fBtnDumpToFile;      ///< button to dump a new CalibTree to file
+   TGTextButton        *fBtnLoadTree;        ///< button to load a new tree
+   TGCheckButton       *fChkAddAsReference;  ///< checkbox to add a new tree as referenceTree
+   TGTextEntry         *fTxtRefName;         ///< text box to specify the referenceTree's name
    
    private:
-   Bool_t fInitialized;                      // has the GUI already been initialized?
+   Bool_t fInitialized;                      ///< has the GUI already been initialized?
    
+   /// \cond CLASSIMP
    ClassDef(AliTPCCalibViewerGUI, 0)
+   /// \endcond
 };
 
 #endif
diff --git a/TPC/TPCbase/AliTPCCalibViewerGUItime.cxx b/TPC/TPCbase/AliTPCCalibViewerGUItime.cxx
index 9ff9b906568..56b60cec2e4 100644
--- a/TPC/TPCbase/AliTPCCalibViewerGUItime.cxx
+++ b/TPC/TPCbase/AliTPCCalibViewerGUItime.cxx
@@ -14,10 +14,7 @@
  **************************************************************************/
 
 
-///////////////////////////////////////////////////////////////////////////////
-//                                                                           //
-//                                                                           //
-///////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCCalibViewerGUItime
 
 
 #include <iostream>
@@ -155,22 +152,18 @@ TGCompositeFrame(p,w,h),
 }
 //______________________________________________________________________________
 AliTPCCalibViewerGUItime::~AliTPCCalibViewerGUItime(){
-  //
-  // dtor
-  //
+  /// dtor
+
   delete fConfigParser;
   delete fTrashBox;
   delete fMapRefTrees;
 }
 //______________________________________________________________________________
 void AliTPCCalibViewerGUItime::DrawGUI(const TGWindow */*p*/, UInt_t w, UInt_t h) {
-   //
-   // draw the GUI
-   //
-   // ======================================================================
-   // ************************* Display everything *************************
-   // ======================================================================
-  
+   /// draw the GUI
+   ///
+   /// ************************* Display everything *************************
+
   SetCleanup(kDeepCleanup);
   
    // *****************************************************************************
@@ -449,18 +442,16 @@ void AliTPCCalibViewerGUItime::DrawGUI(const TGWindow */*p*/, UInt_t w, UInt_t h
 }
 //______________________________________________________________________________
 void AliTPCCalibViewerGUItime::SetInitialValues(){
-  //
-  // Set inital selections of the gui
-  //
+  /// Set inital selections of the gui
+
   fRadioXrun->SetState(kButtonDown);
   fRadioXtime->SetState(kButtonUp);
 }
 
 //______________________________________________________________________________
 void AliTPCCalibViewerGUItime::UseFile(const char* fileName, const char* treeName) {
-  //
-  // retrieve tree from file
-  //
+  /// retrieve tree from file
+
   TObjArray *arr=0x0;
   TString file(fileName);
   if (file.Contains("://")) {
@@ -493,9 +484,8 @@ void AliTPCCalibViewerGUItime::UseFile(const char* fileName, const char* treeNam
 //______________________________________________________________________________
 void AliTPCCalibViewerGUItime::UseChain(TChain *const chain  = 0)
 {
-  //
-  //
-  //
+  ///
+
   fTree=chain;
   if (!CheckChain()) return;
   //set configuration file
@@ -505,10 +495,9 @@ void AliTPCCalibViewerGUItime::UseChain(TChain *const chain  = 0)
 //______________________________________________________________________________
 Bool_t AliTPCCalibViewerGUItime::CheckChain()
 {
-  //
-  // check whether cahin has entries
-  // decide whether to draw graphs in 2D
-  //
+  /// check whether cahin has entries
+  /// decide whether to draw graphs in 2D
+
   if (!fTree) return kFALSE;
   fTree->Lookup();
   Long64_t entries=fTree->GetEntries();
@@ -523,9 +512,8 @@ Bool_t AliTPCCalibViewerGUItime::CheckChain()
 //______________________________________________________________________________
 void AliTPCCalibViewerGUItime::UseConfigFile(const char* file)
 {
-  //
-  // Use 'file' as configuration file
-  //
+  /// Use 'file' as configuration file
+
   fConfigFile=file;
   fConfigParser->ParseConfigFileTxt(fConfigFile.Data());
   FillCalibTypes();
@@ -533,9 +521,8 @@ void AliTPCCalibViewerGUItime::UseConfigFile(const char* file)
 //______________________________________________________________________________
 void AliTPCCalibViewerGUItime::FillRunTypes()
 {
-  //
-  //Loop over the tree entries and fill the run types
-  //
+  /// Loop over the tree entries and fill the run types
+
   if (!fTree) return;
   Int_t id=0;
   fComboRunType->RemoveAll();
@@ -558,9 +545,8 @@ void AliTPCCalibViewerGUItime::FillRunTypes()
 //______________________________________________________________________________
 void AliTPCCalibViewerGUItime::FillCalibTypes()
 {
-  //
-  // loop over configuration and fill calibration types
-  //
+  /// loop over configuration and fill calibration types
+
   Int_t id=0;
   fListCalibType->RemoveAll();
   TObject *o=0x0;
@@ -588,10 +574,9 @@ void AliTPCCalibViewerGUItime::FillCalibTypes()
 //______________________________________________________________________________
 void AliTPCCalibViewerGUItime::CheckDrawGraph()
 {
-  //
-  // Check whether to draw graphs in 2D mode based on the number of entries in the chain
-  // GetEstimate() returns the maximum size of the arrays stored in GetV1()...
-  //
+  /// Check whether to draw graphs in 2D mode based on the number of entries in the chain
+  /// GetEstimate() returns the maximum size of the arrays stored in GetV1()...
+
   if (!fTree) return;
   fNoGraph=kTRUE;
   if (fTree->GetEntries()<fTree->GetEstimate()) fNoGraph=kFALSE;
@@ -599,9 +584,7 @@ void AliTPCCalibViewerGUItime::CheckDrawGraph()
 //______________________________________________________________________________
 void AliTPCCalibViewerGUItime::Reload(Int_t first)
 {
-  //
-  // reload the gui contents, this is needed after the input tree has changed
-  //
+  /// reload the gui contents, this is needed after the input tree has changed
 
   if ( !fTree ) return;
   //in case of the first call create run type and calibration type entries
@@ -669,18 +652,15 @@ void AliTPCCalibViewerGUItime::Reload(Int_t first)
 //______________________________________________________________________________
 void AliTPCCalibViewerGUItime::AddReferenceTree(const char* treeFileName, const char* refName)
 {
-  //
-  // map of reference trees that should always be attached to the CalibViewerGUI
-  //
+  /// map of reference trees that should always be attached to the CalibViewerGUI
+
   fMapRefTrees->Add(new TObjString(refName), new TObjString(treeFileName));
 
 }
 //______________________________________________________________________________
 const TString AliTPCCalibViewerGUItime::GetDrawString(){
-  //
-  // create draw string for ttree by combining the user requestsa
-  //
-  
+  /// create draw string for ttree by combining the user requestsa
+
   TString selectedVariable="";
   Int_t id=-1;
   if (!fListVariables->GetSelectedEntry()) return "";
@@ -706,9 +686,8 @@ const TString AliTPCCalibViewerGUItime::GetDrawString(){
 }
 //______________________________________________________________________________
 const TString AliTPCCalibViewerGUItime::GetDrawOptionString(){
-  //
-  // get user selected draw options
-  //
+  /// get user selected draw options
+
   TString drawOpt;
   if (fComboAddDrawOpt->GetSelectedEntry()) drawOpt=fComboAddDrawOpt->GetSelectedEntry()->GetTitle();
   if (fChkDrawOptSame->GetState()==kButtonDown && !drawOpt.Contains("same",TString::kIgnoreCase))
@@ -717,9 +696,8 @@ const TString AliTPCCalibViewerGUItime::GetDrawOptionString(){
 }
 //______________________________________________________________________________
 void AliTPCCalibViewerGUItime::GetCutString(TString &cutStr){
-  //
-  // create cut string
-  //
+  /// create cut string
+
   TCut cuts(fComboCustomCuts->GetTextEntry()->GetText());
   TString runType="";
   if (fComboRunType->GetSelectedEntry()) runType=fComboRunType->GetSelectedEntry()->GetTitle();
@@ -729,9 +707,8 @@ void AliTPCCalibViewerGUItime::GetCutString(TString &cutStr){
 //______________________________________________________________________________
 void AliTPCCalibViewerGUItime::UpdateValueArrays(Bool_t withGraph, const Double_t *xArr)
 {
-  //
-  //
-  //
+  ///
+
   if (!withGraph){
     fValuesX.ResizeTo(1);
     fValuesY.ResizeTo(1);
@@ -794,9 +771,7 @@ void AliTPCCalibViewerGUItime::UpdateValueArrays(Bool_t withGraph, const Double_
 //______________________________________________________________________________
 void AliTPCCalibViewerGUItime::GetHistogramTitle(TString &title)
 {
-  //
-  // Create string for histogram title
-  //
+  /// Create string for histogram title
 
   title=fDrawString;
   Int_t pos=title.First(">>");
@@ -856,9 +831,8 @@ void AliTPCCalibViewerGUItime::GetHistogramTitle(TString &title)
 //______________________________________________________________________________
 void AliTPCCalibViewerGUItime::AdjustYRange()
 {
-  //
-  //
-  //
+  ///
+
   TIter nextGraphicObject(fTrashBox);
   TObject *o=0x0;
   Float_t min=1,max=0;
@@ -885,9 +859,8 @@ void AliTPCCalibViewerGUItime::AdjustYRange()
 }
 //______________________________________________________________________________
 void AliTPCCalibViewerGUItime::DoDraw() {
-  //
-  // Draw graphics
-  //
+  /// Draw graphics
+
   TString drawString=fDrawString;
   TString cutString;
   GetCutString(cutString);
@@ -1030,9 +1003,8 @@ void AliTPCCalibViewerGUItime::DoDraw() {
 //______________________________________________________________________________
 void AliTPCCalibViewerGUItime::DoDumpRuns()
 {
-  //
-  // Dump the current run numbers to stdout
-  //
+  /// Dump the current run numbers to stdout
+
   Int_t npoints=fRunNumbers.GetNrows();
   Int_t    *sortIndex = new Int_t[npoints];
   TMath::Sort(npoints,fRunNumbers.GetMatrixArray(),sortIndex,kFALSE);
@@ -1048,17 +1020,15 @@ void AliTPCCalibViewerGUItime::DoDumpRuns()
 //______________________________________________________________________________
 void AliTPCCalibViewerGUItime::DoParLimitChange()
 {
-  //
-  //
-  //
+  ///
+
   UpdateParName();
   DoDraw();
 }
 //______________________________________________________________________________
 void AliTPCCalibViewerGUItime::DoNewSelection() {
-   //
-   // decides whether to redraw if user makes another selection
-   //
+   /// decides whether to redraw if user makes another selection
+
   UpdateParLimits();
   fDrawString=GetDrawString();
   fIsCustomDraw=kFALSE;
@@ -1067,9 +1037,8 @@ void AliTPCCalibViewerGUItime::DoNewSelection() {
 //______________________________________________________________________________
 void AliTPCCalibViewerGUItime::DoCustomDraw()
 {
-  //
-  //
-  //
+  ///
+
   fDrawString=fComboCustomDraw->GetTextEntry()->GetText();
 //   if (fDrawString.Contains(">>")){
 //     Warning("DoCustomDraw","Currently no user defined histograms allowed!");
@@ -1082,9 +1051,8 @@ void AliTPCCalibViewerGUItime::DoCustomDraw()
 //______________________________________________________________________________
 void AliTPCCalibViewerGUItime::DoCustomCutsDraw()
 {
-  //
-  //
-  //
+  ///
+
   if (fIsCustomDraw) DoCustomDraw();
   else {
     fDrawString=GetDrawString();
@@ -1095,9 +1063,7 @@ void AliTPCCalibViewerGUItime::DoCustomCutsDraw()
 //______________________________________________________________________________
 void AliTPCCalibViewerGUItime::HandleButtonsDrawSel(Int_t id)
 {
-  //
-  // Draw selection button handling (x-variable)
-  //
+  /// Draw selection button handling (x-variable)
 
   if (id == -1) {
     TGButton *btn = (TGButton *) gTQSender;
@@ -1141,10 +1107,8 @@ void AliTPCCalibViewerGUItime::HandleButtonsDrawSel(Int_t id)
 //______________________________________________________________________________
 void AliTPCCalibViewerGUItime::UpdateParName()
 {
-  //
-  // change parameter name
-  //
-  
+  /// change parameter name
+
   Int_t par = (Int_t)(fNmbPar->GetNumber());
   TString parName="";
   Int_t id=fListVariables->GetSelectedEntry()->EntryId();
@@ -1158,9 +1122,8 @@ void AliTPCCalibViewerGUItime::UpdateParName()
 //______________________________________________________________________________
 void AliTPCCalibViewerGUItime::UpdateParLimits()
 {
-  //
-  // Adjust limits for TVectorT based variables
-  //
+  /// Adjust limits for TVectorT based variables
+
   if (!fTree) return;
   TString selectedVariableTitle="";
   Int_t id=-1;
@@ -1213,9 +1176,8 @@ void AliTPCCalibViewerGUItime::UpdateParLimits()
 //______________________________________________________________________________
 void AliTPCCalibViewerGUItime::MouseMove(Int_t event, Int_t x, Int_t y, TObject */*selected*/)
 {
-  //
-  // handle mouse events in the draw canvas
-  //
+  /// handle mouse events in the draw canvas
+
   UInt_t dd=0,mm=0,yy=0,HH=0,MM=0,SS=0,run=0;
   Double_t valx=0.,valy=0.;
   if (!fCurrentGraph) {
@@ -1276,11 +1238,9 @@ void AliTPCCalibViewerGUItime::MouseMove(Int_t event, Int_t x, Int_t y, TObject
 //______________________________________________________________________________
 void AliTPCCalibViewerGUItime::SetGuiTree(Int_t run)
 {
-  //
-  // create the AliTPCCalibViewerGUI tree for run
-  // cache tree in directory fOutputCacheDir
-  // retrieve file from this directory if it already exists
-  //
+  /// create the AliTPCCalibViewerGUI tree for run
+  /// cache tree in directory fOutputCacheDir
+  /// retrieve file from this directory if it already exists
 
   //
   //Create and set GUI tree  
@@ -1331,9 +1291,8 @@ void AliTPCCalibViewerGUItime::SetGuiTree(Int_t run)
 //______________________________________________________________________________
 void AliTPCCalibViewerGUItime::SubstituteUnderscores(TString &s)
 {
-  //
-  //
-  //
+  ///
+
   s.ReplaceAll("_{","|{");
   s.ReplaceAll("_"," ");
   s.ReplaceAll("|{","_{");
@@ -1342,9 +1301,8 @@ void AliTPCCalibViewerGUItime::SubstituteUnderscores(TString &s)
 //______________________________________________________________________________
 void AliTPCCalibViewerGUItime::DoNewSelectionAliases()
 {
-  //
-  //
-  //
+  ///
+
   if (!fTree) return;
   TList *l=fTree->GetListOfAliases();
   if (!l) return;
@@ -1358,17 +1316,15 @@ void AliTPCCalibViewerGUItime::DoNewSelectionAliases()
 //______________________________________________________________________________
 void AliTPCCalibViewerGUItime::DoAddAlias()
 {
-  //
-  //
-  //
+  ///
+
   new AliTPCCalibViewerGUItimeAddAliasFrame(gClient->GetRoot(), fContTopBottom, 400, 200, kVerticalFrame, this);
 }
 //______________________________________________________________________________
 void AliTPCCalibViewerGUItime::DoDelAlias()
 {
-  //
-  //
-  //
+  ///
+
   if (!fTree) return;
   TList *l=fTree->GetListOfAliases();
   if (!l) return;
@@ -1382,9 +1338,8 @@ void AliTPCCalibViewerGUItime::DoDelAlias()
 //______________________________________________________________________________
 void AliTPCCalibViewerGUItime::UpdateAliasList()
 {
-  //
-  //
-  //
+  ///
+
   printf("UpdateAliasList\n");
   if (!fTree) return;
   TList *l=fTree->GetListOfAliases();
@@ -1401,10 +1356,9 @@ void AliTPCCalibViewerGUItime::UpdateAliasList()
 }
 //______________________________________________________________________________
 TObjArray* AliTPCCalibViewerGUItime::ShowGUI(const char* fileName, const char* treeName) {
-   //
-   // Initialize and show GUI for presentation for demonstration purposes
-   // or for fast standalone use
-   //
+   /// Initialize and show GUI for presentation for demonstration purposes
+   /// or for fast standalone use
+
   TGMainFrame* frmMain = new TGMainFrame(gClient->GetRoot(), 1000, 600);
   frmMain->SetWindowName("AliTPCCalibViewer GUItime");
   frmMain->SetCleanup(kDeepCleanup);
@@ -1439,10 +1393,9 @@ TObjArray* AliTPCCalibViewerGUItime::ShowGUI(const char* fileName, const char* t
 
 //______________________________________________________________________________
 TObjArray* AliTPCCalibViewerGUItime::ShowGUI(TChain *chain) {
-   //
-   // Initialize and show GUI for presentation for demonstration purposes
-   // or for fast standalone use
-   //
+   /// Initialize and show GUI for presentation for demonstration purposes
+   /// or for fast standalone use
+
   TGMainFrame* frmMain = new TGMainFrame(gClient->GetRoot(), 1000, 600);
   frmMain->SetWindowName("AliTPCCalibViewer GUItime");
   frmMain->SetCleanup(kDeepCleanup);
@@ -1474,7 +1427,9 @@ TObjArray* AliTPCCalibViewerGUItime::ShowGUI(TChain *chain) {
 ////////////////////////////////////////////////////////////////////////
 
 
+/// \cond CLASSIMP
 ClassImp(AliTPCCalibViewerGUItimeAddAliasFrame)
+/// \endcond
 
 AliTPCCalibViewerGUItimeAddAliasFrame::AliTPCCalibViewerGUItimeAddAliasFrame(const TGWindow *p, const TGWindow *main,
                                                                              UInt_t w, UInt_t h, UInt_t options,
@@ -1566,17 +1521,15 @@ AliTPCCalibViewerGUItimeAddAliasFrame::AliTPCCalibViewerGUItimeAddAliasFrame(con
 //______________________________________________________________________________
 AliTPCCalibViewerGUItimeAddAliasFrame::~AliTPCCalibViewerGUItimeAddAliasFrame()
 {
-  //
-  //
-  //
+  ///
+
   fMain->DeleteWindow();  // deletes fMain
 }
 //______________________________________________________________________________
 void AliTPCCalibViewerGUItimeAddAliasFrame::DoOK()
 {
-  //
-  //
-  //
+  ///
+
   TString aliasName=fTxt1->GetText();
   TString alias=fTxt2->GetText();
   if (!aliasName.IsNull()&&!alias.IsNull()){
@@ -1591,9 +1544,8 @@ void AliTPCCalibViewerGUItimeAddAliasFrame::DoOK()
 //______________________________________________________________________________
 void AliTPCCalibViewerGUItimeAddAliasFrame::DoCancel()
 {
-  //
-  //
-  //
+  ///
+
   delete this;
 }
 
diff --git a/TPC/TPCbase/AliTPCCalibViewerGUItime.h b/TPC/TPCbase/AliTPCCalibViewerGUItime.h
index c18baa9ffdb..6926b3cb64e 100644
--- a/TPC/TPCbase/AliTPCCalibViewerGUItime.h
+++ b/TPC/TPCbase/AliTPCCalibViewerGUItime.h
@@ -4,15 +4,11 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-/* $Id: AliTPCCalibViewerGUI.h,v */
-
-///////////////////////////////////////////////////////////////////////////////
-//                                                                           //
-//  GUI for displaying calibration entires over time                         //
-//  Calibration Trees are created using the macro TPC/CalibMacros/CalibEnv.C //
-//  used for the calibration monitor                                         //
-//                                                                           //
-///////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCCalibViewerGUItime
+///
+/// \brief GUI for displaying calibration entires over time
+///  Calibration Trees are created using the macro TPC/CalibMacros/CalibEnv.C
+///  used for the calibration monitor
 
 
 #ifndef ROOT_TGButton
@@ -96,76 +92,76 @@ public:
   void UpdateAliasList();
   TCanvas * GetCanvas(){ return fCanvMain->GetCanvas();}
  private:
-  TFile*  fFile;                          //file that keeps the tree
-  TChain*  fTree;                         //internal tree
-  AliTPCCalibViewerGUI *fCalibViewerGUI;  //calib viewer gui used to display verbose information for one run
-  TGTabElement *fCalibViewerGUItab;       //tab the calib view gui redies in
-  TH1*    fCurrentHist;                   //histogram currently drawn in main canvas
-  TGraph* fCurrentGraph;                  //current graph
-  Int_t   fCurrentRunDetails;             //run number for wich details are currently shown
-  TString fOutputCacheDir;                //output cache diretory for AliTPCCalibViewerGUI trees, created on the fly
-  TString fDrawString;                    //current draw string
-  TString fConfigFile;                    //configuration file keeping active branches and branch descriptions
-  AliTPCConfigParser *fConfigParser;      //configuration parser
-  Bool_t  fIsCustomDraw;                  //if custom draw string is selected
-  TVectorD fRunNumbers;                   //run numbers of current selection
-  TVectorD fTimeStamps;                   //timr stamps of current selection
-  TVectorD fValuesX;                      //values of current selection
-  TVectorD fValuesY;                      //values of current selection
+  TFile*  fFile;                          ///< file that keeps the tree
+  TChain*  fTree;                         ///< internal tree
+  AliTPCCalibViewerGUI *fCalibViewerGUI;  ///< calib viewer gui used to display verbose information for one run
+  TGTabElement *fCalibViewerGUItab;       ///< tab the calib view gui redies in
+  TH1*    fCurrentHist;                   ///< histogram currently drawn in main canvas
+  TGraph* fCurrentGraph;                  ///< current graph
+  Int_t   fCurrentRunDetails;             ///< run number for wich details are currently shown
+  TString fOutputCacheDir;                ///< output cache diretory for AliTPCCalibViewerGUI trees, created on the fly
+  TString fDrawString;                    ///< current draw string
+  TString fConfigFile;                    ///< configuration file keeping active branches and branch descriptions
+  AliTPCConfigParser *fConfigParser;      ///< configuration parser
+  Bool_t  fIsCustomDraw;                  ///< if custom draw string is selected
+  TVectorD fRunNumbers;                   ///< run numbers of current selection
+  TVectorD fTimeStamps;                   ///< timr stamps of current selection
+  TVectorD fValuesX;                      ///< values of current selection
+  TVectorD fValuesY;                      ///< values of current selection
   //
-  Bool_t  fNoGraph;                       //Whether to create a graph
-  Long64_t fGraphLimitEntries;            //limit in number of entries in the chain for producing a graph
+  Bool_t  fNoGraph;                       ///< Whether to create a graph
+  Long64_t fGraphLimitEntries;            ///< limit in number of entries in the chain for producing a graph
   //
-  TMap *fMapRefTrees;                      //map of reference trees for the CalibViewer
+  TMap *fMapRefTrees;                      ///< map of reference trees for the CalibViewer
   //GUI elements
   //main canvas Top part, bottom part
-  TGCompositeFrame    *fContTopBottom;      // container for all GUI elements, vertical divided
+  TGCompositeFrame    *fContTopBottom;      ///< container for all GUI elements, vertical divided
   //top left, centre, right
-  TGCompositeFrame    *fContLCR;            // container for all GUI elements, horizontal divided
+  TGCompositeFrame    *fContLCR;            ///< container for all GUI elements, horizontal divided
   //content left
-  TGCompositeFrame    *fContLeft;           // container for GUI elements on left side
-  TGGroupFrame        *fContDrawOpt;        // Subgroup for draw selection
-  TGCheckButton       *fChkDrawOptSame;     // draw option 'same'
-  TGCheckButton       *fChkDrawOptSparse;   // draw option 'sparse'
-  TGComboBox          *fComboAddDrawOpt;    // additional draw options combo box
-  TGGroupFrame        *fContDrawSel;        // Subgroup for draw selection
-  TGCompositeFrame    *fContDrawSelSubRunTime; //Radio button subframe
-  TGRadioButton       *fRadioXhist;         // Radio button x-variable: show only 1D distribution
-  TGRadioButton       *fRadioXrun;          // Radio button x-variable: run
-  TGRadioButton       *fRadioXtime;         // Radio button x-variable: time
-  TGListBox           *fListVariables;      // listbox with possible variables
-  TGComboBox          *fComboRunType;       // run type selection box
-  TGLabel             *fLblRunType;         // run type label
-  TGNumberEntry       *fNmbPar;             // parameter number
-  TGLabel             *fLblPar;             // parameter name
-  TGListBox           *fListCalibType;      // calibration type selection box
-  TGGroupFrame        *fContCalibType;      // calibration type label
+  TGCompositeFrame    *fContLeft;           ///< container for GUI elements on left side
+  TGGroupFrame        *fContDrawOpt;        ///< Subgroup for draw selection
+  TGCheckButton       *fChkDrawOptSame;     ///< draw option 'same'
+  TGCheckButton       *fChkDrawOptSparse;   ///< draw option 'sparse'
+  TGComboBox          *fComboAddDrawOpt;    ///< additional draw options combo box
+  TGGroupFrame        *fContDrawSel;        ///< Subgroup for draw selection
+  TGCompositeFrame    *fContDrawSelSubRunTime; ///< Radio button subframe
+  TGRadioButton       *fRadioXhist;         ///< Radio button x-variable: show only 1D distribution
+  TGRadioButton       *fRadioXrun;          ///< Radio button x-variable: run
+  TGRadioButton       *fRadioXtime;         ///< Radio button x-variable: time
+  TGListBox           *fListVariables;      ///< listbox with possible variables
+  TGComboBox          *fComboRunType;       ///< run type selection box
+  TGLabel             *fLblRunType;         ///< run type label
+  TGNumberEntry       *fNmbPar;             ///< parameter number
+  TGLabel             *fLblPar;             ///< parameter name
+  TGListBox           *fListCalibType;      ///< calibration type selection box
+  TGGroupFrame        *fContCalibType;      ///< calibration type label
   //content centre
-  TGCompositeFrame    *fContCenter;         // container for GUI elements at the center
-  TRootEmbeddedCanvas *fCanvMain;           // main drawing canvas
+  TGCompositeFrame    *fContCenter;         ///< container for GUI elements at the center
+  TRootEmbeddedCanvas *fCanvMain;           ///< main drawing canvas
   //content right 
-  TGCompositeFrame    *fContRight;          // container for GUI elements on right side
-  TGGroupFrame        *fContValues;         // container to keep data point information
-  TGLabel             *fLblRunNumber;       // run number label
-  TGLabel             *fLblRunTime;         // time stamp label
-  TGLabel             *fLblValueX;          // value label
-  TGLabel             *fLblValueY;          // value label
-  TGLabel             *fLblRunNumberVal;    // run number of the data point hoovered
-  TGLabel             *fLblRunTimeVal;      // time stamp of the data point hoovered
-  TGLabel             *fLblValueXVal;       // value of the data point hoovered
-  TGLabel             *fLblValueYVal;       // value of the data point hoovered
-  TGTextButton        *fBtnDumpRuns;        // draw button
-  TGGroupFrame        *fContAliases;         // container to keep data point information
-  TGListBox           *fListAliases;        // list of aliases
+  TGCompositeFrame    *fContRight;          ///< container for GUI elements on right side
+  TGGroupFrame        *fContValues;         ///< container to keep data point information
+  TGLabel             *fLblRunNumber;       ///< run number label
+  TGLabel             *fLblRunTime;         ///< time stamp label
+  TGLabel             *fLblValueX;          ///< value label
+  TGLabel             *fLblValueY;          ///< value label
+  TGLabel             *fLblRunNumberVal;    ///< run number of the data point hoovered
+  TGLabel             *fLblRunTimeVal;      ///< time stamp of the data point hoovered
+  TGLabel             *fLblValueXVal;       ///< value of the data point hoovered
+  TGLabel             *fLblValueYVal;       ///< value of the data point hoovered
+  TGTextButton        *fBtnDumpRuns;        ///< draw button
+  TGGroupFrame        *fContAliases;         ///< container to keep data point information
+  TGListBox           *fListAliases;        ///< list of aliases
   //content bottom
-  TGCompositeFrame    *fContCustom;         // container for custom draw command GUI elements
-  TGCompositeFrame    *fContCustomCuts;     // container for custom cut options GUI elements
-  TGLabel             *fLblCustomDraw;      // label for custom draw string
-  TGLabel             *fLblCustomCuts;      // label for custom cuts string
-  TGComboBox          *fComboCustomDraw;    // combo box custom draw string
-  TGComboBox          *fComboCustomCuts;    // combo box custom cuts string
+  TGCompositeFrame    *fContCustom;         ///< container for custom draw command GUI elements
+  TGCompositeFrame    *fContCustomCuts;     ///< container for custom cut options GUI elements
+  TGLabel             *fLblCustomDraw;      ///< label for custom draw string
+  TGLabel             *fLblCustomCuts;      ///< label for custom cuts string
+  TGComboBox          *fComboCustomDraw;    ///< combo box custom draw string
+  TGComboBox          *fComboCustomCuts;    ///< combo box custom cuts string
   //
-  TObjArray *fTrashBox;                   //graphics objects to be deleted (histograms, graphs,...)
+  TObjArray *fTrashBox;                   ///< graphics objects to be deleted (histograms, graphs,...)
   
   enum { kRadioXhist=10, kRadioXrun=11, kRadioXtime=12 };
   enum { kBranchOnOff=0, kBranchTitle=1, kCalibType=2, kParamNames=3 };
@@ -208,15 +204,17 @@ public:
   
 
 private:
-  TGTransientFrame    *fMain;           //Main frame
-  TGTextEntry         *fTxt1, *fTxt2;   //text input
+  TGTransientFrame    *fMain;           ///< Main frame
+  TGTextEntry         *fTxt1, *fTxt2;   ///< text input
 
-  AliTPCCalibViewerGUItime *fGUI;       //pointer to mother process
+  AliTPCCalibViewerGUItime *fGUI;       ///< pointer to mother process
 
   AliTPCCalibViewerGUItimeAddAliasFrame(const AliTPCCalibViewerGUItimeAddAliasFrame &r);
   AliTPCCalibViewerGUItimeAddAliasFrame &operator = (const AliTPCCalibViewerGUItimeAddAliasFrame &r);
 
+  /// \cond CLASSIMP
   ClassDef(AliTPCCalibViewerGUItimeAddAliasFrame,0)
+  /// \endcond
 };
 
 #endif
diff --git a/TPC/TPCbase/AliTPCClusterParam.cxx b/TPC/TPCbase/AliTPCClusterParam.cxx
index 27a552bd8f7..2a9fa914b11 100644
--- a/TPC/TPCbase/AliTPCClusterParam.cxx
+++ b/TPC/TPCbase/AliTPCClusterParam.cxx
@@ -14,76 +14,67 @@
  **************************************************************************/
 
 
-///////////////////////////////////////////////////////////////////////////////
-//                                                                           //
-//  TPC cluster error, shape and charge parameterization as function
-//  of drift length, and inclination angle                                   //
-//
-//  Following notation is used in following
-//  Int_t dim 0 - y direction
-//            1 - z direction
-//
-//  Int_t type 0 - short pads 
-//             1 - medium pads
-//             2 - long pads
-//  Float_t z    - drift length
-// 
-//  Float_t angle - tangent of inclination angle at given dimension 
-//
-//  Implemented parameterization
-//
-//
-//  1. Resolution as function of drift length and inclination angle
-//     1.a) GetError0(Int_t dim, Int_t type, Float_t z, Float_t angle)
-//          Simple error parameterization as derived from analytical formula
-//          only linear term in drift length and angle^2
-//          The formula is valid only with precission +-5%
-//          Separate parameterization for differnt pad geometry
-//     1.b) GetError0Par
-//          Parabolic term correction - better precision
-//
-//     1.c) GetError1 - JUST FOR Study
-//          Similar to GetError1
-//          The angular and diffusion effect is scaling with pad length
-//          common parameterization for different pad length
-//
-//  2. Error parameterization using charge 
-//     2.a) GetErrorQ
-//          GetError0+
-//          adding 1/Q component to diffusion and angluar part
-//     2.b) GetErrorQPar
-//          GetError0Par+
-//          adding 1/Q component to diffusion and angluar part
-//     2.c) GetErrorQParScaled - Just for study
-//          One parameterization for all pad shapes
-//          Smaller precission as previous one
-//
-//
-//  Example how to retrieve the paramterization:
-/*    
-      AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
-      AliCDBManager::Instance()->SetRun(0) 
-      AliTPCClusterParam * param = AliTPCcalibDB::Instance()->GetClusterParam();
+/// \class AliTPCClusterParam
+/// \brief TPC cluster error, shape and charge parameterization as function of drift length and inclination angle
+///
+/// Following notation is used in following
+/// Int_t dim 0 - y direction
+/// 1 - z direction
+///
+/// Int_t type 0 - short pads
+/// 1 - medium pads
+/// 2 - long pads
+/// Float_t z    - drift length
+///
+/// Float_t angle - tangent of inclination angle at given dimension
+///
+/// Implemented parameterization
+///
+/// 1. Resolution as function of drift length and inclination angle
+///   1.a) GetError0(Int_t dim, Int_t type, Float_t z, Float_t angle)
+/// Simple error parameterization as derived from analytical formula
+/// only linear term in drift length and angle^2
+/// The formula is valid only with precission +-5%
+/// Separate parameterization for differnt pad geometry
+///   1.b) GetError0Par
+/// Parabolic term correction - better precision
+///
+///   1.c) GetError1 - JUST FOR Study
+/// Similar to GetError1
+/// The angular and diffusion effect is scaling with pad length
+/// common parameterization for different pad length
+///
+/// 2. Error parameterization using charge
+///   2.a) GetErrorQ
+/// GetError0+
+/// adding 1/Q component to diffusion and angluar part
+///   2.b) GetErrorQPar
+/// GetError0Par+
+/// adding 1/Q component to diffusion and angluar part
+///   2.c) GetErrorQParScaled - Just for study
+/// One parameterization for all pad shapes
+/// Smaller precission as previous one
+///
+/// Example how to retrieve the paramterization:
+///
+/// ~~~{.cpp}
+/// AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
+/// AliCDBManager::Instance()->SetRun(0)
+/// AliTPCClusterParam * param = AliTPCcalibDB::Instance()->GetClusterParam();
+///
+/// AliTPCClusterParam::SetInstance(param);
+/// TF1 f1("f1","AliTPCClusterParam::SGetError0Par(1,0,x,0)",0,250);
+/// ~~~
+///
+/// Example how to create parameterization:
+/// Note resol is the resolution tree created by AliTPCcalibTracks
+///
+/// ~~~{.cpp}
+/// AliTPCClusterParam  *param = new AliTPCClusterParam;
+/// param->FitData(Resol);
+/// AliTPCClusterParam::SetInstance(param);
+/// ~~~
 
-      //
-      //
-      AliTPCClusterParam::SetInstance(param);
-      TF1 f1("f1","AliTPCClusterParam::SGetError0Par(1,0,x,0)",0,250);
-*/      
-
-// EXAMPLE hot to create parameterization
-/*
-// Note resol is the resolution tree created by AliTPCcalibTracks
-//
-AliTPCClusterParam  *param = new AliTPCClusterParam;
-param->FitData(Resol);
-AliTPCClusterParam::SetInstance(param);
- 
-*/
-
-//
-//                                                                     //
-///////////////////////////////////////////////////////////////////////////////
 #include "AliTPCClusterParam.h"
 #include "TMath.h"
 #include "TFile.h"
@@ -101,7 +92,9 @@ AliTPCClusterParam::SetInstance(param);
 
 #include "AliMathBase.h"
 
+/// \cond CLASSIMP
 ClassImp(AliTPCClusterParam)
+/// \endcond
 
 
 AliTPCClusterParam* AliTPCClusterParam::fgInstance = 0;
@@ -109,9 +102,9 @@ AliTPCClusterParam* AliTPCClusterParam::fgInstance = 0;
 
 /*
   Example usage fitting parameterization:
-  TFile fres("resol.root");    //tree with resolution and shape 
+  TFile fres("resol.root");    //tree with resolution and shape
   TTree * treeRes =(TTree*)fres.Get("Resol");
-  
+
   AliTPCClusterParam param;
   param.SetInstance(&param);
   param.FitResol(treeRes);
@@ -121,10 +114,10 @@ AliTPCClusterParam* AliTPCClusterParam::fgInstance = 0;
   //
   //
   TFile fparam("TPCClusterParam.root");
-  AliTPCClusterParam *param2  =  (AliTPCClusterParam *) fparam.Get("Param"); 
+  AliTPCClusterParam *param2  =  (AliTPCClusterParam *) fparam.Get("Param");
   param2->SetInstance(param2);
   param2->Test(treeRes);
-  
+
 
   treeRes->Draw("(Resol-AliTPCClusterParam::SGetError0(Dim,Pad,Zm,AngleM))/Resol","Dim==0&&QMean<0")
 
@@ -136,10 +129,9 @@ AliTPCClusterParam* AliTPCClusterParam::fgInstance = 0;
 //_ singleton implementation __________________________________________________
 AliTPCClusterParam* AliTPCClusterParam::Instance()
 {
-  //
-  // Singleton implementation
-  // Returns an instance of this class, it is created if neccessary
-  //
+  /// Singleton implementation
+  /// Returns an instance of this class, it is created if neccessary
+
   if (fgInstance == 0){
     fgInstance = new AliTPCClusterParam();
   }
@@ -162,15 +154,14 @@ AliTPCClusterParam::AliTPCClusterParam():
   fResolutionYMap(0)
   //
 {
+  /// Default constructor
+
+  fPosQTnorm[0] = 0;   fPosQTnorm[1] = 0;   fPosQTnorm[2] = 0;
+  fPosQMnorm[0] = 0;   fPosQMnorm[1] = 0;   fPosQMnorm[2] = 0;
   //
-  // Default constructor
-  //
-  fPosQTnorm[0] = 0;   fPosQTnorm[1] = 0;   fPosQTnorm[2] = 0; 
-  fPosQMnorm[0] = 0;   fPosQMnorm[1] = 0;   fPosQMnorm[2] = 0; 
-  //
-  fPosYcor[0]   = 0;   fPosYcor[1]   = 0;   fPosYcor[2]   = 0; 
-  fPosZcor[0]   = 0;   fPosZcor[1]   = 0;   fPosZcor[2]   = 0; 
-  fErrorRMSSys[0]=0;   fErrorRMSSys[1]=0; 
+  fPosYcor[0]   = 0;   fPosYcor[1]   = 0;   fPosYcor[2]   = 0;
+  fPosZcor[0]   = 0;   fPosZcor[1]   = 0;   fPosZcor[2]   = 0;
+  fErrorRMSSys[0]=0;   fErrorRMSSys[1]=0;
 }
 
 AliTPCClusterParam::AliTPCClusterParam(const AliTPCClusterParam& param):
@@ -187,9 +178,8 @@ AliTPCClusterParam::AliTPCClusterParam(const AliTPCClusterParam& param):
   fWaveCorrectionMirroredAngle( kFALSE ),
   fResolutionYMap(0)
 {
-  //
-  // copy constructor
-  //
+  /// copy constructor
+
   if (param.fQNorm) fQNorm = (TObjArray*) param.fQNorm->Clone();
   if (param.fQNormHis) fQNormHis = (TObjArray*) param.fQNormHis->Clone();
   //
@@ -258,9 +248,8 @@ AliTPCClusterParam::AliTPCClusterParam(const AliTPCClusterParam& param):
 
 
 AliTPCClusterParam & AliTPCClusterParam::operator=(const AliTPCClusterParam& param){
-  //
-  // Assignment operator
-  //
+  /// Assignment operator
+
   if (this != &param) {
     if (param.fQNorm) fQNorm = (TObjArray*) param.fQNorm->Clone();
     if (param.fQNormHis) fQNormHis = (TObjArray*) param.fQNormHis->Clone();
@@ -282,7 +271,7 @@ AliTPCClusterParam & AliTPCClusterParam::operator=(const AliTPCClusterParam& par
       fPosZcor[1] = new TVectorD(*(param.fPosZcor[1]));
       fPosZcor[2] = new TVectorD(*(param.fPosZcor[2]));
     }
-    
+
     for (Int_t ii = 0; ii < 2; ++ii) {
       for (Int_t jj = 0; jj < 3; ++jj) {
 	for (Int_t kk = 0; kk < 4; ++kk) {
@@ -322,7 +311,7 @@ AliTPCClusterParam & AliTPCClusterParam::operator=(const AliTPCClusterParam& par
 	fRMSSigmaRatio[ii][jj] = param.fRMSSigmaRatio[ii][jj];
       }
     }
-    
+
     SetWaveCorrectionMap( param.fWaveCorrectionMap );
     SetResolutionYMap( param.fResolutionYMap );
   }
@@ -331,9 +320,8 @@ AliTPCClusterParam & AliTPCClusterParam::operator=(const AliTPCClusterParam& par
 
 
 AliTPCClusterParam::~AliTPCClusterParam(){
-  //
-  // destructor
-  //
+  /// destructor
+
   if (fQNorm) fQNorm->Delete();
   if (fQNormCorr) delete fQNormCorr;
   if (fQNormHis) fQNormHis->Delete();
@@ -363,10 +351,10 @@ AliTPCClusterParam::~AliTPCClusterParam(){
 
 
 void AliTPCClusterParam::FitResol0(TTree * tree, Int_t dim, Int_t type, Float_t *param0, Float_t *error){
-  //
-  // Fit z - angular dependence of resolution 
-  //
-  // Int_t dim=0, type=0;
+  /// Fit z - angular dependence of resolution
+  ///
+  /// Int_t dim=0, type=0;
+
   TString varVal;
   varVal="Resol:AngleM:Zm";
   TString varErr;
@@ -378,20 +366,20 @@ void AliTPCClusterParam::FitResol0(TTree * tree, Int_t dim, Int_t type, Float_t
   Float_t px[10000], py[10000], pz[10000];
   Float_t ex[10000], ey[10000], ez[10000];
   //
-  tree->Draw(varErr.Data(),varCut);  
+  tree->Draw(varErr.Data(),varCut);
   for (Int_t ipoint=0; ipoint<entries; ipoint++){
     ex[ipoint]= tree->GetV3()[ipoint];
     ey[ipoint]= tree->GetV2()[ipoint];
     ez[ipoint]= tree->GetV1()[ipoint];
-  } 
+  }
   tree->Draw(varVal.Data(),varCut);
   for (Int_t ipoint=0; ipoint<entries; ipoint++){
     px[ipoint]= tree->GetV3()[ipoint];
     py[ipoint]= tree->GetV2()[ipoint];
     pz[ipoint]= tree->GetV1()[ipoint];
   }
-  
-  //  
+
+  //
   TLinearFitter fitter(3,"hyp2");
   for (Int_t ipoint=0; ipoint<entries; ipoint++){
     Float_t val = pz[ipoint]*pz[ipoint];
@@ -416,10 +404,10 @@ void AliTPCClusterParam::FitResol0(TTree * tree, Int_t dim, Int_t type, Float_t
 
 
 void AliTPCClusterParam::FitResol0Par(TTree * tree, Int_t dim, Int_t type, Float_t *param0, Float_t *error){
-  //
-  // Fit z - angular dependence of resolution 
-  //
-  // Int_t dim=0, type=0;
+  /// Fit z - angular dependence of resolution
+  ///
+  /// Int_t dim=0, type=0;
+
  TString varVal;
   varVal="Resol:AngleM:Zm";
  TString varErr;
@@ -431,20 +419,20 @@ void AliTPCClusterParam::FitResol0Par(TTree * tree, Int_t dim, Int_t type, Float
   Float_t px[10000], py[10000], pz[10000];
   Float_t ex[10000], ey[10000], ez[10000];
   //
-  tree->Draw(varErr.Data(),varCut);  
+  tree->Draw(varErr.Data(),varCut);
   for (Int_t ipoint=0; ipoint<entries; ipoint++){
     ex[ipoint]= tree->GetV3()[ipoint];
     ey[ipoint]= tree->GetV2()[ipoint];
     ez[ipoint]= tree->GetV1()[ipoint];
-  } 
+  }
   tree->Draw(varVal.Data(),varCut);
   for (Int_t ipoint=0; ipoint<entries; ipoint++){
     px[ipoint]= tree->GetV3()[ipoint];
     py[ipoint]= tree->GetV2()[ipoint];
     pz[ipoint]= tree->GetV1()[ipoint];
   }
-  
-  //  
+
+  //
   TLinearFitter fitter(6,"hyp5");
   for (Int_t ipoint=0; ipoint<entries; ipoint++){
     Float_t val = pz[ipoint]*pz[ipoint];
@@ -481,10 +469,10 @@ void AliTPCClusterParam::FitResol0Par(TTree * tree, Int_t dim, Int_t type, Float
 
 
 void AliTPCClusterParam::FitResol1(TTree * tree, Int_t dim, Float_t *param0, Float_t *error){
-  //
-  // Fit z - angular dependence of resolution - pad length scaling 
-  //
-  // Int_t dim=0, type=0;
+  /// Fit z - angular dependence of resolution - pad length scaling
+  ///
+  /// Int_t dim=0, type=0;
+
  TString varVal;
   varVal="Resol:AngleM*sqrt(Length):Zm/Length";
  TString varErr;
@@ -496,20 +484,20 @@ void AliTPCClusterParam::FitResol1(TTree * tree, Int_t dim, Float_t *param0, Flo
   Float_t px[10000], py[10000], pz[10000];
   Float_t ex[10000], ey[10000], ez[10000];
   //
-  tree->Draw(varErr.Data(),varCut);  
+  tree->Draw(varErr.Data(),varCut);
   for (Int_t ipoint=0; ipoint<entries; ipoint++){
     ex[ipoint]= tree->GetV3()[ipoint];
     ey[ipoint]= tree->GetV2()[ipoint];
     ez[ipoint]= tree->GetV1()[ipoint];
-  } 
+  }
   tree->Draw(varVal.Data(),varCut);
   for (Int_t ipoint=0; ipoint<entries; ipoint++){
     px[ipoint]= tree->GetV3()[ipoint];
     py[ipoint]= tree->GetV2()[ipoint];
     pz[ipoint]= tree->GetV1()[ipoint];
   }
-  
-  //  
+
+  //
   TLinearFitter fitter(3,"hyp2");
   for (Int_t ipoint=0; ipoint<entries; ipoint++){
     Float_t val = pz[ipoint]*pz[ipoint];
@@ -533,10 +521,10 @@ void AliTPCClusterParam::FitResol1(TTree * tree, Int_t dim, Float_t *param0, Flo
 }
 
 void AliTPCClusterParam::FitResolQ(TTree * tree, Int_t dim, Int_t type, Float_t *param0, Float_t *error){
-  //
-  // Fit z - angular dependence of resolution - Q scaling 
-  //
-  // Int_t dim=0, type=0;
+  /// Fit z - angular dependence of resolution - Q scaling
+  ///
+  /// Int_t dim=0, type=0;
+
  TString varVal;
   varVal="Resol:AngleM/sqrt(QMean):Zm/QMean";
   char varVal0[100];
@@ -551,12 +539,12 @@ void AliTPCClusterParam::FitResolQ(TTree * tree, Int_t dim, Int_t type, Float_t
   Float_t px[20000], py[20000], pz[20000], pu[20000], pt[20000];
   Float_t ex[20000], ey[20000], ez[20000];
   //
-  tree->Draw(varErr.Data(),varCut);  
+  tree->Draw(varErr.Data(),varCut);
   for (Int_t ipoint=0; ipoint<entries; ipoint++){
     ex[ipoint]= tree->GetV3()[ipoint];
     ey[ipoint]= tree->GetV2()[ipoint];
     ez[ipoint]= tree->GetV1()[ipoint];
-  } 
+  }
   tree->Draw(varVal.Data(),varCut);
   for (Int_t ipoint=0; ipoint<entries; ipoint++){
     px[ipoint]= tree->GetV3()[ipoint];
@@ -568,8 +556,8 @@ void AliTPCClusterParam::FitResolQ(TTree * tree, Int_t dim, Int_t type, Float_t
     pu[ipoint]= tree->GetV3()[ipoint];
     pt[ipoint]= tree->GetV2()[ipoint];
   }
-  
-  //  
+
+  //
   TLinearFitter fitter(5,"hyp4");
   for (Int_t ipoint=0; ipoint<entries; ipoint++){
     Float_t val = pz[ipoint]*pz[ipoint];
@@ -600,10 +588,10 @@ void AliTPCClusterParam::FitResolQ(TTree * tree, Int_t dim, Int_t type, Float_t
 }
 
 void AliTPCClusterParam::FitResolQPar(TTree * tree, Int_t dim, Int_t type, Float_t *param0, Float_t *error){
-  //
-  // Fit z - angular dependence of resolution - Q scaling  - parabolic correction
-  //
-  // Int_t dim=0, type=0;
+  /// Fit z - angular dependence of resolution - Q scaling  - parabolic correction
+  ///
+  /// Int_t dim=0, type=0;
+
  TString varVal;
   varVal="Resol:AngleM/sqrt(QMean):Zm/QMean";
   char varVal0[100];
@@ -618,12 +606,12 @@ void AliTPCClusterParam::FitResolQPar(TTree * tree, Int_t dim, Int_t type, Float
   Float_t px[20000], py[20000], pz[20000], pu[20000], pt[20000];
   Float_t ex[20000], ey[20000], ez[20000];
   //
-  tree->Draw(varErr.Data(),varCut);  
+  tree->Draw(varErr.Data(),varCut);
   for (Int_t ipoint=0; ipoint<entries; ipoint++){
     ex[ipoint]= tree->GetV3()[ipoint];
     ey[ipoint]= tree->GetV2()[ipoint];
     ez[ipoint]= tree->GetV1()[ipoint];
-  } 
+  }
   tree->Draw(varVal.Data(),varCut);
   for (Int_t ipoint=0; ipoint<entries; ipoint++){
     px[ipoint]= tree->GetV3()[ipoint];
@@ -635,8 +623,8 @@ void AliTPCClusterParam::FitResolQPar(TTree * tree, Int_t dim, Int_t type, Float
     pu[ipoint]= tree->GetV3()[ipoint];
     pt[ipoint]= tree->GetV2()[ipoint];
   }
-  
-  //  
+
+  //
   TLinearFitter fitter(8,"hyp7");
   for (Int_t ipoint=0; ipoint<entries; ipoint++){
     Float_t val = pz[ipoint]*pz[ipoint];
@@ -680,10 +668,10 @@ void AliTPCClusterParam::FitResolQPar(TTree * tree, Int_t dim, Int_t type, Float
 
 
 void AliTPCClusterParam::FitRMS0(TTree * tree, Int_t dim, Int_t type, Float_t *param0, Float_t *error){
-  //
-  // Fit z - angular dependence of resolution 
-  //
-  // Int_t dim=0, type=0;
+  /// Fit z - angular dependence of resolution
+  ///
+  /// Int_t dim=0, type=0;
+
  TString varVal;
   varVal="RMSm:AngleM:Zm";
  TString varErr;
@@ -695,20 +683,20 @@ void AliTPCClusterParam::FitRMS0(TTree * tree, Int_t dim, Int_t type, Float_t *p
   Float_t px[10000], py[10000], pz[10000];
   Float_t ex[10000], ey[10000], ez[10000];
   //
-  tree->Draw(varErr.Data(),varCut);  
+  tree->Draw(varErr.Data(),varCut);
   for (Int_t ipoint=0; ipoint<entries; ipoint++){
     ex[ipoint]= tree->GetV3()[ipoint];
     ey[ipoint]= tree->GetV2()[ipoint];
     ez[ipoint]= tree->GetV1()[ipoint];
-  } 
+  }
   tree->Draw(varVal.Data(),varCut);
   for (Int_t ipoint=0; ipoint<entries; ipoint++){
     px[ipoint]= tree->GetV3()[ipoint];
     py[ipoint]= tree->GetV2()[ipoint];
     pz[ipoint]= tree->GetV1()[ipoint];
   }
-  
-  //  
+
+  //
   TLinearFitter fitter(3,"hyp2");
   for (Int_t ipoint=0; ipoint<entries; ipoint++){
     Float_t val = pz[ipoint]*pz[ipoint];
@@ -732,10 +720,10 @@ void AliTPCClusterParam::FitRMS0(TTree * tree, Int_t dim, Int_t type, Float_t *p
 }
 
 void AliTPCClusterParam::FitRMS1(TTree * tree, Int_t dim, Float_t *param0, Float_t *error){
-  //
-  // Fit z - angular dependence of resolution - pad length scaling 
-  //
-  // Int_t dim=0, type=0;
+  /// Fit z - angular dependence of resolution - pad length scaling
+  ///
+  /// Int_t dim=0, type=0;
+
  TString varVal;
   varVal="RMSm:AngleM*Length:Zm";
  TString varErr;
@@ -747,20 +735,20 @@ void AliTPCClusterParam::FitRMS1(TTree * tree, Int_t dim, Float_t *param0, Float
   Float_t px[10000], py[10000], pz[10000];
   Float_t type[10000], ey[10000], ez[10000];
   //
-  tree->Draw(varErr.Data(),varCut);  
+  tree->Draw(varErr.Data(),varCut);
   for (Int_t ipoint=0; ipoint<entries; ipoint++){
     type[ipoint] = tree->GetV3()[ipoint];
     ey[ipoint]   = tree->GetV2()[ipoint];
     ez[ipoint]   = tree->GetV1()[ipoint];
-  } 
+  }
   tree->Draw(varVal.Data(),varCut);
   for (Int_t ipoint=0; ipoint<entries; ipoint++){
     px[ipoint]= tree->GetV3()[ipoint];
     py[ipoint]= tree->GetV2()[ipoint];
     pz[ipoint]= tree->GetV1()[ipoint];
   }
-  
-  //  
+
+  //
   TLinearFitter fitter(4,"hyp3");
   for (Int_t ipoint=0; ipoint<entries; ipoint++){
     Float_t val = pz[ipoint]*pz[ipoint];
@@ -787,10 +775,10 @@ void AliTPCClusterParam::FitRMS1(TTree * tree, Int_t dim, Float_t *param0, Float
 }
 
 void AliTPCClusterParam::FitRMSQ(TTree * tree, Int_t dim, Int_t type, Float_t *param0, Float_t *error){
-  //
-  // Fit z - angular dependence of resolution - Q scaling 
-  //
-  // Int_t dim=0, type=0;
+  /// Fit z - angular dependence of resolution - Q scaling
+  ///
+  /// Int_t dim=0, type=0;
+
  TString varVal;
   varVal="RMSm:AngleM/sqrt(QMean):Zm/QMean";
   char varVal0[100];
@@ -805,12 +793,12 @@ void AliTPCClusterParam::FitRMSQ(TTree * tree, Int_t dim, Int_t type, Float_t *p
   Float_t px[20000], py[20000], pz[20000], pu[20000], pt[20000];
   Float_t ex[20000], ey[20000], ez[20000];
   //
-  tree->Draw(varErr.Data(),varCut);  
+  tree->Draw(varErr.Data(),varCut);
   for (Int_t ipoint=0; ipoint<entries; ipoint++){
     ex[ipoint]= tree->GetV3()[ipoint];
     ey[ipoint]= tree->GetV2()[ipoint];
     ez[ipoint]= tree->GetV1()[ipoint];
-  } 
+  }
   tree->Draw(varVal.Data(),varCut);
   for (Int_t ipoint=0; ipoint<entries; ipoint++){
     px[ipoint]= tree->GetV3()[ipoint];
@@ -822,8 +810,8 @@ void AliTPCClusterParam::FitRMSQ(TTree * tree, Int_t dim, Int_t type, Float_t *p
     pu[ipoint]= tree->GetV3()[ipoint];
     pt[ipoint]= tree->GetV2()[ipoint];
   }
-  
-  //  
+
+  //
   TLinearFitter fitter(5,"hyp4");
   for (Int_t ipoint=0; ipoint<entries; ipoint++){
     Float_t val = pz[ipoint]*pz[ipoint];
@@ -855,10 +843,10 @@ void AliTPCClusterParam::FitRMSQ(TTree * tree, Int_t dim, Int_t type, Float_t *p
 
 
 void AliTPCClusterParam::FitRMSSigma(TTree * tree, Int_t dim, Int_t type, Float_t *param0, Float_t */*error*/){
-  //
-  // Fit z - angular dependence of resolution - Q scaling 
-  //
-  // Int_t dim=0, type=0;
+  /// Fit z - angular dependence of resolution - Q scaling
+  ///
+  /// Int_t dim=0, type=0;
+
   TString varVal;
   varVal="RMSs:RMSm";
   //
@@ -889,22 +877,20 @@ void AliTPCClusterParam::FitRMSSigma(TTree * tree, Int_t dim, Int_t type, Float_
 
 
 Float_t  AliTPCClusterParam::GetError0(Int_t dim, Int_t type, Float_t z, Float_t angle) const {
-  //
-  //
-  //
+  ///
+
   Float_t value=0;
   value += fParamS0[dim][type][0];
   value += fParamS0[dim][type][1]*z;
   value += fParamS0[dim][type][2]*angle*angle;
-  value  = TMath::Sqrt(TMath::Abs(value)); 
+  value  = TMath::Sqrt(TMath::Abs(value));
   return value;
 }
 
 
 Float_t  AliTPCClusterParam::GetError0Par(Int_t dim, Int_t type, Float_t z, Float_t angle) const {
-  //
-  //
-  //
+  ///
+
   Float_t value=0;
   value += fParamS0Par[dim][type][0];
   value += fParamS0Par[dim][type][1]*z;
@@ -912,16 +898,15 @@ Float_t  AliTPCClusterParam::GetError0Par(Int_t dim, Int_t type, Float_t z, Floa
   value += fParamS0Par[dim][type][3]*z*z;
   value += fParamS0Par[dim][type][4]*angle*angle*angle*angle;
   value += fParamS0Par[dim][type][5]*z*angle*angle;
-  value  = TMath::Sqrt(TMath::Abs(value)); 
+  value  = TMath::Sqrt(TMath::Abs(value));
   return value;
 }
 
 
 
 Float_t  AliTPCClusterParam::GetError1(Int_t dim, Int_t type, Float_t z, Float_t angle) const {
-  //
-  //
-  //
+  ///
+
   Float_t value=0;
   Float_t length=0.75;
   if (type==1) length=1;
@@ -929,30 +914,28 @@ Float_t  AliTPCClusterParam::GetError1(Int_t dim, Int_t type, Float_t z, Float_t
   value += fParamS1[dim][0];
   value += fParamS1[dim][1]*z/length;
   value += fParamS1[dim][2]*angle*angle*length;
-  value  = TMath::Sqrt(TMath::Abs(value)); 
+  value  = TMath::Sqrt(TMath::Abs(value));
   return value;
 }
 
 Float_t  AliTPCClusterParam::GetErrorQ(Int_t dim, Int_t type, Float_t z, Float_t angle, Float_t Qmean) const {
-  //
-  //
-  //
+  ///
+
   Float_t value=0;
   value += fParamSQ[dim][type][0];
   value += fParamSQ[dim][type][1]*z;
   value += fParamSQ[dim][type][2]*angle*angle;
   value += fParamSQ[dim][type][3]*z/Qmean;
   value += fParamSQ[dim][type][4]*angle*angle/Qmean;
-  value  = TMath::Sqrt(TMath::Abs(value)); 
+  value  = TMath::Sqrt(TMath::Abs(value));
   return value;
 
 
 }
 
 Float_t  AliTPCClusterParam::GetErrorQPar(Int_t dim, Int_t type, Float_t z, Float_t angle, Float_t Qmean) const {
-  //
-  //
-  //
+  ///
+
   Float_t value=0;
   value += fParamSQPar[dim][type][0];
   value += fParamSQPar[dim][type][1]*z;
@@ -962,16 +945,15 @@ Float_t  AliTPCClusterParam::GetErrorQPar(Int_t dim, Int_t type, Float_t z, Floa
   value += fParamSQPar[dim][type][5]*z*angle*angle;
   value += fParamSQPar[dim][type][6]*z/Qmean;
   value += fParamSQPar[dim][type][7]*angle*angle/Qmean;
-  value  = TMath::Sqrt(TMath::Abs(value)); 
+  value  = TMath::Sqrt(TMath::Abs(value));
   return value;
 
 
 }
 
 Float_t  AliTPCClusterParam::GetErrorQParScaled(Int_t dim, Int_t type, Float_t z, Float_t angle, Float_t Qmean) const {
-  //
-  //
-  //
+  ///
+
   Float_t value=0;
   value += fParamSQPar[dim][type][0];
   value += fParamSQPar[dim][type][1]*z;
@@ -982,29 +964,27 @@ Float_t  AliTPCClusterParam::GetErrorQParScaled(Int_t dim, Int_t type, Float_t z
   value += fParamSQPar[dim][type][6]*z/Qmean;
   value += fParamSQPar[dim][type][7]*angle*angle/Qmean;
   Float_t valueMean = GetError0Par(dim,type,z,angle);
-  value -= 0.35*0.35*valueMean*valueMean; 
-  value  = TMath::Sqrt(TMath::Abs(value)); 
+  value -= 0.35*0.35*valueMean*valueMean;
+  value  = TMath::Sqrt(TMath::Abs(value));
   return value;
 
 
 }
 
 Float_t  AliTPCClusterParam::GetRMS0(Int_t dim, Int_t type, Float_t z, Float_t angle) const {
-  //
-  // calculate mean RMS of cluster - z,angle - parameters for each pad and dimension separatelly
-  //
+  /// calculate mean RMS of cluster - z,angle - parameters for each pad and dimension separatelly
+
   Float_t value=0;
   value += fParamRMS0[dim][type][0];
   value += fParamRMS0[dim][type][1]*z;
   value += fParamRMS0[dim][type][2]*angle*angle;
-  value  = TMath::Sqrt(TMath::Abs(value)); 
+  value  = TMath::Sqrt(TMath::Abs(value));
   return value;
 }
 
 Float_t  AliTPCClusterParam::GetRMS1(Int_t dim, Int_t type, Float_t z, Float_t angle) const {
-  //
-  // calculate mean RMS of cluster - z,angle - pad length scalling
-  //
+  /// calculate mean RMS of cluster - z,angle - pad length scalling
+
   Float_t value=0;
   Float_t length=0.75;
   if (type==1) length=1;
@@ -1016,28 +996,26 @@ Float_t  AliTPCClusterParam::GetRMS1(Int_t dim, Int_t type, Float_t z, Float_t a
   }
   value += fParamRMS1[dim][2]*z;
   value += fParamRMS1[dim][3]*angle*angle*length*length;
-  value  = TMath::Sqrt(TMath::Abs(value)); 
+  value  = TMath::Sqrt(TMath::Abs(value));
   return value;
 }
 
 Float_t  AliTPCClusterParam::GetRMSQ(Int_t dim, Int_t type, Float_t z, Float_t angle, Float_t Qmean) const {
-  //
-  // calculate mean RMS of cluster - z,angle, Q dependence
-  //
+  /// calculate mean RMS of cluster - z,angle, Q dependence
+
   Float_t value=0;
   value += fParamRMSQ[dim][type][0];
   value += fParamRMSQ[dim][type][1]*z;
   value += fParamRMSQ[dim][type][2]*angle*angle;
   value += fParamRMSQ[dim][type][3]*z/Qmean;
   value += fParamRMSQ[dim][type][4]*angle*angle/Qmean;
-  value  = TMath::Sqrt(TMath::Abs(value)); 
+  value  = TMath::Sqrt(TMath::Abs(value));
   return value;
 }
 
 Float_t  AliTPCClusterParam::GetRMSSigma(Int_t dim, Int_t type, Float_t z, Float_t angle, Float_t Qmean) const {
-  //
-  // calculates RMS of signal shape fluctuation
-  //
+  /// calculates RMS of signal shape fluctuation
+
   Float_t mean = GetRMSQ(dim,type,z,angle,Qmean);
   Float_t value  = fRMSSigmaFit[dim][type][0];
   value+=  fRMSSigmaFit[dim][type][1]*mean;
@@ -1045,9 +1023,8 @@ Float_t  AliTPCClusterParam::GetRMSSigma(Int_t dim, Int_t type, Float_t z, Float
 }
 
 Float_t  AliTPCClusterParam::GetShapeFactor(Int_t dim, Int_t type, Float_t z, Float_t angle, Float_t Qmean, Float_t rmsL, Float_t rmsM) const {
-  //
-  // calculates vallue - sigma distortion contribution
-  //
+  /// calculates vallue - sigma distortion contribution
+
   Double_t value =0;
   //
   Float_t rmsMeanQ  = GetRMSQ(dim,type,z,angle,Qmean);
@@ -1070,18 +1047,18 @@ Float_t  AliTPCClusterParam::GetShapeFactor(Int_t dim, Int_t type, Float_t z, Fl
 
 
 void AliTPCClusterParam::FitData(TTree * tree){
-  //
-  // make fits for error param and shape param
-  //
+  /// make fits for error param and shape param
+
   FitResol(tree);
   FitRMS(tree);
 
 }
 
 void AliTPCClusterParam::FitResol(TTree * tree){
-  //
+  ///
+
   SetInstance(this);
-  for (Int_t idir=0;idir<2; idir++){    
+  for (Int_t idir=0;idir<2; idir++){
     for (Int_t itype=0; itype<3; itype++){
       Float_t param0[10];
       Float_t error0[10];
@@ -1091,17 +1068,17 @@ void AliTPCClusterParam::FitResol(TTree * tree){
       printf("%f\t%f\t%f\n", param0[0],param0[1],param0[2]);
       printf("%f\t%f\t%f\n", error0[0],error0[1],error0[2]);
       for (Int_t ipar=0;ipar<4; ipar++){
-	fParamS0[idir][itype][ipar] = param0[ipar];	
-	fErrorS0[idir][itype][ipar] = param0[ipar];	
-      } 
+	fParamS0[idir][itype][ipar] = param0[ipar];
+	fErrorS0[idir][itype][ipar] = param0[ipar];
+      }
       // error param with parabolic correction
       FitResol0Par(tree, idir, itype,param0,error0);
       printf("\nResolPar\t%d\t%d\tchi2=%f\n",idir,itype,param0[6]);
       printf("%f\t%f\t%f\t%f\t%f\t%f\n", param0[0],param0[1],param0[2],param0[3],param0[4],param0[5]);
       printf("%f\t%f\t%f\t%f\t%f\t%f\n", error0[0],error0[1],error0[2],error0[3],error0[4],error0[5]);
       for (Int_t ipar=0;ipar<7; ipar++){
-	fParamS0Par[idir][itype][ipar] = param0[ipar];	
-	fErrorS0Par[idir][itype][ipar] = param0[ipar];	
+	fParamS0Par[idir][itype][ipar] = param0[ipar];
+	fErrorS0Par[idir][itype][ipar] = param0[ipar];
       }
       //
       FitResolQ(tree, idir, itype,param0,error0);
@@ -1109,8 +1086,8 @@ void AliTPCClusterParam::FitResol(TTree * tree){
       printf("%f\t%f\t%f\t%f\t%f\n", param0[0],param0[1],param0[2],param0[3],param0[4]);
       printf("%f\t%f\t%f\t%f\t%f\n", error0[0],error0[1],error0[2],error0[3],error0[4]);
       for (Int_t ipar=0;ipar<6; ipar++){
-	fParamSQ[idir][itype][ipar] = param0[ipar];	
-	fErrorSQ[idir][itype][ipar] = param0[ipar];	
+	fParamSQ[idir][itype][ipar] = param0[ipar];
+	fErrorSQ[idir][itype][ipar] = param0[ipar];
       }
       //
       FitResolQPar(tree, idir, itype,param0,error0);
@@ -1118,14 +1095,14 @@ void AliTPCClusterParam::FitResol(TTree * tree){
       printf("%f\t%f\t%f\t%f\t%f\t%f\t%f\t%f\n", param0[0],param0[1],param0[2],param0[3],param0[4],param0[5],param0[6],param0[7]);
       printf("%f\t%f\t%f\t%f\t%f\t%f\t%f\t%f\n", error0[0],error0[1],error0[2],error0[3],error0[4],error0[5],error0[6],error0[7]);
       for (Int_t ipar=0;ipar<9; ipar++){
-	fParamSQPar[idir][itype][ipar] = param0[ipar];	
-	fErrorSQPar[idir][itype][ipar] = param0[ipar];	
+	fParamSQPar[idir][itype][ipar] = param0[ipar];
+	fErrorSQPar[idir][itype][ipar] = param0[ipar];
       }
     }
   }
   //
   printf("Resol z-scaled\n");
-  for (Int_t idir=0;idir<2; idir++){    
+  for (Int_t idir=0;idir<2; idir++){
     Float_t param0[4];
     Float_t error0[4];
     FitResol1(tree, idir,param0,error0);
@@ -1133,8 +1110,8 @@ void AliTPCClusterParam::FitResol(TTree * tree){
     printf("%f\t%f\t%f\n", param0[0],param0[1],param0[2]);
     printf("%f\t%f\t%f\n", error0[0],error0[1],error0[2]);
     for (Int_t ipar=0;ipar<4; ipar++){
-      fParamS1[idir][ipar] = param0[ipar];	
-      fErrorS1[idir][ipar] = param0[ipar];	
+      fParamS1[idir][ipar] = param0[ipar];
+      fErrorS1[idir][ipar] = param0[ipar];
     }
   }
 
@@ -1147,15 +1124,16 @@ void AliTPCClusterParam::FitResol(TTree * tree){
       if (itype==2) length=1.5;
       printf("%d\t%f\t%f\t%f\n", itype,fParamS0[idir][itype][0],fParamS0[idir][itype][1]*TMath::Sqrt(length),fParamS0[idir][itype][2]/TMath::Sqrt(length));
     }
-  }  
+  }
 }
 
 
 
 void AliTPCClusterParam::FitRMS(TTree * tree){
-  //
+  ///
+
   SetInstance(this);
-  for (Int_t idir=0;idir<2; idir++){    
+  for (Int_t idir=0;idir<2; idir++){
     for (Int_t itype=0; itype<3; itype++){
       Float_t param0[6];
       Float_t error0[6];
@@ -1164,22 +1142,22 @@ void AliTPCClusterParam::FitRMS(TTree * tree){
       printf("%f\t%f\t%f\n", param0[0],param0[1],param0[2]);
       printf("%f\t%f\t%f\n", error0[0],error0[1],error0[2]);
       for (Int_t ipar=0;ipar<4; ipar++){
-	fParamRMS0[idir][itype][ipar] = param0[ipar];	
-	fErrorRMS0[idir][itype][ipar] = param0[ipar];	
+	fParamRMS0[idir][itype][ipar] = param0[ipar];
+	fErrorRMS0[idir][itype][ipar] = param0[ipar];
       }
       FitRMSQ(tree, idir, itype,param0,error0);
       printf("\nRMSQ\t%d\t%d\tchi2=%f\n",idir,itype,param0[5]);
       printf("%f\t%f\t%f\t%f\t%f\n", param0[0],param0[1],param0[2],param0[3],param0[4]);
       printf("%f\t%f\t%f\t%f\t%f\n", error0[0],error0[1],error0[2],error0[3],error0[4]);
       for (Int_t ipar=0;ipar<6; ipar++){
-	fParamRMSQ[idir][itype][ipar] = param0[ipar];	
-	fErrorRMSQ[idir][itype][ipar] = param0[ipar];	
+	fParamRMSQ[idir][itype][ipar] = param0[ipar];
+	fErrorRMSQ[idir][itype][ipar] = param0[ipar];
       }
     }
   }
   //
   printf("RMS z-scaled\n");
-  for (Int_t idir=0;idir<2; idir++){    
+  for (Int_t idir=0;idir<2; idir++){
     Float_t param0[5];
     Float_t error0[5];
     FitRMS1(tree, idir,param0,error0);
@@ -1187,8 +1165,8 @@ void AliTPCClusterParam::FitRMS(TTree * tree){
     printf("%f\t%f\t%f\t%f\n", param0[0],param0[1],param0[2], param0[3]);
     printf("%f\t%f\t%f\t%f\n", error0[0],error0[1],error0[2], error0[3]);
     for (Int_t ipar=0;ipar<5; ipar++){
-      fParamRMS1[idir][ipar] = param0[ipar];	
-      fErrorRMS1[idir][ipar] = param0[ipar];	
+      fParamRMS1[idir][ipar] = param0[ipar];
+      fErrorRMS1[idir][ipar] = param0[ipar];
     }
   }
 
@@ -1202,22 +1180,22 @@ void AliTPCClusterParam::FitRMS(TTree * tree){
       if (itype==0) printf("%d\t%f\t\t\t%f\t%f\n", itype,fParamRMS0[idir][itype][0],fParamRMS0[idir][itype][1],fParamRMS0[idir][itype][2]/length);
       if (itype>0) printf("%d\t\t\t%f\t%f\t%f\n", itype,fParamRMS0[idir][itype][0],fParamRMS0[idir][itype][1],fParamRMS0[idir][itype][2]/length);
     }
-  }  
+  }
   //
   // Fit RMS sigma
   //
   printf("RMS fluctuation  parameterization \n");
-  for (Int_t idir=0;idir<2; idir++){    
-    for (Int_t itype=0; itype<3; itype++){ 
+  for (Int_t idir=0;idir<2; idir++){
+    for (Int_t itype=0; itype<3; itype++){
       Float_t param0[5];
       Float_t error0[5];
-      FitRMSSigma(tree, idir,itype,param0,error0); 
+      FitRMSSigma(tree, idir,itype,param0,error0);
       printf("\t%d\t%d\t%f\t%f\n", idir, itype, param0[0],param0[1]);
       for (Int_t ipar=0;ipar<2; ipar++){
-	fRMSSigmaFit[idir][itype][ipar] = param0[ipar];	
+	fRMSSigmaFit[idir][itype][ipar] = param0[ipar];
       }
     }
-  } 
+  }
   //
   // store systematic error end RMS fluctuation parameterization
   //
@@ -1236,9 +1214,8 @@ void AliTPCClusterParam::FitRMS(TTree * tree){
 }
 
 void AliTPCClusterParam::Test(TTree * tree, const char *output){
-  //
-  // Draw standard quality histograms to output file
-  //
+  /// Draw standard quality histograms to output file
+
   SetInstance(this);
   TFile f(output,"recreate");
   f.cd();
@@ -1301,9 +1278,7 @@ void AliTPCClusterParam::Test(TTree * tree, const char *output){
 
 
 void AliTPCClusterParam::Print(Option_t* /*option*/) const{
-  //
-  // Print param Information
-  //
+  /// Print param Information
 
   //
   // Error parameterization
@@ -1315,8 +1290,8 @@ void AliTPCClusterParam::Print(Option_t* /*option*/) const{
   for (Int_t ipad=0; ipad<3; ipad++){
     Float_t length=0.75;
     if (ipad==1) length=1;
-    if (ipad==2) length=1.5;    
-    printf("\t%d\t%f\t%f\t%f\t%f\n", ipad, 
+    if (ipad==2) length=1.5;
+    printf("\t%d\t%f\t%f\t%f\t%f\n", ipad,
 	   TMath::Sqrt(TMath::Abs(fParamS0[0][ipad][0])),
 	   TMath::Sqrt(TMath::Abs(fParamS0[0][ipad][1]*length)),
 	   TMath::Sqrt(TMath::Abs(fParamS0[0][ipad][2]/length)),
@@ -1326,7 +1301,7 @@ void AliTPCClusterParam::Print(Option_t* /*option*/) const{
     Float_t length=0.75;
     if (ipad==1) length=1;
     if (ipad==2) length=1.5;
-    printf("\t%dPar\t%f\t%f\t%f\t%f\n", ipad, 
+    printf("\t%dPar\t%f\t%f\t%f\t%f\n", ipad,
 	   TMath::Sqrt(TMath::Abs(fParamS0Par[0][ipad][0])),
 	   TMath::Sqrt(TMath::Abs(fParamS0Par[0][ipad][1]*length)),
 	   TMath::Sqrt(TMath::Abs(fParamS0Par[0][ipad][2]/length)),
@@ -1334,12 +1309,12 @@ void AliTPCClusterParam::Print(Option_t* /*option*/) const{
   }
   printf("Z\tall\t%f\t%f\t%f\t%f\n", TMath::Sqrt(TMath::Abs(fParamS1[1][0])),TMath::Sqrt(fParamS1[1][1]),
 	 TMath::Sqrt(fParamS1[1][2]), TMath::Sqrt(fParamS1[1][3]));
-  
+
   for (Int_t ipad=0; ipad<3; ipad++){
     Float_t length=0.75;
     if (ipad==1) length=1;
-    if (ipad==2) length=1.5;    
-    printf("\t%d\t%f\t%f\t%f\t%f\n", ipad, 
+    if (ipad==2) length=1.5;
+    printf("\t%d\t%f\t%f\t%f\t%f\n", ipad,
 	   TMath::Sqrt(TMath::Abs(fParamS0[1][ipad][0])),
 	   TMath::Sqrt(TMath::Abs(fParamS0[1][ipad][1]*length)),
 	   TMath::Sqrt(TMath::Abs(fParamS0[1][ipad][2]/length)),
@@ -1348,21 +1323,21 @@ void AliTPCClusterParam::Print(Option_t* /*option*/) const{
   for (Int_t ipad=0; ipad<3; ipad++){
     Float_t length=0.75;
     if (ipad==1) length=1;
-    if (ipad==2) length=1.5;        
-    printf("\t%dPar\t%f\t%f\t%f\t%f\n", ipad, 
+    if (ipad==2) length=1.5;
+    printf("\t%dPar\t%f\t%f\t%f\t%f\n", ipad,
 	   TMath::Sqrt(TMath::Abs(TMath::Abs(fParamS0Par[1][ipad][0]))),
 	   TMath::Sqrt(TMath::Abs(fParamS0Par[1][ipad][1]*length)),
 	   TMath::Sqrt(TMath::Abs(fParamS0Par[1][ipad][2]/length)),
 	   TMath::Sqrt(TMath::Abs(fParamS0Par[1][ipad][6])));
   }
-  
+
   //
   // RMS scaling
   //
   printf("\n");
   printf("\nRMS Scaled factors\n");
   printf("Dir\tPad\tP00\t\tP01\t\tP1\t\tP2\t\tchi2\n");
-  printf("Y\tall\t%f\t%f\t%f\t%f\t%f\n", 
+  printf("Y\tall\t%f\t%f\t%f\t%f\t%f\n",
 	 TMath::Sqrt(TMath::Abs(fParamRMS1[0][0])),
 	 TMath::Sqrt(TMath::Abs(fParamRMS1[0][1])),
 	 TMath::Sqrt(TMath::Abs(fParamRMS1[0][2])),
@@ -1371,25 +1346,25 @@ void AliTPCClusterParam::Print(Option_t* /*option*/) const{
   for (Int_t ipad=0; ipad<3; ipad++){
     Float_t length=0.75;
     if (ipad==1) length=1;
-    if (ipad==2) length=1.5;    
+    if (ipad==2) length=1.5;
     if (ipad==0){
-      printf("\t%d\t%f\t%f\t%f\t%f\t%f\n", ipad, 
+      printf("\t%d\t%f\t%f\t%f\t%f\t%f\n", ipad,
 	     TMath::Sqrt(TMath::Abs(fParamRMS0[0][ipad][0])),
 	     0.,
 	     TMath::Sqrt(TMath::Abs(fParamRMS0[0][ipad][1])),
 	     TMath::Sqrt(TMath::Abs(fParamRMS0[0][ipad][2]/(length*length))),
 	     TMath::Sqrt(TMath::Abs(fParamRMS0[0][ipad][3])));
     }else{
-      printf("\t%d\t%f\t%f\t%f\t%f\t%f\n", ipad, 
+      printf("\t%d\t%f\t%f\t%f\t%f\t%f\n", ipad,
 	     0.,
 	     TMath::Sqrt(TMath::Abs(fParamRMS0[0][ipad][0])),
 	     TMath::Sqrt(TMath::Abs(fParamRMS0[0][ipad][1])),
 	     TMath::Sqrt(TMath::Abs(fParamRMS0[0][ipad][2]/(length*length))),
-	     TMath::Sqrt(TMath::Abs(fParamRMS0[0][ipad][3])));	
+	     TMath::Sqrt(TMath::Abs(fParamRMS0[0][ipad][3])));
     }
   }
   printf("\n");
-  printf("Z\tall\t%f\t%f\t%f\t%f\t%f\n", 
+  printf("Z\tall\t%f\t%f\t%f\t%f\t%f\n",
 	 TMath::Sqrt(TMath::Abs(fParamRMS1[1][0])),
 	 TMath::Sqrt(TMath::Abs(fParamRMS1[1][1])),
 	 TMath::Sqrt(TMath::Abs(fParamRMS1[1][2])),
@@ -1398,21 +1373,21 @@ void AliTPCClusterParam::Print(Option_t* /*option*/) const{
   for (Int_t ipad=0; ipad<3; ipad++){
     Float_t length=0.75;
     if (ipad==1) length=1;
-    if (ipad==2) length=1.5;    
+    if (ipad==2) length=1.5;
     if (ipad==0){
-      printf("\t%d\t%f\t%f\t%f\t%f\t%f\n", ipad, 
+      printf("\t%d\t%f\t%f\t%f\t%f\t%f\n", ipad,
 	     TMath::Sqrt(TMath::Abs(fParamRMS0[1][ipad][0])),
 	     0.,
 	     TMath::Sqrt(TMath::Abs(fParamRMS0[1][ipad][1])),
 	     TMath::Sqrt(TMath::Abs(fParamRMS0[1][ipad][2]/(length*length))),
 	     TMath::Sqrt(TMath::Abs(fParamRMS0[1][ipad][3])));
     }else{
-      printf("\t%d\t%f\t%f\t%f\t%f\t%f\n", ipad, 
+      printf("\t%d\t%f\t%f\t%f\t%f\t%f\n", ipad,
 	     0.,
 	     TMath::Sqrt(TMath::Abs(fParamRMS0[1][ipad][0])),
 	     TMath::Sqrt(TMath::Abs(fParamRMS0[1][ipad][1])),
 	     TMath::Sqrt(TMath::Abs(fParamRMS0[1][ipad][2]/(length*length))),
-	     TMath::Sqrt(TMath::Abs(fParamRMS0[1][ipad][3])));	
+	     TMath::Sqrt(TMath::Abs(fParamRMS0[1][ipad][3])));
     }
   }
   printf("\ndEdx  correction matrix used in GetQnormCorr\n");
@@ -1425,17 +1400,17 @@ void AliTPCClusterParam::Print(Option_t* /*option*/) const{
 
 
 Float_t AliTPCClusterParam::Qnorm(Int_t ipad, Int_t itype, Float_t dr, Float_t ty, Float_t tz){
-  // get Q normalization
-  // type - 0 Qtot 1 Qmax
-  // ipad - 0 (0.75 cm) ,1 (1 cm), 2 (1.5 cm)
-  //
-  //expession formula - TString *strq0 = toolkit.FitPlane(chain,"dedxQ.fElements[2]","dr++ty++tz++dr*ty++dr*tz++++dr*dr++ty*tz++ty^2++tz^2","IPad==0",chi2,npoints,param,covar,0,100000);
+  /// get Q normalization
+  /// type - 0 Qtot 1 Qmax
+  /// ipad - 0 (0.75 cm) ,1 (1 cm), 2 (1.5 cm)
+  ///
+  /// expession formula - TString *strq0 = toolkit.FitPlane(chain,"dedxQ.fElements[2]","dr++ty++tz++dr*ty++dr*tz++++dr*dr++ty*tz++ty^2++tz^2","IPad==0",chi2,npoints,param,covar,0,100000);
 
   if (fQNorm==0) return 0;
   TVectorD * norm = (TVectorD*)fQNorm->At(3*itype+ipad);
   if (!norm) return 0;
   TVectorD &no  = *norm;
-  Float_t   res = 
+  Float_t   res =
     no[0]+
     no[1]*dr+
     no[2]*ty+
@@ -1453,10 +1428,9 @@ Float_t AliTPCClusterParam::Qnorm(Int_t ipad, Int_t itype, Float_t dr, Float_t t
 
 
 Float_t AliTPCClusterParam::QnormHis(Int_t ipad, Int_t itype, Float_t dr, Float_t p2, Float_t p3){
-  // get Q normalization
-  // type - 0 Qtot 1 Qmax
-  // ipad - 0 (0.75 cm) ,1 (1 cm), 2 (1.5 cm)
-  //
+  /// get Q normalization
+  /// type - 0 Qtot 1 Qmax
+  /// ipad - 0 (0.75 cm) ,1 (1 cm), 2 (1.5 cm)
 
   if (fQNormHis==0) return 0;
   TH3F * norm = (TH3F*)fQNormHis->At(4*itype+ipad);
@@ -1472,7 +1446,7 @@ Float_t AliTPCClusterParam::QnormHis(Int_t ipad, Int_t itype, Float_t dr, Float_
   p3=TMath::Max(p3,Float_t(norm->GetZaxis()->GetXmin()+norm->GetZaxis()->GetBinWidth(0)));
   //
   Double_t res = norm->GetBinContent(norm->FindBin(dr,p2,p3));
-  if (res==0) res = norm->GetBinContent(norm->FindBin(0.5,0.5,0.5));  // This is just hack - to be fixed entries without 
+  if (res==0) res = norm->GetBinContent(norm->FindBin(0.5,0.5,0.5));  // This is just hack - to be fixed entries without
 
   return res;
 }
@@ -1480,39 +1454,36 @@ Float_t AliTPCClusterParam::QnormHis(Int_t ipad, Int_t itype, Float_t dr, Float_
 
 
 void AliTPCClusterParam::SetQnorm(Int_t ipad, Int_t itype, const TVectorD *const norm){
-  //
-  // set normalization
-  //
-  // type - 0 Qtot 1 Qmax
-  // ipad - 0 (0.75 cm) ,1 (1 cm), 2 (1.5 cm)
-  //
+  /// set normalization
+  ///
+  /// type - 0 Qtot 1 Qmax
+  /// ipad - 0 (0.75 cm) ,1 (1 cm), 2 (1.5 cm)
 
   if (fQNorm==0) fQNorm = new TObjArray(6);
   fQNorm->AddAt(new TVectorD(*norm), itype*3+ipad);
 }
 
 void AliTPCClusterParam::ResetQnormCorr(){
-  //
-  //
-  //
+  ///
+
   if (!fQNormCorr) fQNormCorr= new TMatrixD(12,6);
   for (Int_t irow=0;irow<12; irow++)
     for (Int_t icol=0;icol<6; icol++){
       (*fQNormCorr)(irow,icol)=1.;             // default - no correction
       if (irow>5) (*fQNormCorr)(irow,icol)=0.; // default - no correction
-    } 
+    }
 }
 
 void AliTPCClusterParam::SetQnormCorr(Int_t ipad, Int_t itype, Int_t corrType, Float_t val, Int_t mode){
-  //
-  // ipad        - pad type
-  // itype       - 0- qtot 1-qmax
-  // corrType    - 0 - s0y corr     - eff. PRF corr
-  //             - 1 - s0z corr     - eff. TRF corr
-  //             - 2 - d0y          - eff. diffusion correction y
-  //             - 3 - d0z          - eff. diffusion correction
-  //             - 4 - eff length   - eff.length - wire pitch + x diffsion
-  //             - 5 - pad type normalization
+  /// ipad        - pad type
+  /// itype       - 0- qtot 1-qmax
+  /// corrType    - 0 - s0y corr     - eff. PRF corr
+  /// - 1 - s0z corr     - eff. TRF corr
+  /// - 2 - d0y          - eff. diffusion correction y
+  /// - 3 - d0z          - eff. diffusion correction
+  /// - 4 - eff length   - eff.length - wire pitch + x diffsion
+  /// - 5 - pad type normalization
+
   if (!fQNormCorr) {
     ResetQnormCorr();
   }
@@ -1521,40 +1492,37 @@ void AliTPCClusterParam::SetQnormCorr(Int_t ipad, Int_t itype, Int_t corrType, F
   //
   // rows
   // itype*3+ipad  - itype=0 qtot itype=1 qmax ipad=0
-  // 
-  if (mode==1) { 
+  //
+  if (mode==1) {
     // mode introduced in 20.07.2014 - git describe ~ vAN-20140703-48-g3449a97 - to keep back compatibility with o
     (*fQNormCorr)(itype*3+ipad, corrType) = val;  // set value
     return;
   }
   if (itype<2) (*fQNormCorr)(itype*3+ipad, corrType) *= val;  // multiplicative correction
-  if (itype>=2) (*fQNormCorr)(itype*3+ipad, corrType)+= val;  // additive       correction  
+  if (itype>=2) (*fQNormCorr)(itype*3+ipad, corrType)+= val;  // additive       correction
 }
 
 Double_t  AliTPCClusterParam::GetQnormCorr(Int_t ipad, Int_t itype, Int_t corrType) const{
-  //
-  // see AliTPCClusterParam::SetQnormCorr
-  //
+  /// see AliTPCClusterParam::SetQnormCorr
+
   if (!fQNormCorr) return 0;
   return  (*fQNormCorr)(itype*3+ipad, corrType);
 }
 
 
 Float_t AliTPCClusterParam::QnormPos(Int_t ipad,Bool_t isMax, Float_t pad, Float_t time, Float_t z, Float_t sy2, Float_t sz2, Float_t qm, Float_t qt){
-  //
-  // Make Q normalization as function of following parameters
-  // Fit parameters to be used in corresponding correction function extracted in the AliTPCclaibTracksGain - Taylor expansion
-  // 1 - dp   - relative pad position 
-  // 2 - dt   - relative time position
-  // 3 - di   - drift length (norm to 1);
-  // 4 - dq0  - Tot/Max charge
-  // 5 - dq1  - Max/Tot charge
-  // 6 - sy   - sigma y - shape
-  // 7 - sz   - sigma z - shape
-  //  
-  
-  //The results can be visualized using the debug streamer information of the AliTPCcalibTracksGain - 
-  // Following variable used - correspondance to the our variable conventions  
+  /// Make Q normalization as function of following parameters
+  /// Fit parameters to be used in corresponding correction function extracted in the AliTPCclaibTracksGain - Taylor expansion
+  /// 1 - dp   - relative pad position
+  /// 2 - dt   - relative time position
+  /// 3 - di   - drift length (norm to 1);
+  /// 4 - dq0  - Tot/Max charge
+  /// 5 - dq1  - Max/Tot charge
+  /// 6 - sy   - sigma y - shape
+  /// 7 - sz   - sigma z - shape
+
+  //The results can be visualized using the debug streamer information of the AliTPCcalibTracksGain -
+  // Following variable used - correspondance to the our variable conventions
   //chain0->SetAlias("dp","((Cl.fPad-int(Cl.fPad)-0.5)/0.5)");
   Double_t dp = ((pad-int(pad)-0.5)*2.);
   //chain0->SetAlias("dt","((Cl.fTimeBin-int(Cl.fTimeBin)-0.5)/0.5)");
@@ -1576,12 +1544,12 @@ Float_t AliTPCClusterParam::QnormPos(Int_t ipad,Bool_t isMax, Float_t pad, Float
   if (isMax){
     pvec = fPosQMnorm[ipad];
   }else{
-    pvec = fPosQTnorm[ipad];    
+    pvec = fPosQTnorm[ipad];
   }
   TVectorD &param = *pvec;
   //
   // Eval part  - in correspondance with fit part from debug streamer
-  // 
+  //
   Double_t result=param[0];
   Int_t index =1;
   //
@@ -1622,7 +1590,7 @@ Float_t AliTPCClusterParam::QnormPos(Int_t ipad,Bool_t isMax, Float_t pad, Float
   if (result>1.25) result=1.25;
 
   return result;
-  
+
 }
 
 
@@ -1631,15 +1599,14 @@ Float_t AliTPCClusterParam::QnormPos(Int_t ipad,Bool_t isMax, Float_t pad, Float
 
 Float_t AliTPCClusterParam::PosCorrection(Int_t type, Int_t ipad,  Float_t pad, Float_t time, Float_t z, Float_t /*sy2*/, Float_t /*sz2*/, Float_t /*qm*/){
 
-  //
-  // Make postion correction
-  // type - 0 - y correction
-  //        1 - z correction
-  // ipad - 0, 1, 2 - short, medium long pads 
-  // pad  - float pad number          
-  // time - float time bin number
-  //    z - z of the cluster
-  
+  /// Make postion correction
+  /// type - 0 - y correction
+  ///        1 - z correction
+  /// ipad - 0, 1, 2 - short, medium long pads
+  /// pad  - float pad number
+  /// time - float time bin number
+  ///    z - z of the cluster
+
   //
   //chainres->SetAlias("dp","(-1+(Cl.fZ>0)*2)*((Cl.fPad-int(Cl.fPad))-0.5)");
   //chainres->SetAlias("dt","(-1+(Cl.fZ>0)*2)*((Cl.fTimeBin-0.66-int(Cl.fTimeBin-0.66))-0.5)");
@@ -1664,7 +1631,7 @@ Float_t AliTPCClusterParam::PosCorrection(Int_t type, Int_t ipad,  Float_t pad,
   if (type==0){
     pvec = fPosYcor[ipad];
   }else{
-    pvec = fPosZcor[ipad];    
+    pvec = fPosZcor[ipad];
   }
   TVectorD &param = *pvec;
   //
@@ -1693,14 +1660,13 @@ Float_t AliTPCClusterParam::PosCorrection(Int_t type, Int_t ipad,  Float_t pad,
 
 
 Double_t  AliTPCClusterParam::GaussConvolution(Double_t x0, Double_t x1, Double_t k0, Double_t k1, Double_t s0, Double_t s1){
-  //
-  // 2 D gaus convoluted with angular effect
-  // See in mathematica: 
-  //Simplify[Integrate[Exp[-(x0-k0*xd)*(x0-k0*xd)/(2*s0*s0)-(x1-k1*xd)*(x1-k1*xd)/(2*s1*s1)]/(s0*s1),{xd,-1/2,1/2}]]
-  // 
-  //TF1 f1("f1","AliTPCClusterParam::GaussConvolution(x,0,1,0,0.1,0.1)",-2,2)
-  //TF2 f2("f2","AliTPCClusterParam::GaussConvolution(x,y,1,1,0.1,0.1)",-2,2,-2,2)
-  //
+  /// 2 D gaus convoluted with angular effect
+  /// See in mathematica:
+  /// Simplify[Integrate[Exp[-(x0-k0*xd)*(x0-k0*xd)/(2*s0*s0)-(x1-k1*xd)*(x1-k1*xd)/(2*s1*s1)]/(s0*s1),{xd,-1/2,1/2}]]
+  ///
+  /// TF1 f1("f1","AliTPCClusterParam::GaussConvolution(x,0,1,0,0.1,0.1)",-2,2)
+  /// TF2 f2("f2","AliTPCClusterParam::GaussConvolution(x,y,1,1,0.1,0.1)",-2,2,-2,2)
+
   const Double_t kEpsilon = 0.0001;
   const Double_t twoPi = TMath::TwoPi();
   const Double_t hnorm = 0.5/TMath::Sqrt(twoPi);
@@ -1727,13 +1693,13 @@ Double_t  AliTPCClusterParam::GaussConvolution(Double_t x0, Double_t x1, Double_
 
 
 Double_t  AliTPCClusterParam::GaussConvolutionTail(Double_t x0, Double_t x1, Double_t k0, Double_t k1, Double_t s0, Double_t s1, Double_t tau){
-  //
-  // 2 D gaus convoluted with angular effect and exponential tail in z-direction
-  // tail integrated numerically 
-  // Integral normalized to one
-  // Mean at 0
-  // 
-  // TF1 f1t("f1t","AliTPCClusterParam::GaussConvolutionTail(0,x,0,0,0.5,0.5,0.9)",-5,5)
+  /// 2 D gaus convoluted with angular effect and exponential tail in z-direction
+  /// tail integrated numerically
+  /// Integral normalized to one
+  /// Mean at 0
+  ///
+  /// TF1 f1t("f1t","AliTPCClusterParam::GaussConvolutionTail(0,x,0,0,0.5,0.5,0.9)",-5,5)
+
   Double_t sum =1, mean=0;
   // the COG of exponent
   for (Float_t iexp=0;iexp<5;iexp+=0.2){
@@ -1752,14 +1718,14 @@ Double_t  AliTPCClusterParam::GaussConvolutionTail(Double_t x0, Double_t x1, Dou
 }
 
 Double_t  AliTPCClusterParam::GaussConvolutionGamma4(Double_t x0, Double_t x1, Double_t k0, Double_t k1, Double_t s0, Double_t s1, Double_t tau){
-  //
-  // 2 D gaus convoluted with angular effect and exponential tail in z-direction
-  // tail integrated numerically 
-  // Integral normalized to one
-  // Mean at 0
-  // 
-  // TF1 f1g4("f1g4","AliTPCClusterParam::GaussConvolutionGamma4(0,x,0,0,0.5,0.2,1.6)",-5,5)
-  // TF2 f2g4("f2g4","AliTPCClusterParam::GaussConvolutionGamma4(y,x,0,0,0.5,0.2,1.6)",-5,5,-5,5)
+  /// 2 D gaus convoluted with angular effect and exponential tail in z-direction
+  /// tail integrated numerically
+  /// Integral normalized to one
+  /// Mean at 0
+  ///
+  /// TF1 f1g4("f1g4","AliTPCClusterParam::GaussConvolutionGamma4(0,x,0,0,0.5,0.2,1.6)",-5,5)
+  /// TF2 f2g4("f2g4","AliTPCClusterParam::GaussConvolutionGamma4(y,x,0,0,0.5,0.2,1.6)",-5,5,-5,5)
+
   Double_t sum =0, mean=0;
   // the COG of G4
   for (Float_t iexp=0;iexp<5;iexp+=0.2){
@@ -1771,7 +1737,7 @@ Double_t  AliTPCClusterParam::GaussConvolutionGamma4(Double_t x0, Double_t x1, D
   //
   sum = 0;
   Double_t val = 0;
-  for (Float_t iexp=0;iexp<5;iexp+=0.2){ 
+  for (Float_t iexp=0;iexp<5;iexp+=0.2){
     Double_t g4 = TMath::Exp(-4.*iexp/tau)*TMath::Power(iexp/tau,4.);
     val+=GaussConvolution(x0,x1+mean-iexp, k0, k1 , s0,s1)*g4;
     sum+=g4;
@@ -1780,26 +1746,24 @@ Double_t  AliTPCClusterParam::GaussConvolutionGamma4(Double_t x0, Double_t x1, D
 }
 
 Double_t  AliTPCClusterParam::QmaxCorrection(Int_t sector, Int_t row, Float_t cpad, Float_t ctime, Float_t ky, Float_t kz, Float_t rmsy0, Float_t rmsz0, Float_t effPad, Float_t effDiff){
-  //
-  //
-  // cpad      - pad (y) coordinate
-  // ctime     - time(z) coordinate
-  // ky        - dy/dx
-  // kz        - dz/dx
-  // rmsy0     - RF width in pad units
-  // rmsz0     - RF width in time bin  units
-  // effLength - contibution of PRF and diffusion
-  // effDiff   - overwrite diffusion
+  /// cpad      - pad (y) coordinate
+  /// ctime     - time(z) coordinate
+  /// ky        - dy/dx
+  /// kz        - dz/dx
+  /// rmsy0     - RF width in pad units
+  /// rmsz0     - RF width in time bin  units
+  /// effLength - contibution of PRF and diffusion
+  /// effDiff   - overwrite diffusion
 
   // Response function aproximated by convolution of gaussian with angular effect (integral=1)
-  //  
-  // Gaus width sy and sz is determined by RF width and diffusion 
+  //
+  // Gaus width sy and sz is determined by RF width and diffusion
   // Integral of Q is equal 1
   // Q max is calculated at position cpad, ctime
-  // Example function:         
-  //  TF1 f1("f1", "AliTPCClusterParam::QmaxCorrection(0,0.5,x,0,0,0.5,0.6)",0,1000) 
+  // Example function:
+  //  TF1 f1("f1", "AliTPCClusterParam::QmaxCorrection(0,0.5,x,0,0,0.5,0.6)",0,1000)
   //
-  AliTPCParam * param   = AliTPCcalibDB::Instance()->GetParameters(); 
+  AliTPCParam * param   = AliTPCcalibDB::Instance()->GetParameters();
   Double_t padLength= param->GetPadPitchLength(sector,row);
   Double_t padWidth = param->GetPadPitchWidth(sector);
   Double_t zwidth   = param->GetZWidth();
@@ -1821,35 +1785,33 @@ Double_t  AliTPCClusterParam::QmaxCorrection(Int_t sector, Int_t row, Float_t cp
   //
   //
   Double_t sy = TMath::Sqrt(rmsy0*rmsy0+diffT*diffT);
-  Double_t sz = TMath::Sqrt(rmsz0*rmsz0+diffL*diffL); 
+  Double_t sz = TMath::Sqrt(rmsz0*rmsz0+diffL*diffL);
   //return GaussConvolutionGamma4(py,pz, pky,pkz,sy,sz,tau);
   Double_t length = padLength*TMath::Sqrt(1+ky*ky+kz*kz);
   return GaussConvolution(py,pz, pky,pkz,sy,sz)*length;
 }
 
 Double_t  AliTPCClusterParam::QtotCorrection(Int_t sector, Int_t row, Float_t cpad, Float_t ctime, Float_t ky, Float_t kz, Float_t rmsy0, Float_t rmsz0,  Float_t qtot, Float_t thr, Float_t effPad, Float_t effDiff){
-  //
-  //
-  // cpad      - pad (y) coordinate
-  // ctime     - time(z) coordinate
-  // ky        - dy/dx
-  // kz        - dz/dx
-  // rmsy0     - RF width in pad units
-  // rmsz0     - RF width in time bin  units
-  // qtot      - the sum of signal in cluster - without thr correction
-  // thr       - threshold
-  // effLength - contibution of PRF and diffusion
-  // effDiff   - overwrite diffusion
+  /// cpad      - pad (y) coordinate
+  /// ctime     - time(z) coordinate
+  /// ky        - dy/dx
+  /// kz        - dz/dx
+  /// rmsy0     - RF width in pad units
+  /// rmsz0     - RF width in time bin  units
+  /// qtot      - the sum of signal in cluster - without thr correction
+  /// thr       - threshold
+  /// effLength - contibution of PRF and diffusion
+  /// effDiff   - overwrite diffusion
 
   // Response function aproximated by convolution of gaussian with angular effect (integral=1)
-  //  
-  // Gaus width sy and sz is determined by RF width and diffusion 
+  //
+  // Gaus width sy and sz is determined by RF width and diffusion
   // Integral of Q is equal 1
   // Q max is calculated at position cpad, ctime
-  //          
-  //  
   //
-  AliTPCParam * param   = AliTPCcalibDB::Instance()->GetParameters(); 
+  //
+  //
+  AliTPCParam * param   = AliTPCcalibDB::Instance()->GetParameters();
   Double_t padLength= param->GetPadPitchLength(sector,row);
   Double_t padWidth = param->GetPadPitchWidth(sector);
   Double_t zwidth   = param->GetZWidth();
@@ -1861,16 +1823,16 @@ Double_t  AliTPCClusterParam::QtotCorrection(Int_t sector, Int_t row, Float_t cp
   diffT*=effDiff;  //
   diffL*=effDiff;  //
   //
-  // transform angular effect to pad units 
+  // transform angular effect to pad units
   Double_t pky   = ky*effLength/padWidth;
   Double_t pkz   = kz*effLength/zwidth;
   // position in pad unit
-  //  
+  //
   Double_t py = (cpad+0.5)-TMath::Nint(cpad+0.5);
   Double_t pz = (ctime+0.5)-TMath::Nint(ctime+0.5);
   //
   Double_t sy = TMath::Sqrt(rmsy0*rmsy0+diffT*diffT);
-  Double_t sz = TMath::Sqrt(rmsz0*rmsz0+diffL*diffL); 
+  Double_t sz = TMath::Sqrt(rmsz0*rmsz0+diffL*diffL);
   //
   //
   //
@@ -1880,8 +1842,8 @@ Double_t  AliTPCClusterParam::QtotCorrection(Int_t sector, Int_t row, Float_t cp
   Double_t qnorm=qtot;
   for (Float_t iy=-3;iy<=3;iy+=1.)
     for (Float_t iz=-4;iz<=4;iz+=1.){
-      //      Double_t val = GaussConvolutionGamma4(py-iy,pz-iz, pky,pkz, sy,sz,tau);      
-      Double_t val = GaussConvolution(py-iy,pz-iz, pky,pkz, sy,sz);      
+      //      Double_t val = GaussConvolutionGamma4(py-iy,pz-iz, pky,pkz, sy,sz,tau);
+      Double_t val = GaussConvolution(py-iy,pz-iz, pky,pkz, sy,sz);
       Double_t qlocal =qnorm*val;
       if (TMath::Abs(iy)<1.5&&TMath::Abs(iz)<1.5){
       	sumThr+=qlocal;   // Virtual charge used in cluster finder
@@ -1903,9 +1865,8 @@ Double_t  AliTPCClusterParam::QtotCorrection(Int_t sector, Int_t row, Float_t cp
 
 void AliTPCClusterParam::SetWaveCorrectionMap( THnBase *Map)
 {
-  //
-  // Set Correction Map for Y
-  //
+  /// Set Correction Map for Y
+
   delete fWaveCorrectionMap;
   fWaveCorrectionMap = 0;
   fWaveCorrectionMirroredPad = kFALSE;
@@ -1923,9 +1884,8 @@ void AliTPCClusterParam::SetWaveCorrectionMap( THnBase *Map)
 
 void AliTPCClusterParam::SetResolutionYMap( THnBase *Map)
 {
-  //
-  // Set Resolution Map for Y
-  //
+  /// Set Resolution Map for Y
+
   delete fResolutionYMap;
   fResolutionYMap = 0;
   if( Map ){
@@ -1935,16 +1895,14 @@ void AliTPCClusterParam::SetResolutionYMap( THnBase *Map)
 
 Float_t AliTPCClusterParam::GetWaveCorrection(Int_t Type, Float_t Z, Int_t QMax, Float_t Pad, Float_t angleY ) const
 {
-  //
-  // Correct Y cluster coordinate using a map
-  //
+  /// Correct Y cluster coordinate using a map
 
   if( !fWaveCorrectionMap ) return 0;
   Bool_t swapY = kFALSE;
   Pad = Pad-(Int_t)Pad;
 
   if( TMath::Abs(Pad-0.5)<1.e-8 ){// one pad clusters a stored in underflow bins
-    Pad = -1.; 
+    Pad = -1.;
   } else {
     if( fWaveCorrectionMirroredPad && (Pad<0.5) ){ // cog axis is mirrored at 0.5
 	swapY = !swapY;
@@ -1956,10 +1914,10 @@ Float_t AliTPCClusterParam::GetWaveCorrection(Int_t Type, Float_t Z, Int_t QMax,
     swapY = !swapY;
     Z = -Z;
   }
-  
+
   if( fWaveCorrectionMirroredAngle && (angleY<0) ){ // Angle axis is mirrored at 0
     angleY = -angleY;
-  }  
+  }
   double var[5] = { static_cast<double>(Type), Z, static_cast<double>(QMax), Pad, angleY };
   Long64_t bin = fWaveCorrectionMap->GetBin(var, kFALSE );
   if( bin<0 ) return 0;
diff --git a/TPC/TPCbase/AliTPCClusterParam.h b/TPC/TPCbase/AliTPCClusterParam.h
index baa695b8fd3..4a7ad95dde9 100644
--- a/TPC/TPCbase/AliTPCClusterParam.h
+++ b/TPC/TPCbase/AliTPCClusterParam.h
@@ -5,11 +5,8 @@
 
 /* $Id: AliTPCClusterParam.h,v */
 
-////////////////////////////////////////////////////
-//                                                //
-//  TPC cluster error and shape parameterization  //
-//                                                //
-////////////////////////////////////////////////////
+/// \class AliTPCClusterParam
+/// \brief TPC cluster error and shape parameterization
 
 
 #include <TObject.h>
@@ -36,23 +33,23 @@ class AliTPCClusterParam : public TObject {
   void FitData(TTree * tree);
   void FitResol(TTree * tree);
   void FitRMS(TTree * tree);
-  void SetQnorm(Int_t ipad, Int_t itype,  const TVectorD *const norm); 
-  void SetQnormCorr(Int_t ipad, Int_t itype, Int_t corrType, Float_t val, Int_t mode=1); 
+  void SetQnorm(Int_t ipad, Int_t itype,  const TVectorD *const norm);
+  void SetQnormCorr(Int_t ipad, Int_t itype, Int_t corrType, Float_t val, Int_t mode=1);
   Double_t  GetQnormCorr(Int_t ipad, Int_t itype, Int_t corrType) const;
   TMatrixD *GetQnormCorrMatrix(){return fQNormCorr;};
-  void ResetQnormCorr(); 
+  void ResetQnormCorr();
   void SetWaveCorrectionMap( THnBase *WaveCorrectionMap);
   void SetResolutionYMap( THnBase *ResolutionYMap);
   //
   // Charge parameterization
   //
-  Float_t Qnorm(Int_t ipad, Int_t itype, Float_t dr, Float_t ty, Float_t tz);   
+  Float_t Qnorm(Int_t ipad, Int_t itype, Float_t dr, Float_t ty, Float_t tz);
   Float_t QnormHis(Int_t ipad, Int_t itype, Float_t dr, Float_t ty, Float_t tz);
 
 
   Float_t QnormPos(Int_t ipad, Bool_t isMax,  Float_t pad, Float_t time, Float_t z, Float_t sy2, Float_t sz2, Float_t qm, Float_t qt);
   static Float_t SQnormPos(Int_t ipad, Bool_t isMax,  Float_t pad, Float_t time, Float_t z, Float_t sy2, Float_t sz2, Float_t qm, Float_t qt){ return fgInstance->QnormPos(ipad,isMax,pad,time,z,sy2,sz2,qm,qt);;}
- 
+
   Float_t PosCorrection(Int_t type, Int_t ipad,  Float_t pad, Float_t time, Float_t z, Float_t sy2, Float_t sz2, Float_t qm);
   static Float_t  SPosCorrection(Int_t type, Int_t ipad,  Float_t pad, Float_t time, Float_t z, Float_t sy2, Float_t sz2, Float_t qm){ return fgInstance->PosCorrection(type,ipad,pad,time,z,sy2,sz2,qm);}
   //
@@ -72,7 +69,7 @@ class AliTPCClusterParam : public TObject {
   Float_t GetRMSQ(Int_t dim, Int_t type, Float_t z, Float_t angle, Float_t Qmean) const;
   Float_t GetRMSSigma(Int_t dim, Int_t type, Float_t z, Float_t angle, Float_t Qmean) const;
   Float_t GetShapeFactor(Int_t dim, Int_t type, Float_t z, Float_t angle, Float_t Qmean, Float_t rmsL, Float_t rmsM) const;
-  // 
+  //
   // Correction and resolution maps
   //
   const THnBase *GetWaveCorrectionMap() const { return fWaveCorrectionMap; }
@@ -84,7 +81,7 @@ class AliTPCClusterParam : public TObject {
   //
   void Test(TTree * tree, const char *output="TestClusterParam.root");
   //
-  // static methods equivalents  - use instance of param object - useful for tree draw and TF2 visualization 
+  // static methods equivalents  - use instance of param object - useful for tree draw and TF2 visualization
   static Float_t SGetError0(Int_t dim, Int_t type, Float_t z, Float_t angle){
     return fgInstance->GetError0(dim,type,z,angle);
   }
@@ -143,8 +140,8 @@ class AliTPCClusterParam : public TObject {
   void FitResolQPar(TTree * tree, Int_t dim, Int_t type, Float_t *param0, Float_t *error);
   void FitRMS0(TTree * tree, Int_t dim, Int_t type, Float_t *param0, Float_t *error);
   void FitRMS1(TTree * tree, Int_t dim, Float_t *param0, Float_t *error);
-  void FitRMSQ(TTree * tree, Int_t dim, Int_t type, Float_t *param0, Float_t *error);  
-  void FitRMSSigma(TTree * tree, Int_t dim, Int_t type, Float_t *param0, Float_t *error);  
+  void FitRMSQ(TTree * tree, Int_t dim, Int_t type, Float_t *param0, Float_t *error);
+  void FitRMSSigma(TTree * tree, Int_t dim, Int_t type, Float_t *param0, Float_t *error);
   //
   TVectorD*& PosYcor(Int_t ind) {return fPosYcor[ind];}
   TVectorD*& PosZcor(Int_t ind) {return fPosZcor[ind];}
@@ -153,57 +150,59 @@ class AliTPCClusterParam : public TObject {
   TVectorD* QpadMnorm() const {return fQpadMnorm;}
 
 protected:
-  Float_t fRatio;               //ratio of values constibution to error
-  Float_t fParamS0[2][3][4];    //error parameterization coeficients
-  Float_t fErrorS0[2][3][4];    //error parameterization coeficients
-  Float_t fParamS0Par[2][3][7];    //error parameterization coeficients
-  Float_t fErrorS0Par[2][3][7];    //error parameterization coeficients  
-  Float_t fParamSQ[2][3][6];    //error parameterization coeficients
-  Float_t fErrorSQ[2][3][6];    //error parameterization coeficients
-  Float_t fParamSQPar[2][3][9];    //error parameterization coeficients
-  Float_t fErrorSQPar[2][3][9];    //error parameterization coeficients
-  Float_t fParamS1[2][4];       //error parameterization coeficients
-  Float_t fErrorS1[2][4];       //error parameterization coeficients
-  //
-  Float_t fParamRMS0[2][3][4];   //shape parameterization coeficients
-  Float_t fErrorRMS0[2][3][4];   //shape parameterization coeficients
-  Float_t fParamRMSQ[2][3][6];   //shape parameterization coeficients
-  Float_t fErrorRMSQ[2][3][6];   //shape parameterization coeficients
-  Float_t fParamRMS1[2][5];      //shape parameterization coeficients
-  Float_t fErrorRMS1[2][5];      //shape parameterization coeficients
-  Float_t fErrorRMSSys[2];        // systematic relative error of the parametererization
-  Float_t fRMSSigmaRatio[2][2];   // mean value of the varation of RMS to RMS
-  Float_t fRMSSigmaFit[2][3][2];   // mean value of the varation of RMS to RMS
+  Float_t fRatio;               ///< ratio of values constibution to error
+  Float_t fParamS0[2][3][4];    ///< error parameterization coeficients
+  Float_t fErrorS0[2][3][4];    ///< error parameterization coeficients
+  Float_t fParamS0Par[2][3][7];    ///< error parameterization coeficients
+  Float_t fErrorS0Par[2][3][7];    ///< error parameterization coeficients
+  Float_t fParamSQ[2][3][6];    ///< error parameterization coeficients
+  Float_t fErrorSQ[2][3][6];    ///< error parameterization coeficients
+  Float_t fParamSQPar[2][3][9];    ///< error parameterization coeficients
+  Float_t fErrorSQPar[2][3][9];    ///< error parameterization coeficients
+  Float_t fParamS1[2][4];       ///< error parameterization coeficients
+  Float_t fErrorS1[2][4];       ///< error parameterization coeficients
+  //
+  Float_t fParamRMS0[2][3][4];   ///< shape parameterization coeficients
+  Float_t fErrorRMS0[2][3][4];   ///< shape parameterization coeficients
+  Float_t fParamRMSQ[2][3][6];   ///< shape parameterization coeficients
+  Float_t fErrorRMSQ[2][3][6];   ///< shape parameterization coeficients
+  Float_t fParamRMS1[2][5];      ///< shape parameterization coeficients
+  Float_t fErrorRMS1[2][5];      ///< shape parameterization coeficients
+  Float_t fErrorRMSSys[2];        ///< systematic relative error of the parametererization
+  Float_t fRMSSigmaRatio[2][2];   ///< mean value of the varation of RMS to RMS
+  Float_t fRMSSigmaFit[2][3][2];   ///< mean value of the varation of RMS to RMS
   //
   // charge normalization parametrization
   //
-  TObjArray *fQNorm;              // q norm paramters
-  TMatrixD  *fQNormCorr;          // q norm correction for analytica  correction
-  TObjArray *fQNormHis;           // q norm correction for analytical correction 
+  TObjArray *fQNorm;              ///< q norm paramters
+  TMatrixD  *fQNormCorr;          ///< q norm correction for analytica  correction
+  TObjArray *fQNormHis;           ///< q norm correction for analytical correction
   //
-  TVectorD  *fPosQTnorm[3];       // q position normalization
-  TVectorD  *fPosQMnorm[3];       // q position normalization
-  TVectorD  *fQpadTnorm;          // q pad normalization - Total charge
-  TVectorD  *fQpadMnorm;          // q pad normalization - Max charge
+  TVectorD  *fPosQTnorm[3];       ///< q position normalization
+  TVectorD  *fPosQMnorm[3];       ///< q position normalization
+  TVectorD  *fQpadTnorm;          ///< q pad normalization - Total charge
+  TVectorD  *fQpadMnorm;          ///< q pad normalization - Max charge
   //
   // Position corrections
-  // 
-  TVectorD  *fPosYcor[3];       //  position correction parameterization 
-  TVectorD  *fPosZcor[3];       //  position correction parameterization
   //
-  // Wave Correction Map 
+  TVectorD  *fPosYcor[3];       ///< position correction parameterization
+  TVectorD  *fPosZcor[3];       ///< position correction parameterization
+  //
+  // Wave Correction Map
   //
-  THnBase* fWaveCorrectionMap; //dY with respect to the distance to the center of the pad
-  Bool_t   fWaveCorrectionMirroredPad;   // flag is the cog axis mirrored at 0.5
-  Bool_t   fWaveCorrectionMirroredZ;     // flag is the Z axis mirrored at 0
-  Bool_t   fWaveCorrectionMirroredAngle; // flag is the Angle axis mirrored at 0
+  THnBase* fWaveCorrectionMap; ///< dY with respect to the distance to the center of the pad
+  Bool_t   fWaveCorrectionMirroredPad;   ///< flag is the cog axis mirrored at 0.5
+  Bool_t   fWaveCorrectionMirroredZ;     ///< flag is the Z axis mirrored at 0
+  Bool_t   fWaveCorrectionMirroredAngle; ///< flag is the Angle axis mirrored at 0
   //
   // Resolution Map
   //
-  THnBase* fResolutionYMap; // Map of resolution in Y
+  THnBase* fResolutionYMap; ///< Map of resolution in Y
   //
-  static AliTPCClusterParam*   fgInstance; //! Instance of this class (singleton implementation)
+  static AliTPCClusterParam*   fgInstance; //!< Instance of this class (singleton implementation)
+  /// \cond CLASSIMP
   ClassDef(AliTPCClusterParam,7)    //  TPC Cluster parameter class
+  /// \endcond
 };
 
 #endif
diff --git a/TPC/TPCbase/AliTPCClustersRow.cxx b/TPC/TPCbase/AliTPCClustersRow.cxx
index 49f62397049..a70f42470b2 100644
--- a/TPC/TPCbase/AliTPCClustersRow.cxx
+++ b/TPC/TPCbase/AliTPCClustersRow.cxx
@@ -12,18 +12,16 @@
  * about the suitability of this software for any purpose. It is          *
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
- 
+
 /* $Id$ */
 
-///////////////////////////////////////////////////////////////////////////////
-//                                                                           //
-//  Time Projection Chamber AliTPCClusterRow  objects
-//  -   clusters for given segment of TPC                                //
-//
-//  Origin: Marian Ivanov , GSI Darmstadt
-//                                                                           //
-//                                                                          //
-///////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCClustersRow
+/// \brief Time Projection Chamber AliTPCClusterRow  objects
+///
+/// -   clusters for given segment of TPC
+///
+/// \author Marian Ivanov , GSI Darmstadt
+
 #include <TClass.h>
 #include "AliClusters.h"
 #include "AliTPCclusterMI.h"
@@ -32,17 +30,19 @@
 #include <TClonesArray.h>
 
 
-const Int_t kDefSize = 1;  //defalut size
+const Int_t kDefSize = 1;  ///< defalut size
 
 
-ClassImp(AliTPCClustersRow) 
+/// \cond CLASSIMP
+ClassImp(AliTPCClustersRow)
+/// \endcond
 
 
 //*****************************************************************************
 //
 //_____________________________________________________________________________
-AliTPCClustersRow::AliTPCClustersRow() 
-{  
+AliTPCClustersRow::AliTPCClustersRow()
+{
   //
   //default constructor
   fNclusters=0;
@@ -51,16 +51,16 @@ AliTPCClustersRow::AliTPCClustersRow()
 //____________________________________________________________________________
 AliTPCClustersRow::AliTPCClustersRow(const char *classname) : AliClusters(classname)
 {
- // special constructor
+ /// special constructor
+
  fNclusters=0;
 }
 
 //_____________________________________________________________________________
-TObject *AliTPCClustersRow::InsertCluster(const TObject *c) 
-{    
-  //
-  // Add a simulated cluster copy to the list
-  //
+TObject *AliTPCClustersRow::InsertCluster(const TObject *c)
+{
+  /// Add a simulated cluster copy to the list
+
   if (fClass==0) {
     Error("AliClusters", "class type not specified");
     return 0;
@@ -73,7 +73,8 @@ TObject *AliTPCClustersRow::InsertCluster(const TObject *c)
 
 
 TObject *AliTPCClustersRow::Append(){
- //create new object return pointer to this object
+ /// create new object return pointer to this object
+
  return fClusters->operator[](fClusters->GetEntriesFast());
 }
 
diff --git a/TPC/TPCbase/AliTPCClustersRow.h b/TPC/TPCbase/AliTPCClustersRow.h
index 91be9406dfc..071c259cbf9 100644
--- a/TPC/TPCbase/AliTPCClustersRow.h
+++ b/TPC/TPCbase/AliTPCClustersRow.h
@@ -5,9 +5,8 @@
 
 /* $Id$ */
 
-////////////////////////////////////////////////
-//  Manager class for TPC   clusters                   //
-////////////////////////////////////////////////
+/// \class AliTPCClustersRow
+/// \brief Manager class for TPC   clusters
 
 
 #include "AliClusters.h"
@@ -23,9 +22,11 @@ public:
   virtual TObject *Append();  //create new object return pointer to this object
 
 public:
-  
-  ClassDef(AliTPCClustersRow,1) // Cluster manager 
-};  
+
+  /// \cond CLASSIMP
+  ClassDef(AliTPCClustersRow,1) // Cluster manager
+  /// \endcond
+};
 #endif //ALITPCCLUSTERROW_H
 
 
diff --git a/TPC/TPCbase/AliTPCComposedCorrection.cxx b/TPC/TPCbase/AliTPCComposedCorrection.cxx
index d7b7d833e87..775a2d94748 100644
--- a/TPC/TPCbase/AliTPCComposedCorrection.cxx
+++ b/TPC/TPCbase/AliTPCComposedCorrection.cxx
@@ -14,48 +14,48 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-////////////////////////////////////////////////////////////////////////////////
-//                                                                            //
-// AliTPCComposedCorrection class                                             //
-//                                                                            //
-// This class is creating a correction that is composed out of smaller        //
-// corrections.                                                               //
-// There are two ways the sub-corrections can be combined into this one:      //
-// 1. kParallel: All corrections are applied at the given position x and      //
-//    the dx terms are summed up (this commutes).                             //
-// 2. kQueue: The corrections are called in order. The first one at the       //
-//    given position x resulting in dx1, the second one is called at          //
-//    the corrected position (x+dx1) resulting in dx2, the third one          //
-//    is then called at position (x+dx1+dx2) and so forth. dx=dx1+dx2+...     //
-//    is returned.                                                            //
-// 3. kQueueResidual: like kQueue with the exception that in case of          //
-//    a positive weight the 'Distortion' is called and in case of a negative  //
-//    weight the 'Correction' is called, where the absolute of the weight     //
-//    will be applied to the correction
-// For the inverse of the correction this is taken into account by reversing  //
-// the order the corrections are applied in the kQueue case (no issue for     //
-// kParallel).                                                                //
-//                                                                            //
-// date: 27/04/2010                                                           //
-// Authors: Magnus Mager, Stefan Rossegger, Jim Thomas                       //
-//                                                                            //
-// Example usage:                                                             //
-//                                                                            //
-//  AliMagF mag("mag","mag");                                                 //
-//  AliTPCExBBShape exb;             // B field shape distortions             //
-//  exb.SetBField(&mag);                                                      //
-//                                                                            //
-//  AliTPCExBTwist twist;            // ExB Twist distortions                 //
-//  twist.SetXTwist(0.001);                                                   //
-//                                                                            //
-//   TObjArray cs;  cs.Add(&exb); cs.Add(&twist);                             //
-//                                                                            //
-//  AliTPCComposedCorrection cc;                                              //
-//  cc.SetCorrections(&cs);                                                   //
-//  cc.SetOmegaTauT1T2(wt,T1,T2);                                             //
-//  cc.Print("DA");                                                           //               
-//  cc.CreateHistoDRPhiinZR(0,100,100)->Draw("surf2");                        //
-////////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCComposedCorrection
+/// \brief AliTPCComposedCorrection class
+///
+/// This class is creating a correction that is composed out of smaller
+/// corrections.
+/// There are two ways the sub-corrections can be combined into this one:
+/// 1. kParallel: All corrections are applied at the given position x and
+///   the dx terms are summed up (this commutes).
+/// 2. kQueue: The corrections are called in order. The first one at the
+///   given position x resulting in dx1, the second one is called at
+///   the corrected position (x+dx1) resulting in dx2, the third one
+///   is then called at position (x+dx1+dx2) and so forth. dx=dx1+dx2+...
+///   is returned.
+/// 3. kQueueResidual: like kQueue with the exception that in case of
+///   a positive weight the 'Distortion' is called and in case of a negative
+///   weight the 'Correction' is called, where the absolute of the weight
+///   will be applied to the correction
+/// For the inverse of the correction this is taken into account by reversing
+/// the order the corrections are applied in the kQueue case (no issue for
+/// kParallel).
+///
+/// Example usage:
+///
+/// ~~~{.cpp}
+/// AliMagF mag("mag","mag");
+/// AliTPCExBBShape exb;             // B field shape distortions
+/// exb.SetBField(&mag);
+///
+/// AliTPCExBTwist twist;            // ExB Twist distortions
+/// twist.SetXTwist(0.001);
+///
+/// TObjArray cs;  cs.Add(&exb); cs.Add(&twist);
+///
+/// AliTPCComposedCorrection cc;
+/// cc.SetCorrections(&cs);
+/// cc.SetOmegaTauT1T2(wt,T1,T2);
+/// cc.Print("DA");
+/// cc.CreateHistoDRPhiinZR(0,100,100)->Draw("surf2");
+/// ~~~
+///
+/// \author Magnus Mager, Stefan Rossegger, Jim Thomas
+/// \date 27/04/2010
 
 
 #include <TCollection.h>
@@ -67,16 +67,15 @@
 #include "AliTPCComposedCorrection.h"
 
 
-AliTPCComposedCorrection::AliTPCComposedCorrection() 
+AliTPCComposedCorrection::AliTPCComposedCorrection()
   : AliTPCCorrection("composed_correction",
 		     "composition of corrections"),
     fCorrections(0),
     fMode(kParallel),
     fWeights(0)  // weights of corrections
 {
-  //
-  // default constructor
-  //
+  /// default constructor
+
 }
 
 AliTPCComposedCorrection::AliTPCComposedCorrection(TCollection *corrections,
@@ -87,15 +86,13 @@ AliTPCComposedCorrection::AliTPCComposedCorrection(TCollection *corrections,
     fMode(mode),
     fWeights(0) //weights of correction
 {
-  //
-  // Constructor that defines the set of corrections, this one is composed of.
-  //
+  /// Constructor that defines the set of corrections, this one is composed of.
+
 }
 
 AliTPCComposedCorrection::~AliTPCComposedCorrection() {
-  // 
-  // destructor
-  //
+  /// destructor
+
   if (!fCorrections) {
     AliInfo("No Correction-models were set: can not delete them");
   } else {
@@ -111,13 +108,13 @@ AliTPCComposedCorrection::~AliTPCComposedCorrection() {
 
 
 Bool_t AliTPCComposedCorrection::AddCorrectionCompact(AliTPCCorrection* corr, Double_t weight){
-  //
-  // Add correction  - better name needed (left/right) - for the moment I assumme they commute
-  // Why not to just use array of corrections - CPU consideration
-  // Assumptions:
-  //  - origin of distortion/correction are additive
-  //  - corrections/distortion are small   and they commute
-  //  - only correction ot the same type supported 
+  /// Add correction  - better name needed (left/right) - for the moment I assumme they commute
+  /// Why not to just use array of corrections - CPU consideration
+  /// Assumptions:
+  ///  - origin of distortion/correction are additive
+  ///  - corrections/distortion are small   and they commute
+  ///  - only correction ot the same type supported
+
   const Int_t knCorr=100;
   if (corr==NULL) {
     AliError("Zerro pointer - correction");
@@ -142,28 +139,26 @@ Bool_t AliTPCComposedCorrection::AddCorrectionCompact(AliTPCCorrection* corr, Do
     if (GetSubCorrection(icorr)==NULL)  continue;
     if (GetSubCorrection(icorr)->IsA()==corr->IsA())  toAdd=GetSubCorrection(icorr);
   }
-  // 3.) create of givent type  if does not exist 
+  // 3.) create of givent type  if does not exist
   if (toAdd==NULL){
     toAdd= (AliTPCCorrection*)((corr->IsA())->New());
     fCorrections->Add(toAdd);
   }
-  // 4.) add to object of given type 
+  // 4.) add to object of given type
   return toAdd->AddCorrectionCompact(corr, weight);
 }
 
 
 AliTPCCorrection * AliTPCComposedCorrection::GetSubCorrection(Int_t ipos){
-  //
-  //
-  //
+  ///
+
   TObjArray *arr = (TObjArray*)fCorrections;
   return (AliTPCCorrection *)arr->At(ipos);
 }
 
 AliTPCCorrection * AliTPCComposedCorrection::GetSubCorrection(const char *cname){
-  //
-  //
-  //
+  ///
+
   TCollection *arr = fCorrections;
   return (AliTPCCorrection *)arr->FindObject(cname);
 }
@@ -171,10 +166,8 @@ AliTPCCorrection * AliTPCComposedCorrection::GetSubCorrection(const char *cname)
 
 
 void AliTPCComposedCorrection::GetCorrection(const Float_t x[],const Short_t roc,Float_t dx[]) {
-  //
-  // This applies all correction and the specified manner (see general
-  // class description for details).
-  //
+  /// This applies all correction and the specified manner (see general
+  /// class description for details).
 
   if (!fCorrections) {
     AliInfo("No Corrections-models were set: can not calculate distortions");
@@ -216,21 +209,19 @@ void AliTPCComposedCorrection::GetCorrection(const Float_t x[],const Short_t roc
 }
 
 void AliTPCComposedCorrection::GetDistortion(const Float_t x[],const Short_t roc,Float_t dx[]) {
-  //
-  // This applies all distortions and the specified manner (see general
-  // class descxiption for details).
-  //
+  /// This applies all distortions and the specified manner (see general
+  /// class descxiption for details).
 
   if (!fCorrections) {
     AliInfo("No Corrections-models were set: can not calculate distortions");
     return;
   }
-  
+
   if (fMode==kQueueResidual && !fWeights) {
     AliInfo("kQueueResidual mode was selected but no weights were given. Switching to kQueue instead.");
     fMode=kQueue;
   }
-  
+
   TIterator *i=fCorrections->MakeReverseIterator();
   AliTPCCorrection *c;
   Int_t weightIndex=0;
@@ -273,11 +264,9 @@ void AliTPCComposedCorrection::GetDistortion(const Float_t x[],const Short_t roc
 
 
 void AliTPCComposedCorrection::Print(Option_t* option) const {
-  //
-  // Print function to check which correction classes are used 
-  // option=="d" prints details regarding the setted magnitude 
-  // option=="a" prints the C0 and C1 coefficents for calibration purposes
-  //
+  /// Print function to check which correction classes are used
+  /// option=="d" prints details regarding the setted magnitude
+  /// option=="a" prints the C0 and C1 coefficents for calibration purposes
 
   printf("Composed TPC spacepoint correction \"%s\" -- composed of:\n",GetTitle());
   TString opt = option; opt.ToLower();
@@ -304,25 +293,23 @@ void AliTPCComposedCorrection::Print(Option_t* option) const {
 
 
 void AliTPCComposedCorrection::Init() {
-  //
-  // Initialization funtion (not used at the moment)
-  //
+  /// Initialization funtion (not used at the moment)
+
   if (!fCorrections) {
     AliInfo("No Correction-models were set");
     return;
   }
   TIterator *i=fCorrections->MakeIterator();
   AliTPCCorrection *c;
-  while (0!=(c=dynamic_cast<AliTPCCorrection*>(i->Next()))) 
+  while (0!=(c=dynamic_cast<AliTPCCorrection*>(i->Next())))
     c->Init();
   delete i;
-  
+
 }
 
 void AliTPCComposedCorrection::Update(const TTimeStamp &timeStamp) {
-  //
-  // Update function 
-  //
+  /// Update function
+
   if (!fCorrections) {
     AliInfo("No Correction-models were set");
     return;
@@ -330,26 +317,24 @@ void AliTPCComposedCorrection::Update(const TTimeStamp &timeStamp) {
 
   TIterator *i=fCorrections->MakeIterator();
   AliTPCCorrection *c;
-  while (0!=(c=dynamic_cast<AliTPCCorrection*>(i->Next()))) 
+  while (0!=(c=dynamic_cast<AliTPCCorrection*>(i->Next())))
     c->Update(timeStamp);
   delete i;
- 
+
 }
 
 
 
 void AliTPCComposedCorrection::SetOmegaTauT1T2(Float_t omegaTau,Float_t t1,Float_t t2) {
-  //
-  // Gives the possibility to set the OmegaTau plus Tensor corrections T1 and T2 (effective omega Tau)
-  // to each subcorrection (since they might become event specific due to changing drift velocity)
-  //
-  // The omegaTau comes idealy from the Database, since it is a function of drift velocity, B and E field 
-  // e.g. omegaTau  = -10.0 * Bz * vdrift / Ez ; // with Bz in kG and Ez in V/cm
-  //      omegaTau  = -0.325 for Bz=5kG, Ez=400V/cm and vdrift = 2.6cm/muSec
-  // The T1 and T2 tensors were measured in a dedicated calibration run
-  //
-  // Note: overwrites previously set values!
-  // 
+  /// Gives the possibility to set the OmegaTau plus Tensor corrections T1 and T2 (effective omega Tau)
+  /// to each subcorrection (since they might become event specific due to changing drift velocity)
+  ///
+  /// The omegaTau comes idealy from the Database, since it is a function of drift velocity, B and E field
+  /// e.g. omegaTau  = -10.0 * Bz * vdrift / Ez ; // with Bz in kG and Ez in V/cm
+  ///      omegaTau  = -0.325 for Bz=5kG, Ez=400V/cm and vdrift = 2.6cm/muSec
+  /// The T1 and T2 tensors were measured in a dedicated calibration run
+  ///
+  /// Note: overwrites previously set values!
 
   if (!fCorrections) {
     AliInfo("No Correction-models were set");
@@ -364,4 +349,6 @@ void AliTPCComposedCorrection::SetOmegaTauT1T2(Float_t omegaTau,Float_t t1,Float
   delete i;
 }
 
+/// \cond CLASSIMP
 ClassImp(AliTPCComposedCorrection)
+/// \endcond
diff --git a/TPC/TPCbase/AliTPCComposedCorrection.h b/TPC/TPCbase/AliTPCComposedCorrection.h
index f1ba877a80b..878bd518c85 100644
--- a/TPC/TPCbase/AliTPCComposedCorrection.h
+++ b/TPC/TPCbase/AliTPCComposedCorrection.h
@@ -4,27 +4,25 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-////////////////////////////////////////////////////////////////////////////////
-//                                                                            //
-// AliTPCComposedCorrection class                                             //
-//                                                                            //
-// This class is creating a correction that is composed out of smaller        //
-// corrections.                                                               //
-// There are two ways the sub-corrections can be combined into this one:      //
-// 1. kParallel: All corrections are applied at the given position x and      //
-//    the dx terms are summed up (this commutes).                             //
-// 2. kQueue: The corrections are called in order. The first one at the       //
-//    given position x resulting in dx1, the second one is called at          //
-//    the corrected position (x+dx1) resulting in dx2, the third one          //
-//    is then called at position (x+dx1+dx2) and so forth. dx=dx1+dx2+...     //
-//    is returned.                                                            //
-// For the inverse of the correction this is taken into account by reversing  //
-// the order the corrections are applied in the kQueue case (no issue for     //
-// kParallel).                                                                //
-//                                                                            //
-// date: 27/04/2010                                                           //
-// Authors: Magnus Mager, Stefan Rossegger, Jim Thomas                       //
-////////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCComposedCorrection
+/// \brief AliTPCComposedCorrection class
+///
+/// This class is creating a correction that is composed out of smaller
+/// corrections.
+/// There are two ways the sub-corrections can be combined into this one:
+/// 1. kParallel: All corrections are applied at the given position x and
+///   the dx terms are summed up (this commutes).
+/// 2. kQueue: The corrections are called in order. The first one at the
+///   given position x resulting in dx1, the second one is called at
+///   the corrected position (x+dx1) resulting in dx2, the third one
+///   is then called at position (x+dx1+dx2) and so forth. dx=dx1+dx2+...
+///   is returned.
+/// For the inverse of the correction this is taken into account by reversing
+/// the order the corrections are applied in the kQueue case (no issue for
+/// kParallel).
+///
+/// \author Magnus Mager, Stefan Rossegger, Jim Thomas
+/// \date 27/04/2010
 
 #include "AliTPCCorrection.h"
 #include "TVectorD.h"
@@ -46,7 +44,7 @@ public:
   void SetCorrections(const TCollection *corrections) {fCorrections=(TCollection*)corrections;}
   CompositionType GetMode() const {return fMode;}
   void SetMode(CompositionType mode) {fMode=mode;}
-  
+
   virtual void GetCorrection(const Float_t x[],const Short_t roc,Float_t dx[]);
   virtual void GetDistortion(const Float_t x[],const Short_t roc,Float_t dx[]);
   virtual  AliTPCCorrection * GetSubCorrection(Int_t ipos);
@@ -61,13 +59,15 @@ public:
   const  TVectorD * GetWeights() const {return fWeights;}
 
 private:
-  TCollection *fCorrections; // The corrections this one is composed of.
-  CompositionType fMode;     // The way to apply the corrections (see general class documentation)
-  TVectorD        *fWeights;  // optional vector with weights - used for fit benchmarking
+  TCollection *fCorrections; ///< The corrections this one is composed of.
+  CompositionType fMode;     ///< The way to apply the corrections (see general class documentation)
+  TVectorD        *fWeights;  ///< optional vector with weights - used for fit benchmarking
   AliTPCComposedCorrection & operator = (const AliTPCComposedCorrection &); // dummy assignment operator
   AliTPCComposedCorrection(const AliTPCComposedCorrection&); //dummy copy contructor
 
+  /// \cond CLASSIMP
   ClassDef(AliTPCComposedCorrection,2);
+  /// \endcond
 };
 
 
diff --git a/TPC/TPCbase/AliTPCConfigDA.cxx b/TPC/TPCbase/AliTPCConfigDA.cxx
index 758129b0ed5..a808d55c882 100644
--- a/TPC/TPCbase/AliTPCConfigDA.cxx
+++ b/TPC/TPCbase/AliTPCConfigDA.cxx
@@ -13,19 +13,18 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-///////////////////////////////////////////////////////////////////////////////
-//                                                                           //
-//  Class for Parsing simple text configuration files                        //
-//  It produces a TMap for the Key=>Value pairs found in the                 //
-//  Configutation file.                                                      //
-//                                                                           //
-// The configuration file has a simple structure:                            //
-// * Lines starting with a # or empty lines are ignored                      //
-// * Key and Value are separated either by a <tab> or <space>es              //
-//                                                                           //
-//  Currently the class is used in the TPC DAs to allow an adjustment of     //
-//  the most relevant parameters without recompiling the DAs                 //
-///////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCConfigDA
+/// \brief  Class for Parsing simple text configuration files
+///
+/// It produces a TMap for the Key=>Value pairs found in the
+/// Configutation file.
+///
+/// The configuration file has a simple structure:
+/// * Lines starting with a # or empty lines are ignored
+/// * Key and Value are separated either by a <tab> or <space>es
+///
+/// Currently the class is used in the TPC DAs to allow an adjustment of
+/// the most relevant parameters without recompiling the DAs
 
 
 #include <fstream>
@@ -46,19 +45,17 @@ AliTPCConfigDA::AliTPCConfigDA() :
   TObject(),
   fConfigMap(new TMap)
 {
- //
- // default constructor
- //
+ /// default constructor
+
  fConfigMap->SetOwnerKeyValue();
-} 
+}
 //_____________________________________________________________________
 AliTPCConfigDA::AliTPCConfigDA(const AliTPCConfigDA &cfg) :
   TObject(),
   fConfigMap((TMap*)cfg.fConfigMap->Clone())
 {
-  //
-  // copy constructor
-  //
+  /// copy constructor
+
   fConfigMap->SetOwnerKeyValue();
 }
 
@@ -67,9 +64,8 @@ AliTPCConfigDA::AliTPCConfigDA(const char* cfgfile) :
   TObject(),
   fConfigMap(new TMap)
 {
-  //
-  // default constructor using the config file name as input parameter
-  //
+  /// default constructor using the config file name as input parameter
+
   fConfigMap->SetOwnerKeyValue();
   if ( !cfgfile ) return;
   ParseConfigFileTxt(cfgfile);
@@ -77,9 +73,8 @@ AliTPCConfigDA::AliTPCConfigDA(const char* cfgfile) :
 //_____________________________________________________________________
 AliTPCConfigDA& AliTPCConfigDA::operator = (const  AliTPCConfigDA &source)
 {
-  //
-  // assignment operator
-  //
+  /// assignment operator
+
   if (&source == this) return *this;
   new (this) AliTPCConfigDA(source);
 
@@ -88,34 +83,31 @@ AliTPCConfigDA& AliTPCConfigDA::operator = (const  AliTPCConfigDA &source)
 //_____________________________________________________________________
 AliTPCConfigDA::~AliTPCConfigDA()
 {
- //
- // dtor
- //   
+ /// dtor
+
   delete fConfigMap;
 }
 //_____________________________________________________________________
 Int_t AliTPCConfigDA::ParseConfigFileTxt(const char* cfgfile)
 {
- //
- // Function to parse a configuration file
- //
+ /// Function to parse a configuration file
 
  ifstream file(cfgfile);
  if ( !file.is_open() ){
   Error("ParseConfigFileTxt","File %s could not be opened!", cfgfile);
   return 1;
- } 
+ }
  TString strFile;
  strFile.ReadFile(file);
  TObjArray *arr=strFile.Tokenize("\n");
  if ( !arr ) {
-   file.close(); 
+   file.close();
    return 2;
  }
  TIter nextLine(arr);
  while (TObject *l=nextLine()){
   TString line(((TObjString*)l)->GetString());
-  //remove whitespcaces 
+  //remove whitespcaces
   line.Remove(TString::kBoth,' ');
   line.Remove(TString::kBoth,'\t');
   if ( line.BeginsWith("#") || line=="" ) continue;
@@ -127,8 +119,8 @@ Int_t AliTPCConfigDA::ParseConfigFileTxt(const char* cfgfile)
     continue;
   }
   fConfigMap->Add(arrValues->At(0)->Clone(),arrValues->At(1)->Clone());
-  delete arrValues; 
- } 
+  delete arrValues;
+ }
 
  delete arr;
  return 0;
@@ -136,19 +128,17 @@ Int_t AliTPCConfigDA::ParseConfigFileTxt(const char* cfgfile)
 //_____________________________________________________________________
 Float_t AliTPCConfigDA::GetValue(const char *key) const
 {
-  //
-  //Get value for the speciefied key
-  //
+  /// Get value for the speciefied key
+
   TObject *val=fConfigMap->GetValue(key);
   if ( !val ) return -999.;
   TString sval(((TObjString*)val)->GetString());
-  return sval.Atof(); 
+  return sval.Atof();
 }
 //_____________________________________________________________________
 void AliTPCConfigDA::ResetMap()
 {
-  //
-  // Reset the map with the configuration values
-  //
+  /// Reset the map with the configuration values
+
   fConfigMap->DeleteAll();
 }
diff --git a/TPC/TPCbase/AliTPCConfigDA.h b/TPC/TPCbase/AliTPCConfigDA.h
index a1f1a5ca2aa..c1329949d5b 100644
--- a/TPC/TPCbase/AliTPCConfigDA.h
+++ b/TPC/TPCbase/AliTPCConfigDA.h
@@ -3,33 +3,32 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 #include <TObject.h>
-////////////////////////////////////////////////////////////////////////////
-//
-// Simple configuration file parser
-//
-////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCConfigDA
+/// \brief Simple configuration file parser
 
 class TMap;
 
 class AliTPCConfigDA : public TObject{
-  
+
 public:
   AliTPCConfigDA();
   AliTPCConfigDA(const char* cfgfile);
   AliTPCConfigDA(const AliTPCConfigDA &cfg);
   AliTPCConfigDA& operator = (const AliTPCConfigDA &cfg);
- 
+
   virtual ~AliTPCConfigDA();
-  
+
   Int_t ParseConfigFileTxt(const char* cfgfile);
-  Float_t GetValue(const char* name) const; 
+  Float_t GetValue(const char* name) const;
 
   const TMap* GetConfigurationMap() const {return fConfigMap;}
   void ResetMap();
 
 private:
-  TMap *fConfigMap;                   // Configuration map
-  
+  TMap *fConfigMap;                   ///< Configuration map
+
+  /// \cond CLASSIMP
   ClassDef(AliTPCConfigDA, 1)         // TPC DA configuration file parser
+  /// \endcond
 };
 #endif
diff --git a/TPC/TPCbase/AliTPCConfigParser.cxx b/TPC/TPCbase/AliTPCConfigParser.cxx
index aa8b4a52e09..856181d144d 100644
--- a/TPC/TPCbase/AliTPCConfigParser.cxx
+++ b/TPC/TPCbase/AliTPCConfigParser.cxx
@@ -13,20 +13,19 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-///////////////////////////////////////////////////////////////////////////////
-//                                                                           //
-//  Class for Parsing simple text configuration files                        //
-//  It produces a TList for the TObjArrays with the name of the Key
-//    the TObjArray contain the Values, split from kommas, as found in the   //
-//  Configutation file.                                                      //
-//                                                                           //
-// The configuration file has a simple structure:                            //
-// * Lines starting with a # or empty lines are ignored                      //
-// * Key and Value are separated either by a <tab> or <space>es              //
-//                                                                           //
-//  Currently the class is used in the TPC DAs to allow an adjustment of     //
-//  the most relevant parameters without recompiling the DAs                 //
-///////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCConfigParser
+/// \brief  Class for Parsing simple text configuration files
+///
+/// It produces a TList for the TObjArrays with the name of the Key
+///   the TObjArray contain the Values, split from kommas, as found in the
+/// Configutation file.
+///
+/// The configuration file has a simple structure:
+/// * Lines starting with a # or empty lines are ignored
+/// * Key and Value are separated either by a <tab> or <space>es
+///
+/// Currently the class is used in the TPC DAs to allow an adjustment of
+/// the most relevant parameters without recompiling the DAs
 
 
 #include <fstream>
@@ -50,11 +49,10 @@ fConfigMap(new TList),
 fKeyIter(0),
 fValIter(0)
 {
- //
- // default constructor
- //
+ /// default constructor
+
   fConfigMap->SetOwner();
-} 
+}
 //_____________________________________________________________________
 AliTPCConfigParser::AliTPCConfigParser(const AliTPCConfigParser &cfg) :
 TObject(),
@@ -62,9 +60,8 @@ fConfigMap((TList*)cfg.fConfigMap->Clone()),
 fKeyIter(0),
 fValIter(0)
 {
-  //
-  // copy constructor
-  //
+  /// copy constructor
+
   fConfigMap->SetOwner();
 }
 
@@ -75,9 +72,8 @@ fConfigMap(new TList),
 fKeyIter(0),
 fValIter(0)
 {
-  //
-  // default constructor using the config file name as input parameter
-  //
+  /// default constructor using the config file name as input parameter
+
   fConfigMap->SetOwner();
   if ( !cfgfile ) return;
   ParseConfigFileTxt(cfgfile);
@@ -85,20 +81,18 @@ fValIter(0)
 //_____________________________________________________________________
 AliTPCConfigParser& AliTPCConfigParser::operator = (const  AliTPCConfigParser &source)
 {
-  //
-  // assignment operator
-  //
+  /// assignment operator
+
   if (&source == this) return *this;
   new (this) AliTPCConfigParser(source);
-  
+
   return *this;
 }
 //_____________________________________________________________________
 AliTPCConfigParser::~AliTPCConfigParser()
 {
- //
- // dtor
- //
+ /// dtor
+
   delete fConfigMap;
   delete fKeyIter;
   delete fValIter;
@@ -106,9 +100,8 @@ AliTPCConfigParser::~AliTPCConfigParser()
 //_____________________________________________________________________
 Int_t AliTPCConfigParser::ParseConfigFileTxt(const char* cfgfile)
 {
- //
- // Function to parse a configuration file
- //
+ /// Function to parse a configuration file
+
   ResetMap();
   ifstream file(gSystem->ExpandPathName(cfgfile));
   if ( !file.is_open() ){
@@ -159,16 +152,15 @@ Int_t AliTPCConfigParser::ParseConfigFileTxt(const char* cfgfile)
     fConfigMap->AddLast(objArr);
     delete arrValues;
   }
-  
+
   delete arr;
   return 0;
 }
 //_____________________________________________________________________
 Float_t AliTPCConfigParser::GetValue(const char *key, UInt_t position)
 {
-  //
-  //Get value for the speciefied key
-  //
+  /// Get value for the speciefied key
+
   TObject *val=((TObjArray*)fConfigMap->FindObject(key))->At(position);
   if ( !val ) return -999.;
   TString sval(((TObjString*)val)->GetString());
@@ -177,9 +169,8 @@ Float_t AliTPCConfigParser::GetValue(const char *key, UInt_t position)
 //_____________________________________________________________________
 const char* AliTPCConfigParser::GetData(const char *key, UInt_t position)
 {
-  //
-  //Get value for the speciefied key
-  //
+  /// Get value for the speciefied key
+
   TObjArray *arr=((TObjArray*)fConfigMap->FindObject(key));
   if (position>=(UInt_t)(arr->GetEntries())) return "";
   TObject *val=arr->At(position);
@@ -189,9 +180,8 @@ const char* AliTPCConfigParser::GetData(const char *key, UInt_t position)
 //_____________________________________________________________________
 Float_t AliTPCConfigParser::GetValue(const TObject *key, UInt_t position)
 {
-  //
-  //Get value for the speciefied key
-  //
+  /// Get value for the speciefied key
+
   TObject *val=((TObjArray*)fConfigMap->FindObject(key))->At(position);
   if ( !val ) return -999.;
   TString sval(((TObjString*)val)->GetString());
@@ -200,9 +190,8 @@ Float_t AliTPCConfigParser::GetValue(const TObject *key, UInt_t position)
 //_____________________________________________________________________
 const char* AliTPCConfigParser::GetData(const TObject *key, UInt_t position)
 {
-  //
-  //Get value for the speciefied key
-  //
+  /// Get value for the speciefied key
+
   TObjArray *arr=((TObjArray*)fConfigMap->FindObject(key));
   if (position>=((UInt_t)arr->GetEntries())) return "";
   TObject *val=arr->At(position);
@@ -212,17 +201,15 @@ const char* AliTPCConfigParser::GetData(const TObject *key, UInt_t position)
 //_____________________________________________________________________
 Int_t AliTPCConfigParser::GetNumberOfValues(const char* key) const
 {
-  //
-  // return the number of values for key
-  //
+  /// return the number of values for key
+
   return ((TObjArray*)fConfigMap->FindObject(key))->GetEntries();
 }
 //_____________________________________________________________________
 Int_t AliTPCConfigParser::GetNumberOfValues(TObject* key) const
 {
-  //
-  // return the number of values for key
-  //
+  /// return the number of values for key
+
   return ((TObjArray*)fConfigMap->FindObject(key))->GetEntries();
 }
 //_____________________________________________________________________
@@ -262,8 +249,7 @@ TObject* AliTPCConfigParser::NextValueIter(TObjArray *key){
 //_____________________________________________________________________
 void AliTPCConfigParser::ResetMap()
 {
-  //
-  // Reset the map with the configuration values
-  //
+  /// Reset the map with the configuration values
+
   fConfigMap->Delete();
 }
diff --git a/TPC/TPCbase/AliTPCConfigParser.h b/TPC/TPCbase/AliTPCConfigParser.h
index b1f1eb406fe..7e36a89e081 100644
--- a/TPC/TPCbase/AliTPCConfigParser.h
+++ b/TPC/TPCbase/AliTPCConfigParser.h
@@ -1,3 +1,5 @@
+/// \class AliTPCConfigParser
+
 #ifndef AliTPCConfigParser_H
 #define AliTPCConfigParser_H
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
@@ -8,24 +10,24 @@ class TObjArray;
 class TList;
 
 class AliTPCConfigParser : public TObject{
-  
+
 public:
   AliTPCConfigParser();
   AliTPCConfigParser(const char* cfgfile);
   AliTPCConfigParser(const AliTPCConfigParser &cfg);
   AliTPCConfigParser& operator = (const AliTPCConfigParser &cfg);
- 
+
   virtual ~AliTPCConfigParser();
-  
+
   Int_t ParseConfigFileTxt(const char* cfgfile);
   Float_t GetValue(const char* key, UInt_t position=0);
   Float_t GetValue(const TObject *key, UInt_t position=0);
   const char*  GetData(const char* key, UInt_t position=0);
   const char*  GetData(const TObject* key, UInt_t position=0);
-  
+
   Int_t GetNumberOfValues(const char* key) const;
   Int_t GetNumberOfValues(TObject* key) const;
-  
+
   const TList* GetConfigurationMap() const {return fConfigMap;}
   void ResetMap();
 
@@ -35,7 +37,7 @@ public:
   const TObject* operator()(TObject* key) const {return fConfigMap->FindObject(key);}
 
   void ResetIter() {delete fKeyIter; fKeyIter=0; delete fValIter; fValIter=0;}
-  
+
   TObject* NextKey();
   TObject* NextValue(const char *key);
   TObject* NextValue(TObject *key);
@@ -46,7 +48,9 @@ private:
   TIterator *fValIter;
 
   TObject *NextValueIter(TObjArray *obj);
-  
+
+  /// \cond CLASSIMP
   ClassDef(AliTPCConfigParser, 1)         // TPC DA configuration file parser
+  /// \endcond
 };
 #endif
diff --git a/TPC/TPCbase/AliTPCCorrection.cxx b/TPC/TPCbase/AliTPCCorrection.cxx
index 94c98e17ff3..bc3e756fcd1 100644
--- a/TPC/TPCbase/AliTPCCorrection.cxx
+++ b/TPC/TPCbase/AliTPCCorrection.cxx
@@ -13,73 +13,48 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-// _________________________________________________________________
-//
-// Begin_Html
-//   <h2>  AliTPCCorrection class   </h2>    
-//  
-//   The AliTPCCorrection class provides a general framework to deal with space point distortions. 
-//   An correction class which inherits from here is for example AliTPCExBBShape or AliTPCExBTwist. <br> 
-//   General virtual functions are (for example) CorrectPoint(x,roc) where x is the vector of initial 
-//   positions in cartesian coordinates and roc represents the read-out chamber number according to 
-//   the offline numbering convention. The vector x is overwritten with the corrected coordinates. <br> 
-//   An alternative usage would be CorrectPoint(x,roc,dx), which leaves the vector x untouched, but 
-//   returns the distortions via the vector dx. <br>
-//   This class is normally used via the general class AliTPCComposedCorrection.   
-//   <p>
-//   Furthermore, the class contains basic geometrical descriptions like field cage radii 
-//   (fgkIFCRadius, fgkOFCRadius) and length (fgkTPCZ0) plus the voltages. Also, the definitions 
-//   of size and widths of the fulcrums building the grid of the final look-up table, which is 
-//   then interpolated, is defined in kNX and fgkXList).
-//   <p>
-//   All physics-model classes below are derived from this class in order to not duplicate code 
-//   and to allow a uniform treatment of all physics models.
-//   <p>
-//   <h3> Poisson solver </h3>    
-//   A numerical solver of the Poisson equation (relaxation technique) is implemented for 2-dimensional 
-//   geometries (r,z) as well as for 3-dimensional problems (r,$\phi$,z). The corresponding function 
-//   names are PoissonRelaxation?D. The relevant function arguments are the arrays of the boundary and 
-//   initial conditions (ArrayofArrayV, ArrayofChargeDensities) as well as the grid granularity which 
-//   is used during the calculation. These inputs can be chosen according to the needs of the physical 
-//   effect which is supposed to be simulated. In the 3D version, different symmetry conditions can be set
-//   in order to reduce the calculation time (used in AliTPCFCVoltError3D).
-//   <p>
-//   <h3> Unified plotting functionality  </h3>    
-//   Generic plot functions were implemented. They return a histogram pointer in the chosen plane of 
-//   the TPC drift volume with a selectable grid granularity and the magnitude of the correction vector.
-//   For example, the function CreateHistoDZinXY(z,nx,ny) returns a 2-dimensional histogram which contains 
-//   the longitudinal corrections $dz$ in the (x,y)-plane at the given z position with the granularity of 
-//   nx and ny. The magnitude of the corrections is defined by the class from which this function is called.
-//   In the same manner, standard plots for the (r,$\phi$)-plane and for the other corrections like $dr$ and $rd\phi$ are available  
-//   <p>                                                                      
-//   Note: This class is normally used via the class AliTPCComposedCorrection
-// End_Html
-//
-// Begin_Macro(source)
-//   {
-//   gROOT->SetStyle("Plain"); gStyle->SetPalette(1);
-//   TCanvas *c2 = new TCanvas("cAliTPCCorrection","cAliTPCCorrection",700,1050);  c2->Divide(2,3);
-//   AliTPCROCVoltError3D roc; // EXAMPLE PLOTS - SEE BELOW
-//   roc.SetROCDataFileName("$ALICE_ROOT/TPC/Calib/maps/TPCROCdzSurvey.root");
-//   roc.SetOmegaTauT1T2(0,1,1); // B=0
-//   Float_t z0 = 1; // at +1 cm -> A side
-//   c2->cd(1); roc.CreateHistoDRinXY(1.,300,300)->Draw("cont4z"); 
-//   c2->cd(3);roc.CreateHistoDRPhiinXY(1.,300,300)->Draw("cont4z"); 
-//   c2->cd(5);roc.CreateHistoDZinXY(1.,300,300)->Draw("cont4z"); 
-//   Float_t phi0=0.5;
-//   c2->cd(2);roc.CreateHistoDRinZR(phi0)->Draw("surf2"); 
-//   c2->cd(4);roc.CreateHistoDRPhiinZR(phi0)->Draw("surf2"); 
-//   c2->cd(6);roc.CreateHistoDZinZR(phi0)->Draw("surf2"); 
-//   return c2;
-//   } 
-// End_Macro
-//
-// Begin_Html
-//   <p>
-//   Date: 27/04/2010  <br>
-//   Authors: Magnus Mager, Stefan Rossegger, Jim Thomas                     
-// End_Html 
-// _________________________________________________________________
+/// \class AliTPCCorrection
+/// \brief <h2>  AliTPCCorrection class   </h2>
+///
+/// The AliTPCCorrection class provides a general framework to deal with space point distortions.
+/// An correction class which inherits from here is for example AliTPCExBBShape or AliTPCExBTwist.
+/// General virtual functions are (for example) CorrectPoint(x,roc) where x is the vector of initial
+/// positions in cartesian coordinates and roc represents the read-out chamber number according to
+/// the offline numbering convention. The vector x is overwritten with the corrected coordinates.
+/// An alternative usage would be CorrectPoint(x,roc,dx), which leaves the vector x untouched, but
+/// returns the distortions via the vector dx.
+/// This class is normally used via the general class AliTPCComposedCorrection.
+///
+/// Furthermore, the class contains basic geometrical descriptions like field cage radii
+/// (fgkIFCRadius, fgkOFCRadius) and length (fgkTPCZ0) plus the voltages. Also, the definitions
+/// of size and widths of the fulcrums building the grid of the final look-up table, which is
+/// then interpolated, is defined in kNX and fgkXList).
+///
+/// All physics-model classes below are derived from this class in order to not duplicate code
+/// and to allow a uniform treatment of all physics models.
+///
+/// <h3> Poisson solver </h3>
+/// A numerical solver of the Poisson equation (relaxation technique) is implemented for 2-dimensional
+/// geometries (r,z) as well as for 3-dimensional problems (r,$\phi$,z). The corresponding function
+/// names are PoissonRelaxation?D. The relevant function arguments are the arrays of the boundary and
+/// initial conditions (ArrayofArrayV, ArrayofChargeDensities) as well as the grid granularity which
+/// is used during the calculation. These inputs can be chosen according to the needs of the physical
+/// effect which is supposed to be simulated. In the 3D version, different symmetry conditions can be set
+/// in order to reduce the calculation time (used in AliTPCFCVoltError3D).
+///
+/// <h3> Unified plotting functionality  </h3>
+/// Generic plot functions were implemented. They return a histogram pointer in the chosen plane of
+/// the TPC drift volume with a selectable grid granularity and the magnitude of the correction vector.
+/// For example, the function CreateHistoDZinXY(z,nx,ny) returns a 2-dimensional histogram which contains
+/// the longitudinal corrections $dz$ in the (x,y)-plane at the given z position with the granularity of
+/// nx and ny. The magnitude of the corrections is defined by the class from which this function is called.
+/// In the same manner, standard plots for the (r,$\phi$)-plane and for the other corrections like $dr$ and $rd\phi$ are available
+///
+/// Note: This class is normally used via the class AliTPCComposedCorrection
+/// ![Picture from ROOT macro](AliTPCCorrection_cxx_e4df765.png)
+///
+/// \author Magnus Mager, Stefan Rossegger, Jim Thomas
+/// \date 27/04/2010
 
 
 #include "Riostream.h"
@@ -124,34 +99,35 @@
 #include "TLinearFitter.h"
 #include <AliSysInfo.h>
 
+/// \cond CLASSIMP
 ClassImp(AliTPCCorrection)
+/// \endcond
+
 
- 
 TObjArray *AliTPCCorrection::fgVisualCorrection=0;
 // instance of correction for visualization
 
 
 // FIXME: the following values should come from the database
-const Double_t AliTPCCorrection::fgkTPCZ0    = 249.7;     // nominal gating grid position 
-const Double_t AliTPCCorrection::fgkIFCRadius=  83.5;     // radius which renders the "18 rod manifold" best -> compare calc. of Jim Thomas
+const Double_t AliTPCCorrection::fgkTPCZ0    = 249.7;     ///< nominal gating grid position
+const Double_t AliTPCCorrection::fgkIFCRadius=  83.5;     ///< radius which renders the "18 rod manifold" best -> compare calc. of Jim Thomas
 // compare gkIFCRadius=  83.05: Mean Radius of the Inner Field Cage ( 82.43 min,  83.70 max) (cm)
-const Double_t AliTPCCorrection::fgkOFCRadius= 254.5;     // Mean Radius of the Outer Field Cage (252.55 min, 256.45 max) (cm)
-const Double_t AliTPCCorrection::fgkZOffSet  =   0.2;     // Offset from CE: calculate all distortions closer to CE as if at this point
-const Double_t AliTPCCorrection::fgkCathodeV = -100000.0; // Cathode Voltage (volts)
-const Double_t AliTPCCorrection::fgkGG       =     -70.0; // Gating Grid voltage (volts)
+const Double_t AliTPCCorrection::fgkOFCRadius= 254.5;     ///< Mean Radius of the Outer Field Cage (252.55 min, 256.45 max) (cm)
+const Double_t AliTPCCorrection::fgkZOffSet  =   0.2;     ///< Offset from CE: calculate all distortions closer to CE as if at this point
+const Double_t AliTPCCorrection::fgkCathodeV = -100000.0; ///< Cathode Voltage (volts)
+const Double_t AliTPCCorrection::fgkGG       =     -70.0; ///< Gating Grid voltage (volts)
+
+const Double_t  AliTPCCorrection::fgkdvdE = 0.0024; ///< [cm/V] drift velocity dependency on the E field (from Magboltz for NeCO2N2 at standard environment)
 
-const Double_t  AliTPCCorrection::fgkdvdE = 0.0024; // [cm/V] drift velocity dependency on the E field (from Magboltz for NeCO2N2 at standard environment)
+const Double_t AliTPCCorrection::fgkEM = -1.602176487e-19/9.10938215e-31; ///< charge/mass in [C/kg]
+const Double_t AliTPCCorrection::fgke0 = 8.854187817e-12;                 ///< vacuum permittivity [A·s/(V·m)]
 
-const Double_t AliTPCCorrection::fgkEM = -1.602176487e-19/9.10938215e-31; // charge/mass in [C/kg]
-const Double_t AliTPCCorrection::fgke0 = 8.854187817e-12;                 // vacuum permittivity [A·s/(V·m)]
- 
 
-AliTPCCorrection::AliTPCCorrection() 
+AliTPCCorrection::AliTPCCorrection()
   : TNamed("correction_unity","unity"),fILow(0),fJLow(0),fKLow(0), fT1(1), fT2(1), fIsLocal(kFALSE)
 {
-  //
-  // default constructor
-  //
+  /// default constructor
+
   if (!fgVisualCorrection) fgVisualCorrection= new TObjArray;
 
   InitLookUpfulcrums();
@@ -161,9 +137,8 @@ AliTPCCorrection::AliTPCCorrection()
 AliTPCCorrection::AliTPCCorrection(const char *name,const char *title)
   : TNamed(name,title),fILow(0),fJLow(0),fKLow(0), fT1(1), fT2(1), fIsLocal(kFALSE)
 {
-  //
-  // default constructor, that set the name and title
-  //
+  /// default constructor, that set the name and title
+
   if (!fgVisualCorrection) fgVisualCorrection= new TObjArray;
 
   InitLookUpfulcrums();
@@ -171,65 +146,60 @@ AliTPCCorrection::AliTPCCorrection(const char *name,const char *title)
 }
 
 AliTPCCorrection::~AliTPCCorrection() {
-  // 
-  // virtual destructor
-  //
+  /// virtual destructor
+
 }
 
 Bool_t AliTPCCorrection::AddCorrectionCompact(AliTPCCorrection* corr, Double_t weight){
-  //
-  // Add correction  and make them compact
-  // Assumptions:
-  //  - origin of distortion/correction are additive
-  //  - only correction ot the same type supported ()
+  /// Add correction  and make them compact
+  /// Assumptions:
+  ///  - origin of distortion/correction are additive
+  ///  - only correction ot the same type supported ()
+
   if (corr==NULL) {
     AliError("Zerro pointer - correction");
     return kFALSE;
-  }  
+  }
   AliError(TString::Format("Correction %s not implementend",IsA()->GetName()).Data());
   return kFALSE;
 }
 
 
 void AliTPCCorrection::CorrectPoint(Float_t x[], Short_t roc) {
-  //
-  // Corrects the initial coordinates x (cartesian coordinates)
-  // according to the given effect (inherited classes)
-  // roc represents the TPC read out chamber (offline numbering convention)
-  //
+  /// Corrects the initial coordinates x (cartesian coordinates)
+  /// according to the given effect (inherited classes)
+  /// roc represents the TPC read out chamber (offline numbering convention)
+
   Float_t dx[3];
   GetCorrection(x,roc,dx);
   for (Int_t j=0;j<3;++j) x[j]+=dx[j];
 }
 
 void AliTPCCorrection::CorrectPoint(const Float_t x[], Short_t roc,Float_t xp[]) {
-  //
-  // Corrects the initial coordinates x (cartesian coordinates) and stores the new 
-  // (distorted) coordinates in xp. The distortion is set according to the given effect (inherited classes)
-  // roc represents the TPC read out chamber (offline numbering convention)
-  //
+  /// Corrects the initial coordinates x (cartesian coordinates) and stores the new
+  /// (distorted) coordinates in xp. The distortion is set according to the given effect (inherited classes)
+  /// roc represents the TPC read out chamber (offline numbering convention)
+
   Float_t dx[3];
   GetCorrection(x,roc,dx);
   for (Int_t j=0;j<3;++j) xp[j]=x[j]+dx[j];
 }
 
 void AliTPCCorrection::DistortPoint(Float_t x[], Short_t roc) {
-  //
-  // Distorts the initial coordinates x (cartesian coordinates)
-  // according to the given effect (inherited classes)
-  // roc represents the TPC read out chamber (offline numbering convention)
-  //
+  /// Distorts the initial coordinates x (cartesian coordinates)
+  /// according to the given effect (inherited classes)
+  /// roc represents the TPC read out chamber (offline numbering convention)
+
   Float_t dx[3];
   GetDistortion(x,roc,dx);
   for (Int_t j=0;j<3;++j) x[j]+=dx[j];
 }
 
 void AliTPCCorrection::DistortPointLocal(Float_t x[], Short_t roc) {
-  //
-  // Distorts the initial coordinates x (cartesian coordinates)
-  // according to the given effect (inherited classes)
-  // roc represents the TPC read out chamber (offline numbering convention)
-  //
+  /// Distorts the initial coordinates x (cartesian coordinates)
+  /// according to the given effect (inherited classes)
+  /// roc represents the TPC read out chamber (offline numbering convention)
+
   Float_t gxyz[3]={0,0,0};
   Double_t alpha = TMath::TwoPi()*(roc%18+0.5)/18;
   Double_t ca=TMath::Cos(alpha), sa= TMath::Sin(alpha);
@@ -242,11 +212,10 @@ void AliTPCCorrection::DistortPointLocal(Float_t x[], Short_t roc) {
   x[2]= gxyz[2];
 }
 void AliTPCCorrection::CorrectPointLocal(Float_t x[], Short_t roc) {
-  //
-  // Distorts the initial coordinates x (cartesian coordinates)
-  // according to the given effect (inherited classes)
-  // roc represents the TPC read out chamber (offline numbering convention)
-  //
+  /// Distorts the initial coordinates x (cartesian coordinates)
+  /// according to the given effect (inherited classes)
+  /// roc represents the TPC read out chamber (offline numbering convention)
+
   Float_t gxyz[3]={0,0,0};
   Double_t alpha = TMath::TwoPi()*(roc%18+0.5)/18;
   Double_t ca=TMath::Cos(alpha), sa= TMath::Sin(alpha);
@@ -260,56 +229,53 @@ void AliTPCCorrection::CorrectPointLocal(Float_t x[], Short_t roc) {
 }
 
 void AliTPCCorrection::DistortPoint(const Float_t x[], Short_t roc,Float_t xp[]) {
-  //
-  // Distorts the initial coordinates x (cartesian coordinates) and stores the new 
-  // (distorted) coordinates in xp. The distortion is set according to the given effect (inherited classes)
-  // roc represents the TPC read out chamber (offline numbering convention)
-  //
+  /// Distorts the initial coordinates x (cartesian coordinates) and stores the new
+  /// (distorted) coordinates in xp. The distortion is set according to the given effect (inherited classes)
+  /// roc represents the TPC read out chamber (offline numbering convention)
+
   Float_t dx[3];
   GetDistortion(x,roc,dx);
   for (Int_t j=0;j<3;++j) xp[j]=x[j]+dx[j];
 }
 
 void AliTPCCorrection::GetCorrection(const Float_t /*x*/[], Short_t /*roc*/,Float_t dx[]) {
-  //
-  // This function delivers the correction values dx in respect to the inital coordinates x
-  // roc represents the TPC read out chamber (offline numbering convention)
-  // Note: The dx is overwritten by the inherited effectice class ...
-  //
+  /// This function delivers the correction values dx in respect to the inital coordinates x
+  /// roc represents the TPC read out chamber (offline numbering convention)
+  /// Note: The dx is overwritten by the inherited effectice class ...
+
   for (Int_t j=0;j<3;++j) { dx[j]=0.; }
 }
 
 void AliTPCCorrection::GetDistortion(const Float_t x[], Short_t roc,Float_t dx[]) {
-  //
-  // This function delivers the distortion values dx in respect to the inital coordinates x
-  // roc represents the TPC read out chamber (offline numbering convention)
-  //
+  /// This function delivers the distortion values dx in respect to the inital coordinates x
+  /// roc represents the TPC read out chamber (offline numbering convention)
+
   GetCorrection(x,roc,dx);
   for (Int_t j=0;j<3;++j) dx[j]=-dx[j];
 }
 
 void AliTPCCorrection::GetCorrectionDz(const Float_t x[], Short_t roc,Float_t dx[], Float_t delta) {
-  // author: marian.ivanov@cern.ch
-  //
-  // In this (virtual)function calculates the dx'/dz,  dy'/dz  and dz'/dz at given point (x,y,z)
-  // Generic implementation. Better precision can be acchieved knowing the internal structure
-  // of underlying trasnformation. Derived classes can reimplement it.
-  // To calculate correction is fitted in small neighberhood:
-  // (x+-delta,y+-delta,z+-delta) where delta is an argument
-  //
-  // Input parameters:
-  //   x[]   - space point corrdinate
-  //   roc   - readout chamber identifier (important e.g to do not miss the side of detector) 
-  //   delta - define the size of neighberhood
-  // Output parameter:
-  //   dx[] - array {dx'/dz,  dy'/dz ,  dz'/dz }
+  /// author: marian.ivanov@cern.ch
+  ///
+  /// In this (virtual)function calculates the dx'/dz,  dy'/dz  and dz'/dz at given point (x,y,z)
+  /// Generic implementation. Better precision can be acchieved knowing the internal structure
+  /// of underlying trasnformation. Derived classes can reimplement it.
+  /// To calculate correction is fitted in small neighberhood:
+  /// (x+-delta,y+-delta,z+-delta) where delta is an argument
+  ///
+  /// Input parameters:
+  ///   x[]   - space point corrdinate
+  ///   roc   - readout chamber identifier (important e.g to do not miss the side of detector)
+  ///   delta - define the size of neighberhood
+  /// Output parameter:
+  ///   dx[] - array {dx'/dz,  dy'/dz ,  dz'/dz }
 
   //   if (fIsLocal){  //standard implemenation provides the correction/distortion integrated over full drift length
-  //    
   //
-  //     GetCorrection(xyz,roc,dxyz);  
+  //
+  //     GetCorrection(xyz,roc,dxyz);
   //   }
-  static TLinearFitter fitx(2,"pol1"); 
+  static TLinearFitter fitx(2,"pol1");
   static TLinearFitter fity(2,"pol1");
   static TLinearFitter fitz(2,"pol1");
   fitx.ClearPoints();
@@ -368,21 +334,21 @@ void AliTPCCorrection::GetCorrectionDz(const Float_t x[], Short_t roc,Float_t dx
 }
 
 void AliTPCCorrection::GetDistortionDz(const Float_t x[], Short_t roc,Float_t dx[], Float_t delta) {
-  // author: marian.ivanov@cern.ch
-  //
-  // In this (virtual)function calculates the dx'/dz,  dy'/dz  and dz'/dz at given point (x,y,z)
-  // Generic implementation. Better precision can be acchieved knowing the internal structure
-  // of underlying trasnformation. Derived classes can reimplement it.
-  // To calculate distortion is fitted in small neighberhood:
-  // (x+-delta,y+-delta,z+-delta) where delta is an argument
-  //
-  // Input parameters:
-  //   x[]   - space point corrdinate
-  //   roc   - readout chamber identifier (important e.g to do not miss the side of detector)
-  //   delta - define the size of neighberhood
-  // Output parameter:
-  //   dx[] - array {dx'/dz,  dy'/dz ,  dz'/dz }
-  
+  /// author: marian.ivanov@cern.ch
+  ///
+  /// In this (virtual)function calculates the dx'/dz,  dy'/dz  and dz'/dz at given point (x,y,z)
+  /// Generic implementation. Better precision can be acchieved knowing the internal structure
+  /// of underlying trasnformation. Derived classes can reimplement it.
+  /// To calculate distortion is fitted in small neighberhood:
+  /// (x+-delta,y+-delta,z+-delta) where delta is an argument
+  ///
+  /// Input parameters:
+  ///   x[]   - space point corrdinate
+  ///   roc   - readout chamber identifier (important e.g to do not miss the side of detector)
+  ///   delta - define the size of neighberhood
+  /// Output parameter:
+  ///   dx[] - array {dx'/dz,  dy'/dz ,  dz'/dz }
+
   static TLinearFitter fitx(2,"pol1");
   static TLinearFitter fity(2,"pol1");
   static TLinearFitter fitz(2,"pol1");
@@ -406,7 +372,7 @@ void AliTPCCorrection::GetDistortionDz(const Float_t x[], Short_t roc,Float_t dx
       zmax=0;
     }
   }
-  
+
   //TODO: in principle one shuld check that x[2]+zdelta*delta does not get 'out of' bounds,
   //      so close to the CE it doesn't change the sign, since then the corrections will be wrong ...
   for (Int_t xdelta=-1; xdelta<=1; xdelta++)
@@ -433,18 +399,17 @@ void AliTPCCorrection::GetDistortionDz(const Float_t x[], Short_t roc,Float_t dx
 }
 
 void AliTPCCorrection::GetCorrectionIntegralDz(const Float_t x[], Short_t roc,Float_t dx[], Float_t delta){
-  //
-  // Integrate 3D distortion along drift lines starting from the roc plane
-  //   to the expected z position of the point, this assumes that dz is small
-  //   and the error propagating to z' instead of the correct z is negligible
-  // To define the drift lines virtual function  AliTPCCorrection::GetCorrectionDz is used
-  //
-  // Input parameters:
-  //   x[]   - space point corrdinate
-  //   roc   - readout chamber identifier (important e.g to do not miss the side of detector) 
-  //   delta - define the size of neighberhood
-  // Output parameter:
-  //   dx[] - array { integral(dx'/dz),  integral(dy'/dz) ,  integral(dz'/dz) }
+  /// Integrate 3D distortion along drift lines starting from the roc plane
+  ///   to the expected z position of the point, this assumes that dz is small
+  ///   and the error propagating to z' instead of the correct z is negligible
+  /// To define the drift lines virtual function  AliTPCCorrection::GetCorrectionDz is used
+  ///
+  /// Input parameters:
+  ///   x[]   - space point corrdinate
+  ///   roc   - readout chamber identifier (important e.g to do not miss the side of detector)
+  ///   delta - define the size of neighberhood
+  /// Output parameter:
+  ///   dx[] - array { integral(dx'/dz),  integral(dy'/dz) ,  integral(dz'/dz) }
 
   Float_t zroc= ((roc%36)<18) ? fgkTPCZ0:-fgkTPCZ0;
   Double_t zdrift = TMath::Abs(x[2]-zroc);
@@ -470,7 +435,7 @@ void AliTPCCorrection::GetCorrectionIntegralDz(const Float_t x[], Short_t roc,Fl
     // since at larger drift (smaller z) the corrections are larger (absolute, but negative)
     //  the slopes will be positive.
     // but since we chose deltaZ opposite sign the singn of the corretion should be fine
-    
+
     Float_t xyz2[3]={xyz[0],xyz[1],static_cast<Float_t>(xyz[2]+deltaZ/2.)};
     GetCorrectionDz(xyz2,roc,dxyz,delta/2.);
     xyz[0]+=deltaZ*dxyz[0];
@@ -485,17 +450,16 @@ void AliTPCCorrection::GetCorrectionIntegralDz(const Float_t x[], Short_t roc,Fl
 }
 
 void AliTPCCorrection::GetDistortionIntegralDz(const Float_t x[], Short_t roc,Float_t dx[], Float_t delta){
-  //
-  // Integrate 3D distortion along drift lines
-  // To define the drift lines virtual function  AliTPCCorrection::GetCorrectionDz is used
-  //
-  // Input parameters:
-  //   x[]   - space point corrdinate
-  //   roc   - readout chamber identifier (important e.g to do not miss the side of detector)
-  //   delta - define the size of neighberhood
-  // Output parameter:
-  //   dx[] - array { integral(dx'/dz),  integral(dy'/dz) ,  integral(dz'/dz) }
-  
+  /// Integrate 3D distortion along drift lines
+  /// To define the drift lines virtual function  AliTPCCorrection::GetCorrectionDz is used
+  ///
+  /// Input parameters:
+  ///   x[]   - space point corrdinate
+  ///   roc   - readout chamber identifier (important e.g to do not miss the side of detector)
+  ///   delta - define the size of neighberhood
+  /// Output parameter:
+  ///   dx[] - array { integral(dx'/dz),  integral(dy'/dz) ,  integral(dz'/dz) }
+
   Float_t zroc= ((roc%36)<18) ? fgkTPCZ0:-fgkTPCZ0;
   Double_t zdrift = TMath::Abs(x[2]-zroc);
   Int_t    nsteps = Int_t(zdrift/delta)+1;
@@ -525,49 +489,44 @@ void AliTPCCorrection::GetDistortionIntegralDz(const Float_t x[], Short_t roc,Fl
   dx[0]=xyz[0]-x[0];
   dx[1]=xyz[1]-x[1];
   dx[2]=      sumdz;  //TODO: is sumdz correct?
-  
+
 }
 
 
 void AliTPCCorrection::Init() {
-  //
-  // Initialization funtion (not used at the moment)
-  //
+  /// Initialization funtion (not used at the moment)
+
 }
 
 void AliTPCCorrection::Update(const TTimeStamp &/*timeStamp*/) {
-  //
-  // Update function 
-  //
+  /// Update function
+
 }
 
 void AliTPCCorrection::Print(Option_t* /*option*/) const {
-  //
-  // Print function to check which correction classes are used 
-  // option=="d" prints details regarding the setted magnitude 
-  // option=="a" prints the C0 and C1 coefficents for calibration purposes
-  //
+  /// Print function to check which correction classes are used
+  /// option=="d" prints details regarding the setted magnitude
+  /// option=="a" prints the C0 and C1 coefficents for calibration purposes
+
   printf("TPC spacepoint correction: \"%s\"\n",GetTitle());
 }
 
 void AliTPCCorrection:: SetOmegaTauT1T2(Float_t /*omegaTau*/,Float_t t1,Float_t t2) {
-  //
-  // Virtual funtion to pass the wt values (might become event dependent) to the inherited classes
-  // t1 and t2 represent the "effective omegaTau" corrections and were measured in a dedicated
-  // calibration run
-  //
+  /// Virtual funtion to pass the wt values (might become event dependent) to the inherited classes
+  /// t1 and t2 represent the "effective omegaTau" corrections and were measured in a dedicated
+  /// calibration run
+
   fT1=t1;
   fT2=t2;
   //SetOmegaTauT1T2(omegaTau, t1, t2);
 }
 
 TH2F* AliTPCCorrection::CreateHistoDRinXY(Float_t z,Int_t nx,Int_t ny) {
-  //
-  // Simple plot functionality.
-  // Returns a 2d hisogram which represents the corrections in radial direction (dr)
-  // in respect to position z within the XY plane.
-  // The histogramm has nx times ny entries. 
-  //
+  /// Simple plot functionality.
+  /// Returns a 2d hisogram which represents the corrections in radial direction (dr)
+  /// in respect to position z within the XY plane.
+  /// The histogramm has nx times ny entries.
+
   AliTPCParam* tpcparam = new AliTPCParamSR;
 
   TH2F *h=CreateTH2F("dr_xy", TString::Format("%s: DRinXY Z=%2.0f", GetTitle(),z).Data(),"x [cm]","y [cm]","dr [cm]",
@@ -594,12 +553,10 @@ TH2F* AliTPCCorrection::CreateHistoDRinXY(Float_t z,Int_t nx,Int_t ny) {
 }
 
 TH2F* AliTPCCorrection::CreateHistoDRPhiinXY(Float_t z,Int_t nx,Int_t ny) {
-  //
-  // Simple plot functionality.
-  // Returns a 2d hisogram which represents the corrections in rphi direction (drphi) 
-  // in respect to position z within the XY plane.
-  // The histogramm has nx times ny entries. 
-  //
+  /// Simple plot functionality.
+  /// Returns a 2d hisogram which represents the corrections in rphi direction (drphi)
+  /// in respect to position z within the XY plane.
+  /// The histogramm has nx times ny entries.
 
   AliTPCParam* tpcparam = new AliTPCParamSR;
 
@@ -621,7 +578,7 @@ TH2F* AliTPCCorrection::CreateHistoDRPhiinXY(Float_t z,Int_t nx,Int_t ny) {
 	Float_t dphi=phi1-phi0;
 	if (dphi<TMath::Pi()) dphi+=TMath::TwoPi();
 	if (dphi>TMath::Pi()) dphi-=TMath::TwoPi();
-      
+
 	h->SetBinContent(ix,iy,r0*dphi);
       }
       else
@@ -633,15 +590,13 @@ TH2F* AliTPCCorrection::CreateHistoDRPhiinXY(Float_t z,Int_t nx,Int_t ny) {
 }
 
 TH2F* AliTPCCorrection::CreateHistoDZinXY(Float_t z,Int_t nx,Int_t ny) {
-  //
-  // Simple plot functionality.
-  // Returns a 2d hisogram which represents the corrections in longitudinal direction (dz)
-  // in respect to position z within the XY plane.
-  // The histogramm has nx times ny entries. 
-  //
+  /// Simple plot functionality.
+  /// Returns a 2d hisogram which represents the corrections in longitudinal direction (dz)
+  /// in respect to position z within the XY plane.
+  /// The histogramm has nx times ny entries.
 
   AliTPCParam* tpcparam = new AliTPCParamSR;
- 
+
   TH2F *h=CreateTH2F("dz_xy",TString::Format("%s: DZinXY Z=%2.0f", GetTitle(),z).Data(),"x [cm]","y [cm]","dz [cm]",
 		     nx,-250.,250.,ny,-250.,250.);
   Float_t x[3],dx[3];
@@ -665,12 +620,11 @@ TH2F* AliTPCCorrection::CreateHistoDZinXY(Float_t z,Int_t nx,Int_t ny) {
 }
 
 TH2F* AliTPCCorrection::CreateHistoDRinZR(Float_t phi,Int_t nz,Int_t nr) {
-  //
-  // Simple plot functionality.
-  // Returns a 2d hisogram which represents the corrections in r direction (dr) 
-  // in respect to angle phi within the ZR plane.
-  // The histogramm has nx times ny entries. 
-  //
+  /// Simple plot functionality.
+  /// Returns a 2d hisogram which represents the corrections in r direction (dr)
+  /// in respect to angle phi within the ZR plane.
+  /// The histogramm has nx times ny entries.
+
   TH2F *h=CreateTH2F("dr_zr",TString::Format("%s: DRinZR Phi=%2.2f", GetTitle(),phi).Data(),"z [cm]","r [cm]","dr [cm]",
 		     nz,-250.,250.,nr,85.,250.);
   Float_t x[3],dx[3];
@@ -692,12 +646,11 @@ TH2F* AliTPCCorrection::CreateHistoDRinZR(Float_t phi,Int_t nz,Int_t nr) {
 }
 
 TH2F* AliTPCCorrection::CreateHistoDRPhiinZR(Float_t phi,Int_t nz,Int_t nr) {
-  //
-  // Simple plot functionality.
-  // Returns a 2d hisogram which represents the corrections in rphi direction (drphi) 
-  // in respect to angle phi within the ZR plane.
-  // The histogramm has nx times ny entries. 
-  //
+  /// Simple plot functionality.
+  /// Returns a 2d hisogram which represents the corrections in rphi direction (drphi)
+  /// in respect to angle phi within the ZR plane.
+  /// The histogramm has nx times ny entries.
+
   TH2F *h=CreateTH2F("drphi_zr", TString::Format("%s: DRPhiinZR R=%2.2f", GetTitle(),phi).Data(),"z [cm]","r [cm]","drphi [cm]",
 		     nz,-250.,250.,nr,85.,250.);
   Float_t x[3],dx[3];
@@ -712,11 +665,11 @@ TH2F* AliTPCCorrection::CreateHistoDRPhiinZR(Float_t phi,Int_t nz,Int_t nr) {
       Float_t r0=TMath::Sqrt((x[0]      )*(x[0]      )+(x[1]      )*(x[1]      ));
       Float_t phi0=TMath::ATan2(x[1]      ,x[0]      );
       Float_t phi1=TMath::ATan2(x[1]+dx[1],x[0]+dx[0]);
-      
+
       Float_t dphi=phi1-phi0;
       if (dphi<TMath::Pi()) dphi+=TMath::TwoPi();
       if (dphi>TMath::Pi()) dphi-=TMath::TwoPi();
-      
+
       h->SetBinContent(iz,ir,r0*dphi);
     }
   }
@@ -724,12 +677,11 @@ TH2F* AliTPCCorrection::CreateHistoDRPhiinZR(Float_t phi,Int_t nz,Int_t nr) {
 }
 
 TH2F* AliTPCCorrection::CreateHistoDZinZR(Float_t phi,Int_t nz,Int_t nr) {
-  //
-  // Simple plot functionality.
-  // Returns a 2d hisogram which represents the corrections in longitudinal direction (dz) 
-  // in respect to angle phi within the ZR plane.
-  // The histogramm has nx times ny entries. 
-  //
+  /// Simple plot functionality.
+  /// Returns a 2d hisogram which represents the corrections in longitudinal direction (dz)
+  /// in respect to angle phi within the ZR plane.
+  /// The histogramm has nx times ny entries.
+
   TH2F *h=CreateTH2F("dz_zr",TString::Format("%s: DZinZR Z=%2.0f", GetTitle(),phi).Data(),"z [cm]","r [cm]","dz [cm]",
 		     nz,-250.,250.,nr,85.,250.);
   Float_t x[3],dx[3];
@@ -753,10 +705,8 @@ TH2F* AliTPCCorrection::CreateTH2F(const char *name,const char *title,
 				   const char *xlabel,const char *ylabel,const char *zlabel,
 				  Int_t nbinsx,Double_t xlow,Double_t xup,
 				  Int_t nbinsy,Double_t ylow,Double_t yup) {
-  //
-  // Helper function to create a 2d histogramm of given size
-  //
-  
+  /// Helper function to create a 2d histogramm of given size
+
   TString hname=name;
   Int_t i=0;
   if (gDirectory) {
@@ -779,11 +729,10 @@ TH2F* AliTPCCorrection::CreateTH2F(const char *name,const char *title,
 
 // Simple Interpolation functions: e.g. with bi(tri)cubic interpolations (not yet in TH2 and TH3)
 
-void AliTPCCorrection::Interpolate2DEdistortion( Int_t order, Double_t r, Double_t z, 
+void AliTPCCorrection::Interpolate2DEdistortion( Int_t order, Double_t r, Double_t z,
 						  const Double_t er[kNZ][kNR], Double_t &erValue ) {
-  //
-  // Interpolate table - 2D interpolation
-  //
+  /// Interpolate table - 2D interpolation
+
   Double_t saveEr[5] = {0,0,0,0,0};
 
   Search( kNZ,   fgkZList,  z,   fJLow   ) ;
@@ -800,13 +749,11 @@ void AliTPCCorrection::Interpolate2DEdistortion( Int_t order, Double_t r, Double
 
 }
 
-void AliTPCCorrection::Interpolate3DEdistortion( Int_t order, Double_t r, Float_t phi, Double_t z, 
+void AliTPCCorrection::Interpolate3DEdistortion( Int_t order, Double_t r, Float_t phi, Double_t z,
 						 const Double_t er[kNZ][kNPhi][kNR], const Double_t ephi[kNZ][kNPhi][kNR], const Double_t ez[kNZ][kNPhi][kNR],
 						 Double_t &erValue, Double_t &ephiValue, Double_t &ezValue) {
-  //
-  // Interpolate table - 3D interpolation
-  //
-  
+  /// Interpolate table - 3D interpolation
+
   Double_t saveEr[5]= {0,0,0,0,0};
   Double_t savedEr[5]= {0,0,0,0,0} ;
 
@@ -834,9 +781,9 @@ void AliTPCCorrection::Interpolate3DEdistortion( Int_t order, Double_t r, Float_
       saveEphi[j-fJLow]   = Interpolate( &fgkRList[fKLow], &ephi[i][j][fKLow], order, r ) ;
       saveEz[j-fJLow]     = Interpolate( &fgkRList[fKLow], &ez[i][j][fKLow], order, r )   ;
     }
-    savedEr[i-fILow]     = Interpolate( &fgkPhiList[fJLow], saveEr, order, phi )   ; 
-    savedEphi[i-fILow]   = Interpolate( &fgkPhiList[fJLow], saveEphi, order, phi ) ; 
-    savedEz[i-fILow]     = Interpolate( &fgkPhiList[fJLow], saveEz, order, phi )   ; 
+    savedEr[i-fILow]     = Interpolate( &fgkPhiList[fJLow], saveEr, order, phi )   ;
+    savedEphi[i-fILow]   = Interpolate( &fgkPhiList[fJLow], saveEphi, order, phi ) ;
+    savedEz[i-fILow]     = Interpolate( &fgkPhiList[fJLow], saveEz, order, phi )   ;
   }
   erValue     = Interpolate( &fgkZList[fILow], savedEr, order, z )    ;
   ephiValue   = Interpolate( &fgkZList[fILow], savedEphi, order, z )  ;
@@ -844,12 +791,10 @@ void AliTPCCorrection::Interpolate3DEdistortion( Int_t order, Double_t r, Float_
 
 }
 
-Double_t AliTPCCorrection::Interpolate2DTable( Int_t order, Double_t x, Double_t y, 
-					      Int_t nx,  Int_t ny, const Double_t xv[], const Double_t yv[], 
+Double_t AliTPCCorrection::Interpolate2DTable( Int_t order, Double_t x, Double_t y,
+					      Int_t nx,  Int_t ny, const Double_t xv[], const Double_t yv[],
 					      const TMatrixD &array ) {
-  //
-  // Interpolate table (TMatrix format) - 2D interpolation
-  //
+  /// Interpolate table (TMatrix format) - 2D interpolation
 
   static  Int_t jlow = 0, klow = 0 ;
   Double_t saveArray[5] = {0,0,0,0,0} ;
@@ -875,9 +820,7 @@ Double_t AliTPCCorrection::Interpolate3DTable( Int_t order, Double_t x,   Double
 					      Int_t  nx,    Int_t  ny,    Int_t  nz,
 					      const Double_t xv[], const Double_t yv[], const Double_t zv[],
 					      TMatrixD **arrayofArrays ) {
-  //
-  // Interpolate table (TMatrix format) - 3D interpolation
-  //
+  /// Interpolate table (TMatrix format) - 3D interpolation
 
   static  Int_t ilow = 0, jlow = 0, klow = 0 ;
   Double_t saveArray[5]= {0,0,0,0,0};
@@ -885,7 +828,7 @@ Double_t AliTPCCorrection::Interpolate3DTable( Int_t order, Double_t x,   Double
 
   Search( nx, xv, x, ilow   ) ;
   Search( ny, yv, y, jlow   ) ;
-  Search( nz, zv, z, klow   ) ;  
+  Search( nz, zv, z, klow   ) ;
 
   if ( ilow < 0 ) ilow = 0 ;   // check if out of range
   if ( jlow < 0 ) jlow = 0 ;
@@ -902,23 +845,21 @@ Double_t AliTPCCorrection::Interpolate3DTable( Int_t order, Double_t x,   Double
 	{
 	  saveArray[i-ilow] = Interpolate( &yv[jlow], &table(i,jlow), order, y )   ;
 	}
-      savedArray[k-klow] = Interpolate( &xv[ilow], saveArray, order, x )   ; 
+      savedArray[k-klow] = Interpolate( &xv[ilow], saveArray, order, x )   ;
     }
   return( Interpolate( &zv[klow], savedArray, order, z ) )   ;
 
 }
 
-Double_t AliTPCCorrection::Interpolate( const Double_t xArray[], const Double_t yArray[], 
+Double_t AliTPCCorrection::Interpolate( const Double_t xArray[], const Double_t yArray[],
 				       Int_t order, Double_t x ) {
-  //
-  // Interpolate function Y(x) using linear (order=1) or quadratic (order=2) interpolation.
-  //
+  /// Interpolate function Y(x) using linear (order=1) or quadratic (order=2) interpolation.
 
   Double_t y ;
-  if ( order == 2 ) {                // Quadratic Interpolation = 2 
-    y  = (x-xArray[1]) * (x-xArray[2]) * yArray[0] / ( (xArray[0]-xArray[1]) * (xArray[0]-xArray[2]) ) ; 
-    y += (x-xArray[2]) * (x-xArray[0]) * yArray[1] / ( (xArray[1]-xArray[2]) * (xArray[1]-xArray[0]) ) ; 
-    y += (x-xArray[0]) * (x-xArray[1]) * yArray[2] / ( (xArray[2]-xArray[0]) * (xArray[2]-xArray[1]) ) ; 
+  if ( order == 2 ) {                // Quadratic Interpolation = 2
+    y  = (x-xArray[1]) * (x-xArray[2]) * yArray[0] / ( (xArray[0]-xArray[1]) * (xArray[0]-xArray[2]) ) ;
+    y += (x-xArray[2]) * (x-xArray[0]) * yArray[1] / ( (xArray[1]-xArray[2]) * (xArray[1]-xArray[0]) ) ;
+    y += (x-xArray[0]) * (x-xArray[1]) * yArray[2] / ( (xArray[2]-xArray[0]) * (xArray[2]-xArray[1]) ) ;
   } else {                           // Linear Interpolation = 1
     y  = yArray[0] + ( yArray[1]-yArray[0] ) * ( x-xArray[0] ) / ( xArray[1] - xArray[0] ) ;
   }
@@ -927,13 +868,11 @@ Double_t AliTPCCorrection::Interpolate( const Double_t xArray[], const Double_t
 
 }
 
-Float_t AliTPCCorrection::Interpolate2DTable( Int_t order, Double_t x, Double_t y, 
-					      Int_t nx,  Int_t ny, const Double_t xv[], const Double_t yv[], 
+Float_t AliTPCCorrection::Interpolate2DTable( Int_t order, Double_t x, Double_t y,
+					      Int_t nx,  Int_t ny, const Double_t xv[], const Double_t yv[],
 					      const TMatrixF &array ) {
-  //
-  // Interpolate table (TMatrix format) - 2D interpolation
-  // Float version (in order to decrease the OCDB size)
-  //
+  /// Interpolate table (TMatrix format) - 2D interpolation
+  /// Float version (in order to decrease the OCDB size)
 
   static  Int_t jlow = 0, klow = 0 ;
   Float_t saveArray[5] = {0.,0.,0.,0.,0.} ;
@@ -959,10 +898,8 @@ Float_t AliTPCCorrection::Interpolate3DTable( Int_t order, Double_t x,   Double_
 					      Int_t  nx,    Int_t  ny,    Int_t  nz,
 					      const Double_t xv[], const Double_t yv[], const Double_t zv[],
 					      TMatrixF **arrayofArrays ) {
-  //
-  // Interpolate table (TMatrix format) - 3D interpolation 
-  // Float version (in order to decrease the OCDB size)
-  //
+  /// Interpolate table (TMatrix format) - 3D interpolation
+  /// Float version (in order to decrease the OCDB size)
 
   static  Int_t ilow = 0, jlow = 0, klow = 0 ;
   Float_t saveArray[5]= {0.,0.,0.,0.,0.};
@@ -970,7 +907,7 @@ Float_t AliTPCCorrection::Interpolate3DTable( Int_t order, Double_t x,   Double_
 
   Search( nx, xv, x, ilow   ) ;
   Search( ny, yv, y, jlow   ) ;
-  Search( nz, zv, z, klow   ) ;  
+  Search( nz, zv, z, klow   ) ;
 
   if ( ilow < 0 ) ilow = 0 ;   // check if out of range
   if ( jlow < 0 ) jlow = 0 ;
@@ -987,23 +924,21 @@ Float_t AliTPCCorrection::Interpolate3DTable( Int_t order, Double_t x,   Double_
 	{
 	  saveArray[i-ilow] = Interpolate( &yv[jlow], &table(i,jlow), order, y )   ;
 	}
-      savedArray[k-klow] = Interpolate( &xv[ilow], saveArray, order, x )   ; 
+      savedArray[k-klow] = Interpolate( &xv[ilow], saveArray, order, x )   ;
     }
   return( Interpolate( &zv[klow], savedArray, order, z ) )   ;
 
 }
-Float_t AliTPCCorrection::Interpolate( const Double_t xArray[], const Float_t yArray[], 
+Float_t AliTPCCorrection::Interpolate( const Double_t xArray[], const Float_t yArray[],
 				       Int_t order, Double_t x ) {
-  //
-  // Interpolate function Y(x) using linear (order=1) or quadratic (order=2) interpolation.
-  // Float version (in order to decrease the OCDB size)
-  //
+  /// Interpolate function Y(x) using linear (order=1) or quadratic (order=2) interpolation.
+  /// Float version (in order to decrease the OCDB size)
 
   Float_t y ;
-  if ( order == 2 ) {                // Quadratic Interpolation = 2 
-    y  = (x-xArray[1]) * (x-xArray[2]) * yArray[0] / ( (xArray[0]-xArray[1]) * (xArray[0]-xArray[2]) ) ; 
-    y += (x-xArray[2]) * (x-xArray[0]) * yArray[1] / ( (xArray[1]-xArray[2]) * (xArray[1]-xArray[0]) ) ; 
-    y += (x-xArray[0]) * (x-xArray[1]) * yArray[2] / ( (xArray[2]-xArray[0]) * (xArray[2]-xArray[1]) ) ; 
+  if ( order == 2 ) {                // Quadratic Interpolation = 2
+    y  = (x-xArray[1]) * (x-xArray[2]) * yArray[0] / ( (xArray[0]-xArray[1]) * (xArray[0]-xArray[2]) ) ;
+    y += (x-xArray[2]) * (x-xArray[0]) * yArray[1] / ( (xArray[1]-xArray[2]) * (xArray[1]-xArray[0]) ) ;
+    y += (x-xArray[0]) * (x-xArray[1]) * yArray[2] / ( (xArray[2]-xArray[0]) * (xArray[2]-xArray[1]) ) ;
   } else {                           // Linear Interpolation = 1
     y  = yArray[0] + ( yArray[1]-yArray[0] ) * ( x-xArray[0] ) / ( xArray[1] - xArray[0] ) ;
   }
@@ -1015,20 +950,18 @@ Float_t AliTPCCorrection::Interpolate( const Double_t xArray[], const Float_t yA
 
 
 void AliTPCCorrection::Search( Int_t n, const Double_t xArray[], Double_t x, Int_t &low ) {
-  //
-  // Search an ordered table by starting at the most recently used point
-  //
+  /// Search an ordered table by starting at the most recently used point
 
   Long_t middle, high ;
   Int_t  ascend = 0, increment = 1 ;
 
   if ( xArray[n-1] >= xArray[0] ) ascend = 1 ;  // Ascending ordered table if true
-  
-  if ( low < 0 || low > n-1 ) { 
-    low = -1 ; high = n ; 
+
+  if ( low < 0 || low > n-1 ) {
+    low = -1 ; high = n ;
   } else {                                            // Ordered Search phase
     if ( (Int_t)( x >= xArray[low] ) == ascend )  {
-      if ( low == n-1 ) return ;          
+      if ( low == n-1 ) return ;
       high = low + 1 ;
       while ( (Int_t)( x >= xArray[high] ) == ascend ) {
 	low = high ;
@@ -1047,7 +980,7 @@ void AliTPCCorrection::Search( Int_t n, const Double_t xArray[], Double_t x, Int
       }
     }
   }
-  
+
   while ( (high-low) != 1 ) {                     // Binary Search Phase
     middle = ( high + low ) / 2 ;
     if ( (Int_t)( x >= xArray[middle] ) == ascend )
@@ -1055,30 +988,28 @@ void AliTPCCorrection::Search( Int_t n, const Double_t xArray[], Double_t x, Int
     else
       high = middle ;
   }
-  
+
   if ( x == xArray[n-1] ) low = n-2 ;
   if ( x == xArray[0]   ) low = 0 ;
-  
+
 }
 
 void AliTPCCorrection::InitLookUpfulcrums() {
-  //
-  // Initialization of interpolation points - for main look up table
-  //   (course grid in the middle, fine grid on the borders)
-  //
+  /// Initialization of interpolation points - for main look up table
+  ///   (course grid in the middle, fine grid on the borders)
 
   AliTPCROC * roc = AliTPCROC::Instance();
-  const Double_t rLow =  TMath::Floor(roc->GetPadRowRadii(0,0))-1; // first padRow plus some margin 
+  const Double_t rLow =  TMath::Floor(roc->GetPadRowRadii(0,0))-1; // first padRow plus some margin
 
   // fulcrums in R
   fgkRList[0] = rLow;
   for (Int_t i = 1; i<kNR; i++) {
-    fgkRList[i] = fgkRList[i-1] + 3.5;     // 3.5 cm spacing    
-    if (fgkRList[i]<90 ||fgkRList[i]>245) 
+    fgkRList[i] = fgkRList[i-1] + 3.5;     // 3.5 cm spacing
+    if (fgkRList[i]<90 ||fgkRList[i]>245)
        fgkRList[i] = fgkRList[i-1] + 0.5; // 0.5 cm spacing
-    else if (fgkRList[i]<100 || fgkRList[i]>235) 
+    else if (fgkRList[i]<100 || fgkRList[i]>235)
        fgkRList[i] = fgkRList[i-1] + 1.5;  // 1.5 cm spacing
-    else if (fgkRList[i]<120 || fgkRList[i]>225) 
+    else if (fgkRList[i]<120 || fgkRList[i]>225)
        fgkRList[i] = fgkRList[i-1] + 2.5;  // 2.5 cm spacing
   }
 
@@ -1091,55 +1022,53 @@ void AliTPCCorrection::InitLookUpfulcrums() {
       fgkZList[j] = fgkZList[j-1] + 0.09; // 0.09 cm spacing
     else if(TMath::Abs(fgkZList[j])< 0.6)
       fgkZList[j] = fgkZList[j-1] + 0.4; // 0.4 cm spacing
-    else if      (TMath::Abs(fgkZList[j])< 2.5 || TMath::Abs(fgkZList[j])>248) 
+    else if      (TMath::Abs(fgkZList[j])< 2.5 || TMath::Abs(fgkZList[j])>248)
       fgkZList[j] = fgkZList[j-1] + 0.5; // 0.5 cm spacing
-    else if (TMath::Abs(fgkZList[j])<10 || TMath::Abs(fgkZList[j])>235) 
+    else if (TMath::Abs(fgkZList[j])<10 || TMath::Abs(fgkZList[j])>235)
       fgkZList[j] = fgkZList[j-1] + 1.5;  // 1.5 cm spacing
-    else if (TMath::Abs(fgkZList[j])<25 || TMath::Abs(fgkZList[j])>225) 
+    else if (TMath::Abs(fgkZList[j])<25 || TMath::Abs(fgkZList[j])>225)
       fgkZList[j] = fgkZList[j-1] + 2.5;  // 2.5 cm spacing
-    else 
+    else
       fgkZList[j] = fgkZList[j-1] + 4;  // 4 cm spacing
 
     fgkZList[kNZ-j-1] = -fgkZList[j];
   }
-  
+
   // fulcrums in phi
-  for (Int_t k = 0; k<kNPhi; k++) 
-    fgkPhiList[k] = TMath::TwoPi()*k/(kNPhi-1);    
-  
-  
+  for (Int_t k = 0; k<kNPhi; k++)
+    fgkPhiList[k] = TMath::TwoPi()*k/(kNPhi-1);
+
+
 }
 
 
-void AliTPCCorrection::PoissonRelaxation2D(TMatrixD &arrayV, TMatrixD &chargeDensity, 
-					   TMatrixD &arrayErOverEz, TMatrixD &arrayDeltaEz, 
+void AliTPCCorrection::PoissonRelaxation2D(TMatrixD &arrayV, TMatrixD &chargeDensity,
+					   TMatrixD &arrayErOverEz, TMatrixD &arrayDeltaEz,
 					   Int_t rows, Int_t columns, Int_t iterations,
 					   Bool_t rocDisplacement ) {
-  //
-  // Solve Poisson's Equation by Relaxation Technique in 2D (assuming cylindrical symmetry)
-  //
-  // Solve Poissons equation in a cylindrical coordinate system. The arrayV matrix must be filled with the 
-  // boundary conditions on the first and last rows, and the first and last columns.  The remainder of the 
-  // array can be blank or contain a preliminary guess at the solution.  The Charge density matrix contains 
-  // the enclosed spacecharge density at each point. The charge density matrix can be full of zero's if 
-  // you wish to solve Laplaces equation however it should not contain random numbers or you will get 
-  // random numbers back as a solution. 
-  // Poisson's equation is solved by iteratively relaxing the matrix to the final solution.  In order to 
-  // speed up the convergence to the best solution, this algorithm does a binary expansion of the solution 
-  // space.  First it solves the problem on a very sparse grid by skipping rows and columns in the original 
-  // matrix.  Then it doubles the number of points and solves the problem again.  Then it doubles the 
-  // number of points and solves the problem again.  This happens several times until the maximum number
-  // of points has been included in the array.  
-  //
-  // NOTE: In order for this algorithmto work, the number of rows and columns must be a power of 2 plus one.
-  // So rows == 2**M + 1 and columns == 2**N + 1.  The number of rows and columns can be different.
-  // 
-  // NOTE: rocDisplacement is used to include (or ignore) the ROC misalignment in the dz calculation
-  //
-  // Original code by Jim Thomas (STAR TPC Collaboration)
-  //
-
-  Double_t ezField = (fgkCathodeV-fgkGG)/fgkTPCZ0; // = ALICE Electric Field (V/cm) Magnitude ~ -400 V/cm; 
+  /// Solve Poisson's Equation by Relaxation Technique in 2D (assuming cylindrical symmetry)
+  ///
+  /// Solve Poissons equation in a cylindrical coordinate system. The arrayV matrix must be filled with the
+  /// boundary conditions on the first and last rows, and the first and last columns.  The remainder of the
+  /// array can be blank or contain a preliminary guess at the solution.  The Charge density matrix contains
+  /// the enclosed spacecharge density at each point. The charge density matrix can be full of zero's if
+  /// you wish to solve Laplaces equation however it should not contain random numbers or you will get
+  /// random numbers back as a solution.
+  /// Poisson's equation is solved by iteratively relaxing the matrix to the final solution.  In order to
+  /// speed up the convergence to the best solution, this algorithm does a binary expansion of the solution
+  /// space.  First it solves the problem on a very sparse grid by skipping rows and columns in the original
+  /// matrix.  Then it doubles the number of points and solves the problem again.  Then it doubles the
+  /// number of points and solves the problem again.  This happens several times until the maximum number
+  /// of points has been included in the array.
+  ///
+  /// NOTE: In order for this algorithmto work, the number of rows and columns must be a power of 2 plus one.
+  /// So rows == 2**M + 1 and columns == 2**N + 1.  The number of rows and columns can be different.
+  ///
+  /// NOTE: rocDisplacement is used to include (or ignore) the ROC misalignment in the dz calculation
+  ///
+  /// Original code by Jim Thomas (STAR TPC Collaboration)
+
+  Double_t ezField = (fgkCathodeV-fgkGG)/fgkTPCZ0; // = ALICE Electric Field (V/cm) Magnitude ~ -400 V/cm;
 
   const Float_t  gridSizeR   =  (fgkOFCRadius-fgkIFCRadius) / (rows-1) ;
   const Float_t  gridSizeZ   =  fgkTPCZ0 / (columns-1) ;
@@ -1149,7 +1078,7 @@ void AliTPCCorrection::PoissonRelaxation2D(TMatrixD &arrayV, TMatrixD &chargeDen
   TMatrixD  arrayEz(rows,columns) ;
 
   //Check that number of rows and columns is suitable for a binary expansion
-  
+
   if ( !IsPowerOfTwo(rows-1) ) {
     AliError("PoissonRelaxation - Error in the number of rows. Must be 2**M - 1");
     return;
@@ -1158,40 +1087,40 @@ void AliTPCCorrection::PoissonRelaxation2D(TMatrixD &arrayV, TMatrixD &chargeDen
     AliError("PoissonRelaxation - Error in the number of columns. Must be 2**N - 1");
     return;
   }
-  
+
   // Solve Poisson's equation in cylindrical coordinates by relaxation technique
   // Allow for different size grid spacing in R and Z directions
   // Use a binary expansion of the size of the matrix to speed up the solution of the problem
-  
+
   Int_t iOne = (rows-1)/4 ;
   Int_t jOne = (columns-1)/4 ;
   // Solve for N in 2**N, add one.
-  Int_t loops = 1 + (int) ( 0.5 + TMath::Log2( (double) TMath::Max(iOne,jOne) ) ) ;  
+  Int_t loops = 1 + (int) ( 0.5 + TMath::Log2( (double) TMath::Max(iOne,jOne) ) ) ;
 
-  for ( Int_t count = 0 ; count < loops ; count++ ) { 
+  for ( Int_t count = 0 ; count < loops ; count++ ) {
     // Loop while the matrix expands & the resolution increases.
 
     Float_t tempGridSizeR = gridSizeR * iOne ;
     Float_t tempRatio     = ratio * iOne * iOne / ( jOne * jOne ) ;
     Float_t tempFourth    = 1.0 / (2.0 + 2.0*tempRatio) ;
-    
+
     // Do this the standard C++ way to avoid gcc extensions for Float_t coef1[rows]
-    std::vector<float> coef1(rows) ;  
-    std::vector<float> coef2(rows) ;  
+    std::vector<float> coef1(rows) ;
+    std::vector<float> coef2(rows) ;
 
     for ( Int_t i = iOne ; i < rows-1 ; i+=iOne ) {
        Float_t radius = fgkIFCRadius + i*gridSizeR ;
       coef1[i] = 1.0 + tempGridSizeR/(2*radius);
       coef2[i] = 1.0 - tempGridSizeR/(2*radius);
     }
-    
+
     TMatrixD sumChargeDensity(rows,columns) ;
 
     for ( Int_t i = iOne ; i < rows-1 ; i += iOne ) {
       Float_t radius = fgkIFCRadius + iOne*gridSizeR ;
       for ( Int_t j = jOne ; j < columns-1 ; j += jOne ) {
 	if ( iOne == 1 && jOne == 1 ) sumChargeDensity(i,j) = chargeDensity(i,j) ;
-	else {        
+	else {
 	  // Add up all enclosed charge density contributions within 1/2 unit in all directions
 	  Float_t weight = 0.0 ;
 	  Float_t sum    = 0.0 ;
@@ -1202,7 +1131,7 @@ void AliTPCCorrection::PoissonRelaxation2D(TMatrixD &arrayV, TMatrixD &chargeDen
 	      else
 		weight = 1.0 ;
 	      // Note that this is cylindrical geometry
-	      sumChargeDensity(i,j) += chargeDensity(ii,jj)*weight*radius ;  
+	      sumChargeDensity(i,j) += chargeDensity(ii,jj)*weight*radius ;
 	      sum += weight*radius ;
 	    }
 	  }
@@ -1212,34 +1141,34 @@ void AliTPCCorrection::PoissonRelaxation2D(TMatrixD &arrayV, TMatrixD &chargeDen
        }
     }
 
-    for ( Int_t k = 1 ; k <= iterations; k++ ) {               
+    for ( Int_t k = 1 ; k <= iterations; k++ ) {
       // Solve Poisson's Equation
-      // Over-relaxation index, must be >= 1 but < 2.  Arrange for it to evolve from 2 => 1 
+      // Over-relaxation index, must be >= 1 but < 2.  Arrange for it to evolve from 2 => 1
       // as interations increase.
-      Float_t overRelax   = 1.0 + TMath::Sqrt( TMath::Cos( (k*TMath::PiOver2())/iterations ) ) ; 
+      Float_t overRelax   = 1.0 + TMath::Sqrt( TMath::Cos( (k*TMath::PiOver2())/iterations ) ) ;
       Float_t overRelaxM1 = overRelax - 1.0 ;
       Float_t overRelaxtempFourth, overRelaxcoef5 ;
       overRelaxtempFourth = overRelax * tempFourth ;
-      overRelaxcoef5 = overRelaxM1 / overRelaxtempFourth ; 
+      overRelaxcoef5 = overRelaxM1 / overRelaxtempFourth ;
 
       for ( Int_t i = iOne ; i < rows-1 ; i += iOne ) {
 	for ( Int_t j = jOne ; j < columns-1 ; j += jOne ) {
 
 	  arrayV(i,j) = (   coef2[i]       *   arrayV(i-iOne,j)
 			  + tempRatio      * ( arrayV(i,j-jOne) + arrayV(i,j+jOne) )
-			  - overRelaxcoef5 *   arrayV(i,j) 
-			  + coef1[i]       *   arrayV(i+iOne,j) 
-			  + sumChargeDensity(i,j) 
+			  - overRelaxcoef5 *   arrayV(i,j)
+			  + coef1[i]       *   arrayV(i+iOne,j)
+			  + sumChargeDensity(i,j)
 			) * overRelaxtempFourth;
 	}
       }
 
-      if ( k == iterations ) {    
+      if ( k == iterations ) {
 	// After full solution is achieved, copy low resolution solution into higher res array
 	for ( Int_t i = iOne ; i < rows-1 ; i += iOne ) {
 	  for ( Int_t j = jOne ; j < columns-1 ; j += jOne ) {
 
-	    if ( iOne > 1 ) {              
+	    if ( iOne > 1 ) {
 	      arrayV(i+iOne/2,j)                    =  ( arrayV(i+iOne,j) + arrayV(i,j)     ) / 2 ;
 	      if ( i == iOne )  arrayV(i-iOne/2,j) =  ( arrayV(0,j)       + arrayV(iOne,j) ) / 2 ;
 	    }
@@ -1251,7 +1180,7 @@ void AliTPCCorrection::PoissonRelaxation2D(TMatrixD &arrayV, TMatrixD &chargeDen
 	      arrayV(i+iOne/2,j+jOne/2) =  ( arrayV(i+iOne,j+jOne) + arrayV(i,j) ) / 2 ;
 	      if ( i == iOne ) arrayV(i-iOne/2,j-jOne/2) =   ( arrayV(0,j-jOne) + arrayV(iOne,j) ) / 2 ;
 	      if ( j == jOne ) arrayV(i-iOne/2,j-jOne/2) =   ( arrayV(i-iOne,0) + arrayV(i,jOne) ) / 2 ;
-	      // Note that this leaves a point at the upper left and lower right corners uninitialized. 
+	      // Note that this leaves a point at the upper left and lower right corners uninitialized.
 	      // -> Not a big deal.
 	    }
 
@@ -1265,40 +1194,40 @@ void AliTPCCorrection::PoissonRelaxation2D(TMatrixD &arrayV, TMatrixD &chargeDen
     jOne = jOne / 2 ; if ( jOne < 1 ) jOne = 1 ;
 
     sumChargeDensity.Clear();
-  }      
+  }
 
   // Differentiate V(r) and solve for E(r) using special equations for the first and last rows
-  for ( Int_t j = 0 ; j < columns ; j++ ) {	  
+  for ( Int_t j = 0 ; j < columns ; j++ ) {
     for ( Int_t i = 1 ; i < rows-1 ; i++ ) arrayEr(i,j) = -1 * ( arrayV(i+1,j) - arrayV(i-1,j) ) / (2*gridSizeR) ;
-    arrayEr(0,j)      =  -1 * ( -0.5*arrayV(2,j) + 2.0*arrayV(1,j) - 1.5*arrayV(0,j) ) / gridSizeR ;  
-    arrayEr(rows-1,j) =  -1 * ( 1.5*arrayV(rows-1,j) - 2.0*arrayV(rows-2,j) + 0.5*arrayV(rows-3,j) ) / gridSizeR ; 
+    arrayEr(0,j)      =  -1 * ( -0.5*arrayV(2,j) + 2.0*arrayV(1,j) - 1.5*arrayV(0,j) ) / gridSizeR ;
+    arrayEr(rows-1,j) =  -1 * ( 1.5*arrayV(rows-1,j) - 2.0*arrayV(rows-2,j) + 0.5*arrayV(rows-3,j) ) / gridSizeR ;
   }
 
   // Differentiate V(z) and solve for E(z) using special equations for the first and last columns
   for ( Int_t i = 0 ; i < rows ; i++) {
     for ( Int_t j = 1 ; j < columns-1 ; j++ ) arrayEz(i,j) = -1 * ( arrayV(i,j+1) - arrayV(i,j-1) ) / (2*gridSizeZ) ;
-    arrayEz(i,0)         =  -1 * ( -0.5*arrayV(i,2) + 2.0*arrayV(i,1) - 1.5*arrayV(i,0) ) / gridSizeZ ;  
-    arrayEz(i,columns-1) =  -1 * ( 1.5*arrayV(i,columns-1) - 2.0*arrayV(i,columns-2) + 0.5*arrayV(i,columns-3) ) / gridSizeZ ; 
+    arrayEz(i,0)         =  -1 * ( -0.5*arrayV(i,2) + 2.0*arrayV(i,1) - 1.5*arrayV(i,0) ) / gridSizeZ ;
+    arrayEz(i,columns-1) =  -1 * ( 1.5*arrayV(i,columns-1) - 2.0*arrayV(i,columns-2) + 0.5*arrayV(i,columns-3) ) / gridSizeZ ;
   }
-  
+
   for ( Int_t i = 0 ; i < rows ; i++) {
     // Note: go back and compare to old version of this code.  See notes below.
     // JT Test ... attempt to divide by real Ez not Ez to first order
     for ( Int_t j = 0 ; j < columns ; j++ ) {
       arrayEz(i,j) += ezField;
       // This adds back the overall Z gradient of the field (main E field component)
-    } 
+    }
     // Warning: (-=) assumes you are using an error potetial without the overall Field included
-  }                                 
-  
+  }
+
   // Integrate Er/Ez from Z to zero
-  for ( Int_t j = 0 ; j < columns ; j++ )  {	  
+  for ( Int_t j = 0 ; j < columns ; j++ )  {
     for ( Int_t i = 0 ; i < rows ; i++ ) {
-      
-      Int_t index = 1 ;   // Simpsons rule if N=odd.  If N!=odd then add extra point by trapezoidal rule.  
+
+      Int_t index = 1 ;   // Simpsons rule if N=odd.  If N!=odd then add extra point by trapezoidal rule.
       arrayErOverEz(i,j) = 0.0 ;
       arrayDeltaEz(i,j) = 0.0 ;
-      
+
       for ( Int_t k = j ; k < columns ; k++ ) {
 	arrayErOverEz(i,j)  +=  index*(gridSizeZ/3.0)*arrayEr(i,k)/arrayEz(i,k) ;
 	arrayDeltaEz(i,j)   +=  index*(gridSizeZ/3.0)*(arrayEz(i,k)-ezField) ;
@@ -1309,9 +1238,9 @@ void AliTPCCorrection::PoissonRelaxation2D(TMatrixD &arrayV, TMatrixD &chargeDen
 	arrayDeltaEz(i,j)   -=  (gridSizeZ/3.0)*(arrayEz(i,columns-1)-ezField) ;
       }
       if ( index == 2 ) {
-	arrayErOverEz(i,j)  +=  (gridSizeZ/3.0) * ( 0.5*arrayEr(i,columns-2)/arrayEz(i,columns-2) 
+	arrayErOverEz(i,j)  +=  (gridSizeZ/3.0) * ( 0.5*arrayEr(i,columns-2)/arrayEz(i,columns-2)
 						    -2.5*arrayEr(i,columns-1)/arrayEz(i,columns-1));
-	arrayDeltaEz(i,j)   +=  (gridSizeZ/3.0) * ( 0.5*(arrayEz(i,columns-2)-ezField) 
+	arrayDeltaEz(i,j)   +=  (gridSizeZ/3.0) * ( 0.5*(arrayEz(i,columns-2)-ezField)
 						    -2.5*(arrayEz(i,columns-1)-ezField));
       }
       if ( j == columns-2 ) {
@@ -1326,51 +1255,50 @@ void AliTPCCorrection::PoissonRelaxation2D(TMatrixD &arrayV, TMatrixD &chargeDen
       }
     }
   }
-  
+
   // calculate z distortion from the integrated Delta Ez residuals
   // and include the aquivalence (Volt to cm) of the ROC shift !!
 
-  for ( Int_t j = 0 ; j < columns ; j++ )  {	  
+  for ( Int_t j = 0 ; j < columns ; j++ )  {
     for ( Int_t i = 0 ; i < rows ; i++ ) {
 
       // Scale the Ez distortions with the drift velocity pertubation -> delivers cm
       arrayDeltaEz(i,j) = arrayDeltaEz(i,j)*fgkdvdE;
 
       // ROC Potential in cm aquivalent
-      Double_t dzROCShift =  arrayV(i, columns -1)/ezField;  
+      Double_t dzROCShift =  arrayV(i, columns -1)/ezField;
       if ( rocDisplacement ) arrayDeltaEz(i,j) = arrayDeltaEz(i,j) + dzROCShift;  // add the ROC misaligment
 
     }
   }
- 
+
   arrayEr.Clear();
   arrayEz.Clear();
 
 }
 
-void AliTPCCorrection::PoissonRelaxation3D( TMatrixD**arrayofArrayV, TMatrixD**arrayofChargeDensities, 
+void AliTPCCorrection::PoissonRelaxation3D( TMatrixD**arrayofArrayV, TMatrixD**arrayofChargeDensities,
 		    TMatrixD**arrayofEroverEz, TMatrixD**arrayofEPhioverEz, TMatrixD**arrayofDeltaEz,
-		    Int_t rows, Int_t columns,  Int_t phislices, 
+		    Int_t rows, Int_t columns,  Int_t phislices,
 		    Float_t deltaphi, Int_t iterations, Int_t symmetry,
 		    Bool_t rocDisplacement  ) {
-  //
-  // 3D - Solve Poisson's Equation in 3D by Relaxation Technique
-  //
-  //    NOTE: In order for this algorith to work, the number of rows and columns must be a power of 2 plus one.  
-  //    The number of rows and COLUMNS can be different.
-  //
-  //    ROWS       ==  2**M + 1  
-  //    COLUMNS    ==  2**N + 1  
-  //    PHISLICES  ==  Arbitrary but greater than 3
-  //
-  //    DeltaPhi in Radians
-  //
-  //    SYMMETRY = 0 if no phi symmetries, and no phi boundary conditions
-  //             = 1 if we have reflection symmetry at the boundaries (eg. sector symmetry or half sector symmetries).
-  //
-  // NOTE: rocDisplacement is used to include (or ignore) the ROC misalignment in the dz calculation
-
-  const Double_t ezField = (fgkCathodeV-fgkGG)/fgkTPCZ0; // = ALICE Electric Field (V/cm) Magnitude ~ -400 V/cm; 
+  /// 3D - Solve Poisson's Equation in 3D by Relaxation Technique
+  ///
+  ///    NOTE: In order for this algorith to work, the number of rows and columns must be a power of 2 plus one.
+  ///    The number of rows and COLUMNS can be different.
+  ///
+  ///    ROWS       ==  2**M + 1
+  ///    COLUMNS    ==  2**N + 1
+  ///    PHISLICES  ==  Arbitrary but greater than 3
+  ///
+  ///    DeltaPhi in Radians
+  ///
+  ///    SYMMETRY = 0 if no phi symmetries, and no phi boundary conditions
+  /// = 1 if we have reflection symmetry at the boundaries (eg. sector symmetry or half sector symmetries).
+  ///
+  /// NOTE: rocDisplacement is used to include (or ignore) the ROC misalignment in the dz calculation
+
+  const Double_t ezField = (fgkCathodeV-fgkGG)/fgkTPCZ0; // = ALICE Electric Field (V/cm) Magnitude ~ -400 V/cm;
 
   const Float_t  gridSizeR   =  (fgkOFCRadius-fgkIFCRadius) / (rows-1) ;
   const Float_t  gridSizePhi =  deltaphi ;
@@ -1381,19 +1309,19 @@ void AliTPCCorrection::PoissonRelaxation3D( TMatrixD**arrayofArrayV, TMatrixD**a
   TMatrixD arrayE(rows,columns) ;
 
   // Check that the number of rows and columns is suitable for a binary expansion
-  if ( !IsPowerOfTwo((rows-1))    ) {  
-    AliError("Poisson3DRelaxation - Error in the number of rows. Must be 2**M - 1"); 
+  if ( !IsPowerOfTwo((rows-1))    ) {
+    AliError("Poisson3DRelaxation - Error in the number of rows. Must be 2**M - 1");
     return; }
-  if ( !IsPowerOfTwo((columns-1)) ) { 
+  if ( !IsPowerOfTwo((columns-1)) ) {
     AliError("Poisson3DRelaxation - Error in the number of columns. Must be 2**N - 1");
     return; }
-  if ( phislices <= 3   )  { 
+  if ( phislices <= 3   )  {
     AliError("Poisson3DRelaxation - Error in the number of phislices. Must be larger than 3");
     return; }
-  if  ( phislices > 1000 ) { 
-    AliError("Poisson3D  phislices > 1000 is not allowed (nor wise) ");  
-    return; }  
-  
+  if  ( phislices > 1000 ) {
+    AliError("Poisson3D  phislices > 1000 is not allowed (nor wise) ");
+    return; }
+
   // Solve Poisson's equation in cylindrical coordinates by relaxation technique
   // Allow for different size grid spacing in R and Z directions
   // Use a binary expansion of the matrix to speed up the solution of the problem
@@ -1411,7 +1339,7 @@ void AliTPCCorrection::PoissonRelaxation3D( TMatrixD**arrayofArrayV, TMatrixD**a
 
   for ( Int_t count = 0 ; count < loops ; count++ ) {      // START the master loop and do the binary expansion
     AliSysInfo::AddStamp("3Diter", 20,count,0);
-   
+
     Float_t  tempgridSizeR   =  gridSizeR  * ione ;
     Float_t  tempratioPhi    =  ratioPhi * ione * ione ; // Used tobe divided by ( m_one * m_one ) when m_one was != 1
     Float_t  tempratioZ      =  ratioZ   * ione * ione / ( jone * jone ) ;
@@ -1444,8 +1372,8 @@ void AliTPCCorrection::PoissonRelaxation3D( TMatrixD**arrayofArrayV, TMatrixD**a
 	      for ( Int_t jj = j-jone/2 ; jj <= j+jone/2 ; jj++ ) {
 		if ( ii == i-ione/2 || ii == i+ione/2 || jj == j-jone/2 || jj == j+jone/2 ) weight = 0.5 ;
 		else
-		  weight = 1.0 ; 
-		sumChargeDensity(i,j) += chargeDensity(ii,jj)*weight*radius ;  
+		  weight = 1.0 ;
+		sumChargeDensity(i,j) += chargeDensity(ii,jj)*weight*radius ;
 		sum += weight*radius ;
 	      }
 	    }
@@ -1459,20 +1387,20 @@ void AliTPCCorrection::PoissonRelaxation3D( TMatrixD**arrayofArrayV, TMatrixD**a
     for ( Int_t k = 1 ; k <= iterations; k++ ) {
 
       // over-relaxation index, >= 1 but < 2
-      Float_t overRelax   = 1.0 + TMath::Sqrt( TMath::Cos( (k*TMath::PiOver2())/iterations ) ) ; 
+      Float_t overRelax   = 1.0 + TMath::Sqrt( TMath::Cos( (k*TMath::PiOver2())/iterations ) ) ;
       Float_t overRelaxM1 = overRelax - 1.0 ;
 
       std::vector<float> overRelaxcoef4(rows) ;  // Do this the standard C++ way to avoid gcc extensions
       std::vector<float> overRelaxcoef5(rows) ;  // Do this the standard C++ way to avoid gcc extensions
 
-      for ( Int_t i = ione ; i < rows-1 ; i+=ione ) { 
+      for ( Int_t i = ione ; i < rows-1 ; i+=ione ) {
 	overRelaxcoef4[i] = overRelax * coef4[i] ;
-	overRelaxcoef5[i] = overRelaxM1 / overRelaxcoef4[i] ; 
+	overRelaxcoef5[i] = overRelaxM1 / overRelaxcoef4[i] ;
       }
 
       for ( Int_t m = 0 ; m < phislices ; m++ ) {
 
-	mplus  = m + 1;   signplus  = 1 ; 
+	mplus  = m + 1;   signplus  = 1 ;
 	mminus = m - 1 ;  signminus = 1 ;
 	if (symmetry==1) {  // Reflection symmetry in phi (e.g. symmetry at sector boundaries, or half sectors, etc.)
 	  if ( mplus  > phislices-1 ) mplus  = phislices - 2 ;
@@ -1480,7 +1408,7 @@ void AliTPCCorrection::PoissonRelaxation3D( TMatrixD**arrayofArrayV, TMatrixD**a
 	}
 	else if (symmetry==-1) {   // Anti-symmetry in phi
 	  if ( mplus  > phislices-1 ) { mplus  = phislices - 2 ; signplus  = -1 ; }
-	  if ( mminus < 0 )           { mminus = 1 ;	         signminus = -1 ; } 
+	  if ( mminus < 0 )           { mminus = 1 ;	         signminus = -1 ; }
 	}
 		else { // No Symmetries in phi, no boundaries, the calculation is continuous across all phi
 	  if ( mplus  > phislices-1 ) mplus  = m + 1 - phislices ;
@@ -1499,15 +1427,15 @@ void AliTPCCorrection::PoissonRelaxation3D( TMatrixD**arrayofArrayV, TMatrixD**a
 	  // slow implementation
 	  for ( Int_t i = ione ; i < rows-1 ; i+=ione )  {
 	    for ( Int_t j = jone ; j < columns-1 ; j+=jone ) {
-	      
+
 	      arrayV(i,j) = (   coef2[i]          *   arrayV(i-ione,j)
 				+ tempratioZ        * ( arrayV(i,j-jone)  +  arrayV(i,j+jone) )
-				- overRelaxcoef5[i] *   arrayV(i,j) 
-				+ coef1[i]          *   arrayV(i+ione,j)  
+				- overRelaxcoef5[i] *   arrayV(i,j)
+				+ coef1[i]          *   arrayV(i+ione,j)
 				+ coef3[i]          * ( signplus*arrayVP(i,j)       +  signminus*arrayVM(i,j) )
-				+ sumChargeDensity(i,j) 
-				) * overRelaxcoef4[i] ;     
-	      // Note: over-relax the solution at each step.  This speeds up the convergance.	      
+				+ sumChargeDensity(i,j)
+				) * overRelaxcoef4[i] ;
+	      // Note: over-relax the solution at each step.  This speeds up the convergance.
 	    }
 	  }
 	}else{
@@ -1520,23 +1448,23 @@ void AliTPCCorrection::PoissonRelaxation3D( TMatrixD**arrayofArrayV, TMatrixD**a
 	      Double_t /*resSlow*/resFast;
 // 	      resSlow  = (   coef2[i]          *   arrayV(i-ione,j)
 // 				+ tempratioZ        * ( arrayV(i,j-jone)  +  arrayV(i,j+jone) )
-// 				- overRelaxcoef5[i] *   arrayV(i,j) 
-// 				+ coef1[i]          *   arrayV(i+ione,j)  
+// 				- overRelaxcoef5[i] *   arrayV(i,j)
+// 				+ coef1[i]          *   arrayV(i+ione,j)
 // 				+ coef3[i]          * ( signplus*arrayVP(i,j)       +  signminus*arrayVM(i,j) )
-// 				+ sumChargeDensity(i,j) 
-// 				) * overRelaxcoef4[i] ;     
+// 				+ sumChargeDensity(i,j)
+// 				) * overRelaxcoef4[i] ;
 	      resFast   = (   coef2[i]          *   arrayVfastI[j-columns*ione]
 			      + tempratioZ        * ( arrayVfastI[j-jone]  +  arrayVfastI[j+jone] )
-			      - overRelaxcoef5[i] *   arrayVfastI[j] 
-			      + coef1[i]          * arrayVfastI[j+columns*ione]    
+			      - overRelaxcoef5[i] *   arrayVfastI[j]
+			      + coef1[i]          * arrayVfastI[j+columns*ione]
 			      + coef3[i]          * ( signplus* arrayVPfastI[j]      +  signminus*arrayVMfastI[j])
-			      + sumChargeDensityFastI[j] 
-			      ) * overRelaxcoef4[i] ;     
+			      + sumChargeDensityFastI[j]
+			      ) * overRelaxcoef4[i] ;
 // 	      if (resSlow!=resFast){
 // 		printf("problem\t%d\t%d\t%f\t%f\t%f\n",i,j,resFast,resSlow,resFast-resSlow);
 // 	      }
 	      arrayVfastI[j]=resFast;
-	      // Note: over-relax the solution at each step.  This speeds up the convergance.	      
+	      // Note: over-relax the solution at each step.  This speeds up the convergance.
 	    }
 	  }
 	}
@@ -1544,8 +1472,8 @@ void AliTPCCorrection::PoissonRelaxation3D( TMatrixD**arrayofArrayV, TMatrixD**a
 	if ( k == iterations ) {   // After full solution is achieved, copy low resolution solution into higher res array
 	  for ( Int_t i = ione ; i < rows-1 ; i+=ione )  {
 	    for ( Int_t j = jone ; j < columns-1 ; j+=jone ) {
-	      
-	      if ( ione > 1 ) {              
+
+	      if ( ione > 1 ) {
 		arrayV(i+ione/2,j)                    =  ( arrayV(i+ione,j) + arrayV(i,j)     ) / 2 ;
 		if ( i == ione )  arrayV(i-ione/2,j) =  ( arrayV(0,j)       + arrayV(ione,j) ) / 2 ;
 	      }
@@ -1559,18 +1487,18 @@ void AliTPCCorrection::PoissonRelaxation3D( TMatrixD**arrayofArrayV, TMatrixD**a
 		if ( j == jone ) arrayV(i-ione/2,j-jone/2) =   ( arrayV(i-ione,0) + arrayV(i,jone) ) / 2 ;
 		// Note that this leaves a point at the upper left and lower right corners uninitialized. Not a big deal.
 	      }
-	    }	    
+	    }
 	  }
 	}
 
       }
-    }      
+    }
 
     ione = ione / 2 ; if ( ione < 1 ) ione = 1 ;
     jone = jone / 2 ; if ( jone < 1 ) jone = 1 ;
 
   }
-  
+
   //Differentiate V(r) and solve for E(r) using special equations for the first and last row
   //Integrate E(r)/E(z) from point of origin to pad plane
   AliSysInfo::AddStamp("CalcField", 100,0,0);
@@ -1578,26 +1506,26 @@ void AliTPCCorrection::PoissonRelaxation3D( TMatrixD**arrayofArrayV, TMatrixD**a
   for ( Int_t m = 0 ; m < phislices ; m++ ) {
     TMatrixD& arrayV    =  *arrayofArrayV[m] ;
     TMatrixD& eroverEz  =  *arrayofEroverEz[m] ;
-    
+
     for ( Int_t j = columns-1 ; j >= 0 ; j-- ) {  // Count backwards to facilitate integration over Z
-      
+
       // Differentiate in R
       for ( Int_t i = 1 ; i < rows-1 ; i++ )  arrayE(i,j) = -1 * ( arrayV(i+1,j) - arrayV(i-1,j) ) / (2*gridSizeR) ;
-      arrayE(0,j)      =  -1 * ( -0.5*arrayV(2,j) + 2.0*arrayV(1,j) - 1.5*arrayV(0,j) ) / gridSizeR ;  
-      arrayE(rows-1,j) =  -1 * ( 1.5*arrayV(rows-1,j) - 2.0*arrayV(rows-2,j) + 0.5*arrayV(rows-3,j) ) / gridSizeR ; 
+      arrayE(0,j)      =  -1 * ( -0.5*arrayV(2,j) + 2.0*arrayV(1,j) - 1.5*arrayV(0,j) ) / gridSizeR ;
+      arrayE(rows-1,j) =  -1 * ( 1.5*arrayV(rows-1,j) - 2.0*arrayV(rows-2,j) + 0.5*arrayV(rows-3,j) ) / gridSizeR ;
       // Integrate over Z
       for ( Int_t i = 0 ; i < rows ; i++ ) {
-	Int_t index = 1 ;   // Simpsons rule if N=odd.  If N!=odd then add extra point by trapezoidal rule.  
+	Int_t index = 1 ;   // Simpsons rule if N=odd.  If N!=odd then add extra point by trapezoidal rule.
 	eroverEz(i,j) = 0.0 ;
 	for ( Int_t k = j ; k < columns ; k++ ) {
-	  
+
 	  eroverEz(i,j)  +=  index*(gridSizeZ/3.0)*arrayE(i,k)/(-1*ezField) ;
 	  if ( index != 4 )  index = 4; else index = 2 ;
 	}
 	if ( index == 4 ) eroverEz(i,j)  -=  (gridSizeZ/3.0)*arrayE(i,columns-1)/ (-1*ezField) ;
-	if ( index == 2 ) eroverEz(i,j)  +=  
+	if ( index == 2 ) eroverEz(i,j)  +=
 	  (gridSizeZ/3.0)*(0.5*arrayE(i,columns-2)-2.5*arrayE(i,columns-1))/(-1*ezField) ;
-	if ( j == columns-2 ) eroverEz(i,j) =  
+	if ( j == columns-2 ) eroverEz(i,j) =
 	  (gridSizeZ/3.0)*(1.5*arrayE(i,columns-2)+1.5*arrayE(i,columns-1))/(-1*ezField) ;
 	if ( j == columns-1 ) eroverEz(i,j) =  0.0 ;
       }
@@ -1606,21 +1534,21 @@ void AliTPCCorrection::PoissonRelaxation3D( TMatrixD**arrayofArrayV, TMatrixD**a
     // eroverEz.Draw("surf") ; } // JT test
   }
   AliSysInfo::AddStamp("IntegrateEr", 120,0,0);
-  
-  //Differentiate V(r) and solve for E(phi) 
+
+  //Differentiate V(r) and solve for E(phi)
   //Integrate E(phi)/E(z) from point of origin to pad plane
 
   for ( Int_t m = 0 ; m < phislices ; m++ ) {
-    
-    mplus  = m + 1;   signplus  = 1 ; 
-    mminus = m - 1 ;  signminus = 1 ; 
+
+    mplus  = m + 1;   signplus  = 1 ;
+    mminus = m - 1 ;  signminus = 1 ;
     if (symmetry==1) { // Reflection symmetry in phi (e.g. symmetry at sector boundaries, or half sectors, etc.)
       if ( mplus  > phislices-1 ) mplus  = phislices - 2 ;
       if ( mminus < 0 )           mminus = 1 ;
     }
     else if (symmetry==-1) {       // Anti-symmetry in phi
       if ( mplus  > phislices-1 ) { mplus  = phislices - 2 ;  signplus  = -1 ; }
-      if ( mminus < 0 )           { mminus = 1 ;	            signminus = -1 ; } 
+      if ( mminus < 0 )           { mminus = 1 ;	            signminus = -1 ; }
     }
     else { // No Symmetries in phi, no boundaries, the calculations is continuous across all phi
       if ( mplus  > phislices-1 ) mplus  = m + 1 - phislices ;
@@ -1637,17 +1565,17 @@ void AliTPCCorrection::PoissonRelaxation3D( TMatrixD**arrayofArrayV, TMatrixD**a
       }
       // Integrate over Z
       for ( Int_t i = 0 ; i < rows ; i++ ) {
-	Int_t index = 1 ;   // Simpsons rule if N=odd.  If N!=odd then add extra point by trapezoidal rule.  
+	Int_t index = 1 ;   // Simpsons rule if N=odd.  If N!=odd then add extra point by trapezoidal rule.
 	ePhioverEz(i,j) = 0.0 ;
 	for ( Int_t k = j ; k < columns ; k++ ) {
-	  
+
 	  ePhioverEz(i,j)  +=  index*(gridSizeZ/3.0)*arrayE(i,k)/(-1*ezField) ;
 	  if ( index != 4 )  index = 4; else index = 2 ;
 	}
 	if ( index == 4 ) ePhioverEz(i,j)  -=  (gridSizeZ/3.0)*arrayE(i,columns-1)/ (-1*ezField) ;
-	if ( index == 2 ) ePhioverEz(i,j)  +=  
+	if ( index == 2 ) ePhioverEz(i,j)  +=
 	  (gridSizeZ/3.0)*(0.5*arrayE(i,columns-2)-2.5*arrayE(i,columns-1))/(-1*ezField) ;
-	if ( j == columns-2 ) ePhioverEz(i,j) =  
+	if ( j == columns-2 ) ePhioverEz(i,j) =
 	  (gridSizeZ/3.0)*(1.5*arrayE(i,columns-2)+1.5*arrayE(i,columns-1))/(-1*ezField) ;
 	if ( j == columns-1 ) ePhioverEz(i,j) =  0.0 ;
       }
@@ -1656,35 +1584,35 @@ void AliTPCCorrection::PoissonRelaxation3D( TMatrixD**arrayofArrayV, TMatrixD**a
     // arrayE.Draw("surf") ; } // JT test
   }
   AliSysInfo::AddStamp("IntegrateEphi", 130,0,0);
-  
+
 
   // Differentiate V(r) and solve for E(z) using special equations for the first and last row
   // Integrate (E(z)-Ezstd) from point of origin to pad plane
-  
+
   for ( Int_t m = 0 ; m < phislices ; m++ ) {
     TMatrixD& arrayV   =  *arrayofArrayV[m] ;
     TMatrixD& deltaEz  =  *arrayofDeltaEz[m] ;
-    
+
     // Differentiate V(z) and solve for E(z) using special equations for the first and last columns
     for ( Int_t i = 0 ; i < rows ; i++) {
       for ( Int_t j = 1 ; j < columns-1 ; j++ ) arrayE(i,j) = -1 * ( arrayV(i,j+1) - arrayV(i,j-1) ) / (2*gridSizeZ) ;
-      arrayE(i,0)         =  -1 * ( -0.5*arrayV(i,2) + 2.0*arrayV(i,1) - 1.5*arrayV(i,0) ) / gridSizeZ ;  
-      arrayE(i,columns-1) =  -1 * ( 1.5*arrayV(i,columns-1) - 2.0*arrayV(i,columns-2) + 0.5*arrayV(i,columns-3) ) / gridSizeZ ; 
+      arrayE(i,0)         =  -1 * ( -0.5*arrayV(i,2) + 2.0*arrayV(i,1) - 1.5*arrayV(i,0) ) / gridSizeZ ;
+      arrayE(i,columns-1) =  -1 * ( 1.5*arrayV(i,columns-1) - 2.0*arrayV(i,columns-2) + 0.5*arrayV(i,columns-3) ) / gridSizeZ ;
     }
-    
+
     for ( Int_t j = columns-1 ; j >= 0 ; j-- ) {  // Count backwards to facilitate integration over Z
       // Integrate over Z
       for ( Int_t i = 0 ; i < rows ; i++ ) {
-	Int_t index = 1 ;   // Simpsons rule if N=odd.  If N!=odd then add extra point by trapezoidal rule.  
+	Int_t index = 1 ;   // Simpsons rule if N=odd.  If N!=odd then add extra point by trapezoidal rule.
 	deltaEz(i,j) = 0.0 ;
 	for ( Int_t k = j ; k < columns ; k++ ) {
 	  deltaEz(i,j)  +=  index*(gridSizeZ/3.0)*arrayE(i,k) ;
 	  if ( index != 4 )  index = 4; else index = 2 ;
 	}
 	if ( index == 4 ) deltaEz(i,j)  -=  (gridSizeZ/3.0)*arrayE(i,columns-1) ;
-	if ( index == 2 ) deltaEz(i,j)  +=  
+	if ( index == 2 ) deltaEz(i,j)  +=
 	  (gridSizeZ/3.0)*(0.5*arrayE(i,columns-2)-2.5*arrayE(i,columns-1)) ;
-	if ( j == columns-2 ) deltaEz(i,j) =  
+	if ( j == columns-2 ) deltaEz(i,j) =
 	  (gridSizeZ/3.0)*(1.5*arrayE(i,columns-2)+1.5*arrayE(i,columns-1)) ;
 	if ( j == columns-1 ) deltaEz(i,j) =  0.0 ;
       }
@@ -1692,32 +1620,32 @@ void AliTPCCorrection::PoissonRelaxation3D( TMatrixD**arrayofArrayV, TMatrixD**a
 
     // if ( m == 0 ) { TCanvas*  c1 =  new TCanvas("erOverEz","erOverEz",50,50,840,600) ;  c1 -> cd() ;
     // eroverEz.Draw("surf") ; } // JT test
-    
+
     // calculate z distortion from the integrated Delta Ez residuals
     // and include the aquivalence (Volt to cm) of the ROC shift !!
-    
-    for ( Int_t j = 0 ; j < columns ; j++ )  {	  
+
+    for ( Int_t j = 0 ; j < columns ; j++ )  {
       for ( Int_t i = 0 ; i < rows ; i++ ) {
-	
+
 	// Scale the Ez distortions with the drift velocity pertubation -> delivers cm
 	deltaEz(i,j) = deltaEz(i,j)*fgkdvdE;
-	
+
 	// ROC Potential in cm aquivalent
-	Double_t dzROCShift =  arrayV(i, columns -1)/ezField;  
+	Double_t dzROCShift =  arrayV(i, columns -1)/ezField;
 	if ( rocDisplacement ) deltaEz(i,j) = deltaEz(i,j) + dzROCShift;  // add the ROC misaligment
-	
+
       }
     }
 
-  } // end loop over phi  
+  } // end loop over phi
   AliSysInfo::AddStamp("IntegrateEz", 140,0,0);
- 
+
 
   for ( Int_t k = 0 ; k < phislices ; k++ )
     {
       arrayofSumChargeDensities[k]->Delete() ;
     }
-  
+
 
 
   arrayE.Clear();
@@ -1725,9 +1653,8 @@ void AliTPCCorrection::PoissonRelaxation3D( TMatrixD**arrayofArrayV, TMatrixD**a
 
 
 Int_t AliTPCCorrection::IsPowerOfTwo(Int_t i) const {
-  //
-  // Helperfunction: Check if integer is a power of 2
-  //
+  /// Helperfunction: Check if integer is a power of 2
+
   Int_t j = 0;
   while( i > 0 ) { j += (i&1) ; i = (i>>1) ; }
   if ( j == 1 ) return(1) ;  // True
@@ -1736,42 +1663,41 @@ Int_t AliTPCCorrection::IsPowerOfTwo(Int_t i) const {
 
 
 AliExternalTrackParam * AliTPCCorrection::FitDistortedTrack(AliExternalTrackParam & trackIn, Double_t refX, Int_t dir, TTreeSRedirector * const pcstream){
-  //
-  // Fit the track parameters - without and with distortion
-  // 1. Space points in the TPC are simulated along the trajectory  
-  // 2. Space points distorted
-  // 3. Fits  the non distorted and distroted track to the reference plane at refX
-  // 4. For visualization and debugging  purposes the space points and tracks can be stored  in the tree - using the TTreeSRedirector functionality 
-  //
-  // trackIn   - input track parameters
-  // refX     - reference X to fit the track
-  // dir      - direction - out=1 or in=-1
-  // pcstream -  debug streamer to check the results
-  //
-  // see AliExternalTrackParam.h documentation:
-  // track1.fP[0] - local y (rphi)
-  // track1.fP[1] - z 
-  // track1.fP[2] - sinus of local inclination angle
-  // track1.fP[3] - tangent of deep angle
-  // track1.fP[4] - 1/pt
+  /// Fit the track parameters - without and with distortion
+  /// 1. Space points in the TPC are simulated along the trajectory
+  /// 2. Space points distorted
+  /// 3. Fits  the non distorted and distroted track to the reference plane at refX
+  /// 4. For visualization and debugging  purposes the space points and tracks can be stored  in the tree - using the TTreeSRedirector functionality
+  ///
+  /// trackIn   - input track parameters
+  /// refX     - reference X to fit the track
+  /// dir      - direction - out=1 or in=-1
+  /// pcstream -  debug streamer to check the results
+  ///
+  /// see AliExternalTrackParam.h documentation:
+  /// track1.fP[0] - local y (rphi)
+  /// track1.fP[1] - z
+  /// track1.fP[2] - sinus of local inclination angle
+  /// track1.fP[3] - tangent of deep angle
+  /// track1.fP[4] - 1/pt
 
   AliTPCROC * roc = AliTPCROC::Instance();
   const Int_t    npoints0=roc->GetNRows(0)+roc->GetNRows(36);
   const Double_t kRTPC0  =roc->GetPadRowRadii(0,0);
   const Double_t kRTPC1  =roc->GetPadRowRadii(36,roc->GetNRows(36)-1);
-  const Double_t kMaxSnp = 0.85;  
+  const Double_t kMaxSnp = 0.85;
   const Double_t kSigmaY=0.1;
   const Double_t kSigmaZ=0.1;
   const Double_t kMaxR=500;
   const Double_t kMaxZ=500;
-  
+
   const Double_t kMaxZ0=220;
   const Double_t kZcut=3;
   const Double_t kMass = TDatabasePDG::Instance()->GetParticle("pi+")->Mass();
   Int_t npoints1=0;
   Int_t npoints2=0;
 
-  AliExternalTrackParam  track(trackIn); // 
+  AliExternalTrackParam  track(trackIn); //
   // generate points
   AliTrackPointArray pointArray0(npoints0);
   AliTrackPointArray pointArray1(npoints0);
@@ -1790,7 +1716,7 @@ AliExternalTrackParam * AliTPCCorrection::FitDistortedTrack(AliExternalTrackPara
     if (TMath::Abs(track.GetZ())>kMaxZ0) continue;
     if (TMath::Abs(track.GetX())<kRTPC0) continue;
     if (TMath::Abs(track.GetX())>kRTPC1) continue;
-    AliTrackPoint pIn0;                               // space point          
+    AliTrackPoint pIn0;                               // space point
     AliTrackPoint pIn1;
     Int_t sector= (xyz[2]>0)? 0:18;
     pointArray0.GetPoint(pIn0,npoints);
@@ -1808,7 +1734,7 @@ AliExternalTrackParam * AliTPCCorrection::FitDistortedTrack(AliExternalTrackPara
     prot1.SetXYZ(prot1.GetX(),prot1.GetY(), prot1.GetZ(),covPoint);
     pIn0=prot0.Rotate(-alpha);                       // rotate back to global frame
     pIn1=prot1.Rotate(-alpha);                       // rotate back to global frame
-    pointArray0.AddPoint(npoints, &pIn0);      
+    pointArray0.AddPoint(npoints, &pIn0);
     pointArray1.AddPoint(npoints, &pIn1);
     npoints++;
     if (npoints>=npoints0) break;
@@ -1829,7 +1755,7 @@ AliExternalTrackParam * AliTPCCorrection::FitDistortedTrack(AliExternalTrackPara
     pointArray0.GetPoint(point1,npoints-21);
     pointArray0.GetPoint(point2,npoints-11);
     pointArray0.GetPoint(point3,npoints-1);
-  } 
+  }
   if ((TMath::Abs(point1.GetX()-point3.GetX())+TMath::Abs(point1.GetY()-point3.GetY()))<10){
     printf("fit points not properly initialized\n");
     return 0;
@@ -1839,7 +1765,7 @@ AliExternalTrackParam * AliTPCCorrection::FitDistortedTrack(AliExternalTrackPara
   track0->ResetCovariance(10);
   track1->ResetCovariance(10);
   if (TMath::Abs(AliTrackerBase::GetBz())<0.01){
-    ((Double_t*)track0->GetParameter())[4]=  trackIn.GetParameter()[4];    
+    ((Double_t*)track0->GetParameter())[4]=  trackIn.GetParameter()[4];
     ((Double_t*)track1->GetParameter())[4]=  trackIn.GetParameter()[4];
   }
   for (Int_t jpoint=0; jpoint<npoints; jpoint++){
@@ -1874,7 +1800,7 @@ AliExternalTrackParam * AliTPCCorrection::FitDistortedTrack(AliExternalTrackPara
     pointCov[2]=prot0.GetCov()[5];//sigmaz^2
     if (!track0->Update(pointPos,pointCov)) break;
     //
-    Double_t deltaX=prot1.GetX()-prot0.GetX();   // delta X 
+    Double_t deltaX=prot1.GetX()-prot0.GetX();   // delta X
     Double_t deltaYX=deltaX*TMath::Tan(TMath::ASin(track1->GetSnp()));  // deltaY due  delta X
     Double_t deltaZX=deltaX*track1->GetTgl();                           // deltaZ due  delta X
 
@@ -1910,18 +1836,17 @@ AliExternalTrackParam * AliTPCCorrection::FitDistortedTrack(AliExternalTrackPara
 
 
 TTree* AliTPCCorrection::CreateDistortionTree(Double_t step){
-  //
-  // create the distortion tree on a mesh with granularity given by step
-  // return the tree with distortions at given position 
-  // Map is created on the mesh with given step size
-  //
+  /// create the distortion tree on a mesh with granularity given by step
+  /// return the tree with distortions at given position
+  /// Map is created on the mesh with given step size
+
   TTreeSRedirector *pcstream = new TTreeSRedirector(Form("correction%s.root",GetName()));
   Float_t xyz[3];
   for (Double_t x= -250; x<250; x+=step){
     for (Double_t y= -250; y<250; y+=step){
       Double_t r    = TMath::Sqrt(x*x+y*y);
       if (r<80) continue;
-      if (r>250) continue;      
+      if (r>250) continue;
       for (Double_t z= -250; z<250; z+=step){
 	Int_t roc=(z>0)?0:18;
 	xyz[0]=x;
@@ -1939,11 +1864,11 @@ TTree* AliTPCCorrection::CreateDistortionTree(Double_t step){
 	Double_t dr=r1-r;
 	Double_t drphi=(phi1-phi)*r;
 	(*pcstream)<<"distortion"<<
-	  "x="<<x<<           // original position        
+	  "x="<<x<<           // original position
 	  "y="<<y<<
 	  "z="<<z<<
 	  "r="<<r<<
-	  "phi="<<phi<<	  
+	  "phi="<<phi<<
 	  "x1="<<xyz[0]<<      // distorted position
 	  "y1="<<xyz[1]<<
 	  "z1="<<xyz[2]<<
@@ -1957,7 +1882,7 @@ TTree* AliTPCCorrection::CreateDistortionTree(Double_t step){
 	  "drphi="<<drphi<<
 	  "\n";
       }
-    }	
+    }
   }
   delete pcstream;
   TFile f(Form("correction%s.root",GetName()));
@@ -1973,34 +1898,32 @@ TTree* AliTPCCorrection::CreateDistortionTree(Double_t step){
 
 
 void AliTPCCorrection::MakeTrackDistortionTree(TTree *tinput, Int_t dtype, Int_t ptype, const TObjArray * corrArray, Int_t step, Int_t offset, Bool_t debug ){
-  //
-  // Make a fit tree:
-  // For each partial correction (specified in array) and given track topology (phi, theta, snp, refX)
-  // calculates partial distortions
-  // Partial distortion is stored in the resulting tree
-  // Output is storred in the file distortion_<dettype>_<partype>.root
-  // Partial  distortion is stored with the name given by correction name
-  //
-  //
-  // Parameters of function:
-  // input     - input tree
-  // dtype     - distortion type 0 - ITSTPC,  1 -TPCTRD, 2 - TPCvertex , 3 - TPC-TOF,  4 - TPCTPC track crossing 
-  // ppype     - parameter type
-  // corrArray - array with partial corrections
-  // step      - skipe entries  - if 1 all entries processed - it is slow
-  // debug     0 if debug on also space points dumped - it is slow
-
-  const Double_t kMaxSnp = 0.85;  
+  /// Make a fit tree:
+  /// For each partial correction (specified in array) and given track topology (phi, theta, snp, refX)
+  /// calculates partial distortions
+  /// Partial distortion is stored in the resulting tree
+  /// Output is storred in the file distortion_<dettype>_<partype>.root
+  /// Partial  distortion is stored with the name given by correction name
+  ///
+  /// Parameters of function:
+  /// input     - input tree
+  /// dtype     - distortion type 0 - ITSTPC,  1 -TPCTRD, 2 - TPCvertex , 3 - TPC-TOF,  4 - TPCTPC track crossing
+  /// ppype     - parameter type
+  /// corrArray - array with partial corrections
+  /// step      - skipe entries  - if 1 all entries processed - it is slow
+  /// debug     0 if debug on also space points dumped - it is slow
+
+  const Double_t kMaxSnp = 0.85;
   const Double_t kcutSnp=0.25;
   const Double_t kcutTheta=1.;
   const Double_t kRadiusTPC=85;
-  //  AliTPCROC *tpcRoc =AliTPCROC::Instance();  
+  //  AliTPCROC *tpcRoc =AliTPCROC::Instance();
   //
   const Double_t kMass = TDatabasePDG::Instance()->GetParticle("pi+")->Mass();
   //  const Double_t kB2C=-0.299792458e-3;
-  const Int_t kMinEntries=20; 
+  const Int_t kMinEntries=20;
   Double_t phi,theta, snp, mean,rms, entries,sector,dsec;
-  Float_t refX;  
+  Float_t refX;
   Int_t run;
   tinput->SetBranchAddress("run",&run);
   tinput->SetBranchAddress("theta",&theta);
@@ -2048,7 +1971,7 @@ void AliTPCCorrection::MakeTrackDistortionTree(TTree *tinput, Int_t dtype, Int_t
     Double_t bz=AliTrackerBase::GetBz();
     if (dtype !=4) { //exclude TPC  - for TPC mainly non primary tracks
       if (dtype!=2 && TMath::Abs(bz)>0.1 )  tPar[4]=snp/(refX*bz*kB2C*2);
-      
+
       if (dtype==2 && TMath::Abs(bz)>0.1 )  {
 	tPar[4]=snp/(kRadiusTPC*bz*kB2C*2);//
 	// snp at the TPC inner radius in case the vertex match used
@@ -2070,7 +1993,7 @@ void AliTPCCorrection::MakeTrackDistortionTree(TTree *tinput, Int_t dtype, Int_t
       "dtype="<<dtype<<   // detector match type
       "ptype="<<ptype<<   // parameter type
       "theta="<<theta<<   // theta
-      "phi="<<phi<<       // phi 
+      "phi="<<phi<<       // phi
       "snp="<<snp<<       // snp
       "mean="<<mean<<     // mean dist value
       "rms="<<rms<<       // rms
@@ -2079,7 +2002,7 @@ void AliTPCCorrection::MakeTrackDistortionTree(TTree *tinput, Int_t dtype, Int_t
       "refX="<<refXD<<         // referece X as double
       "gx="<<xyz[0]<<         // global position at reference
       "gy="<<xyz[1]<<         // global position at reference
-      "gz="<<xyz[2]<<         // global position at reference	
+      "gz="<<xyz[2]<<         // global position at reference
       "dRrec="<<dRrec<<      // delta Radius in reconstruction
       "pt="<<pt<<            // pt
       "id="<<id<<             // track id
@@ -2106,19 +2029,19 @@ void AliTPCCorrection::MakeTrackDistortionTree(TTree *tinput, Int_t dtype, Int_t
 	  if (!trackOut->Rotate(trackIn.GetAlpha())) isOK=kFALSE;
 	  if (!AliTrackerBase::PropagateTrackTo(trackOut,trackIn.GetX(),kMass,5,kFALSE,kMaxSnp)) isOK=kFALSE;
 	  //	  trackOut->PropagateTo(trackIn.GetX(),AliTrackerBase::GetBz());
-	  //	  
+	  //
 	  corrections[icorr]= trackOut->GetParameter()[ptype]-trackIn.GetParameter()[ptype];
-	  delete trackOut;      
+	  delete trackOut;
 	}else{
 	  corrections[icorr]=0;
 	  isOK=kFALSE;
 	}
 	//if (ptype==4 &&bz<0) corrections[icorr]*=-1;  // interpret as curvature - commented out
-      }      
+      }
       (*pcstream)<<"fit"<<
 	Form("%s=",corr->GetName())<<corrections[icorr];   // dump correction value
     }
-  
+
     if (dtype==4) for (Int_t icorr=0; icorr<ncorr; icorr++) {
       //
       // special case of the TPC tracks crossing the CE
@@ -2127,7 +2050,7 @@ void AliTPCCorrection::MakeTrackDistortionTree(TTree *tinput, Int_t dtype, Int_t
       corrections[icorr]=0;
       if (entries>kMinEntries){
 	AliExternalTrackParam trackIn0(refX,phi,tPar,cov); //Outer - direction to vertex
-	AliExternalTrackParam trackIn1(refX,phi,tPar,cov); //Inner - direction magnet 
+	AliExternalTrackParam trackIn1(refX,phi,tPar,cov); //Inner - direction magnet
 	AliExternalTrackParam *trackOut0 = 0;
 	AliExternalTrackParam *trackOut1 = 0;
 	//
@@ -2145,7 +2068,7 @@ void AliTPCCorrection::MakeTrackDistortionTree(TTree *tinput, Int_t dtype, Int_t
 	  if (!AliTrackerBase::PropagateTrackTo(&trackIn1,refX,kMass,5,kTRUE,kMaxSnp)) isOK=kFALSE;
 	  if (!trackIn1.Rotate(trackIn0.GetAlpha()))  isOK=kFALSE;
 	  if (!AliTrackerBase::PropagateTrackTo(&trackIn1,trackIn0.GetX(),kMass,1,kFALSE,kMaxSnp)) isOK=kFALSE;
-	  if (!trackOut1->Rotate(trackIn1.GetAlpha())) isOK=kFALSE;	  
+	  if (!trackOut1->Rotate(trackIn1.GetAlpha())) isOK=kFALSE;
 	  if (!AliTrackerBase::PropagateTrackTo(trackOut1,trackIn1.GetX(),kMass,5,kFALSE,kMaxSnp)) isOK=kFALSE;
 	  //
 	  corrections[icorr] = (trackOut0->GetParameter()[ptype]-trackIn0.GetParameter()[ptype]);
@@ -2159,16 +2082,16 @@ void AliTPCCorrection::MakeTrackDistortionTree(TTree *tinput, Int_t dtype, Int_t
 		(TMath::Abs(trackIn0.GetSnp()-trackIn1.GetSnp())>0.0001)
 		){
 	      isOK=kFALSE;
-	    }	  	  
-	  delete trackOut0;      
-	  delete trackOut1;    	  
+	    }
+	  delete trackOut0;
+	  delete trackOut1;
 	}else{
 	  corrections[icorr]=0;
 	  isOK=kFALSE;
 	}
 	//
 	//if (ptype==4 &&bz<0) corrections[icorr]*=-1;  // interpret as curvature - commented out no in lookup
-      }      
+      }
       (*pcstream)<<"fit"<<
 	Form("%s=",corr->GetName())<<corrections[icorr];   // dump correction value
     }
@@ -2183,26 +2106,24 @@ void AliTPCCorrection::MakeTrackDistortionTree(TTree *tinput, Int_t dtype, Int_t
 
 
 void AliTPCCorrection::MakeSectorDistortionTree(TTree *tinput, Int_t dtype, Int_t ptype, const TObjArray * corrArray, Int_t step, Int_t offset, Bool_t debug ){
-  //
-  // Make a fit tree:
-  // For each partial correction (specified in array) and given track topology (phi, theta, snp, refX)
-  // calculates partial distortions
-  // Partial distortion is stored in the resulting tree
-  // Output is storred in the file distortion_<dettype>_<partype>.root
-  // Partial  distortion is stored with the name given by correction name
-  //
-  //
-  // Parameters of function:
-  // input     - input tree
-  // dtype     - distortion type 10 - IROC-OROC 
-  // ppype     - parameter type
-  // corrArray - array with partial corrections
-  // step      - skipe entries  - if 1 all entries processed - it is slow
-  // debug     0 if debug on also space points dumped - it is slow
-
-  const Double_t kMaxSnp = 0.8;  
-  const Int_t kMinEntries=200; 
-  //  AliTPCROC *tpcRoc =AliTPCROC::Instance();  
+  /// Make a fit tree:
+  /// For each partial correction (specified in array) and given track topology (phi, theta, snp, refX)
+  /// calculates partial distortions
+  /// Partial distortion is stored in the resulting tree
+  /// Output is storred in the file distortion_<dettype>_<partype>.root
+  /// Partial  distortion is stored with the name given by correction name
+  ///
+  /// Parameters of function:
+  /// input     - input tree
+  /// dtype     - distortion type 10 - IROC-OROC
+  /// ppype     - parameter type
+  /// corrArray - array with partial corrections
+  /// step      - skipe entries  - if 1 all entries processed - it is slow
+  /// debug     0 if debug on also space points dumped - it is slow
+
+  const Double_t kMaxSnp = 0.8;
+  const Int_t kMinEntries=200;
+  //  AliTPCROC *tpcRoc =AliTPCROC::Instance();
   //
   const Double_t kMass = TDatabasePDG::Instance()->GetParticle("pi+")->Mass();
   //  const Double_t kB2C=-0.299792458e-3;
@@ -2251,11 +2172,11 @@ void AliTPCCorrection::MakeSectorDistortionTree(TTree *tinput, Int_t dtype, Int_
     //
     printf("%f\t%f\t%f\t%f\t%f\t%f\n",entries, sector,theta,snp, mean,rms);
     Double_t bz=AliTrackerBase::GetBz();
-    AliExternalTrackParam track(refX,phi,tPar,cov);    
+    AliExternalTrackParam track(refX,phi,tPar,cov);
     Double_t xyz[3],xyzIn[3],xyzOut[3];
     track.GetXYZ(xyz);
-    track.GetXYZAt(85,bz,xyzIn);    
-    track.GetXYZAt(245,bz,xyzOut);    
+    track.GetXYZAt(85,bz,xyzIn);
+    track.GetXYZAt(245,bz,xyzOut);
     Double_t phiIn  = TMath::ATan2(xyzIn[1],xyzIn[0]);
     Double_t phiOut = TMath::ATan2(xyzOut[1],xyzOut[0]);
     Double_t phiRef = TMath::ATan2(xyz[1],xyz[0]);
@@ -2263,7 +2184,7 @@ void AliTPCCorrection::MakeSectorDistortionTree(TTree *tinput, Int_t dtype, Int_
     Int_t sectorIn  = TMath::Nint(9.*phiIn/TMath::Pi()-0.5);
     Int_t sectorOut = TMath::Nint(9.*phiOut/TMath::Pi()-0.5);
     //
-    Bool_t isOK=kTRUE; 
+    Bool_t isOK=kTRUE;
     if (sectorIn!=sectorOut) isOK=kFALSE;  // requironment - cluster in the same sector
     if (sectorIn!=sectorRef) isOK=kFALSE;  // requironment - cluster in the same sector
     if (entries<kMinEntries/(1+TMath::Abs(globalZ/100.))) isOK=kFALSE;  // requironment - minimal amount of tracks in bin
@@ -2278,7 +2199,7 @@ void AliTPCCorrection::MakeSectorDistortionTree(TTree *tinput, Int_t dtype, Int_
       "dtype="<<dtype<<   // detector match type
       "ptype="<<ptype<<   // parameter type
       "theta="<<theta<<   // theta
-      "phi="<<phi<<       // phi 
+      "phi="<<phi<<       // phi
       "snp="<<snp<<       // snp
       "mean="<<mean<<     // mean dist value
       "rms="<<rms<<       // rms
@@ -2287,7 +2208,7 @@ void AliTPCCorrection::MakeSectorDistortionTree(TTree *tinput, Int_t dtype, Int_
       "refX="<<refXD<<         // referece X
       "gx="<<xyz[0]<<         // global position at reference
       "gy="<<xyz[1]<<         // global position at reference
-      "gz="<<xyz[2]<<         // global position at reference	
+      "gz="<<xyz[2]<<         // global position at reference
       "dRrec="<<dRrec<<      // delta Radius in reconstruction
       "pt="<<pt<<      //pt
       "id="<<id<<             // track id
@@ -2322,7 +2243,7 @@ void AliTPCCorrection::MakeSectorDistortionTree(TTree *tinput, Int_t dtype, Int_
 	  // rotate all tracks to the same frame
 	  if (!trackOut0->Rotate(trackIn0.GetAlpha())) isOK=kFALSE;
 	  if (!trackIn1.Rotate(trackIn0.GetAlpha()))  isOK=kFALSE;
-	  if (!trackOut1->Rotate(trackIn0.GetAlpha())) isOK=kFALSE;	  
+	  if (!trackOut1->Rotate(trackIn0.GetAlpha())) isOK=kFALSE;
 	  //
 	  if (!AliTrackerBase::PropagateTrackTo(trackOut0,refX,kMass,1,kFALSE,kMaxSnp)) isOK=kFALSE;
 	  if (!AliTrackerBase::PropagateTrackTo(&trackIn1,refX,kMass,1,kFALSE,kMaxSnp)) isOK=kFALSE;
@@ -2338,13 +2259,13 @@ void AliTPCCorrection::MakeSectorDistortionTree(TTree *tinput, Int_t dtype, Int_
 	    "pOut1.="<<trackOut1<<
 	    "refX="<<refXD<<
 	    "\n";
-	  delete trackOut0;      
-	  delete trackOut1;      
+	  delete trackOut0;
+	  delete trackOut1;
 	}else{
 	  corrections[icorr]=0;
 	  isOK=kFALSE;
 	}
-      }      
+      }
       (*pcstream)<<"fit"<<
 	Form("%s=",corr->GetName())<<corrections[icorr];   // dump correction value
     }
@@ -2357,9 +2278,8 @@ void AliTPCCorrection::MakeSectorDistortionTree(TTree *tinput, Int_t dtype, Int_
 
 
 void AliTPCCorrection::MakeLaserDistortionTreeOld(TTree* tree, TObjArray *corrArray, Int_t itype){
-  //
-  // Make a laser fit tree for global minimization
-  //
+  /// Make a laser fit tree for global minimization
+
   const Double_t cutErrY=0.1;
   const Double_t cutErrZ=0.1;
   const Double_t kEpsilon=0.00000001;
@@ -2379,7 +2299,7 @@ void AliTPCCorrection::MakeLaserDistortionTreeOld(TTree* tree, TObjArray *corrAr
   Int_t entries= tree->GetEntries();
   TTreeSRedirector *pcstream= new TTreeSRedirector("distortionLaser_0.root");
   Double_t bz=AliTrackerBase::GetBz();
-  // 
+  //
 
   for (Int_t ientry=0; ientry<entries; ientry++){
     tree->GetEntry(ientry);
@@ -2415,7 +2335,7 @@ void AliTPCCorrection::MakeLaserDistortionTreeOld(TTree* tree, TObjArray *corrAr
 	    array[counter]=(*delta)[jrow];
 	    counter++;
 	  }
-	}    
+	}
 	Double_t rms3  = 0;
 	Double_t mean3 = 0;
 	if (counter>2){
@@ -2437,12 +2357,12 @@ void AliTPCCorrection::MakeLaserDistortionTreeOld(TTree* tree, TObjArray *corrAr
 	gz = (*ltr->GetVecGZ())[irow];
 	//
 	// get delta R used in reconstruction
-	AliTPCcalibDB*  calib=AliTPCcalibDB::Instance();  
+	AliTPCcalibDB*  calib=AliTPCcalibDB::Instance();
 	AliTPCCorrection * correction = calib->GetTPCComposedCorrection(AliTrackerBase::GetBz());
 	//      const AliTPCRecoParam * recoParam = calib->GetTransform()->GetCurrentRecoParam();
 	//Double_t xyz0[3]={gx,gy,gz};
 	Double_t oldR=TMath::Sqrt(gx*gx+gy*gy);
-	Double_t fphi = TMath::ATan2(gy,gx);      
+	Double_t fphi = TMath::ATan2(gy,gx);
 	Double_t fsector = 9.*fphi/TMath::Pi();
 	if (fsector<0) fsector+=18;
 	Double_t dsec = fsector-Int_t(fsector)-0.5;
@@ -2456,11 +2376,11 @@ void AliTPCCorrection::MakeLaserDistortionTreeOld(TTree* tree, TObjArray *corrAr
 	  correction->CorrectPoint(xyz1, sector);
 	  refX=TMath::Sqrt(xyz1[0]*xyz1[0]+xyz1[1]*xyz1[1]);
 	  dRrec=oldR-refX;
-	} 
+	}
 	if (TMath::Abs(rms3)>kMaxRMS) isOK=kFALSE;
 	if (TMath::Abs(mean-mean3)>kMaxRMS) isOK=kFALSE;
-	if (counter<4) isOK=kFALSE;	
-	if (npoints<90) isOK=kFALSE;	
+	if (counter<4) isOK=kFALSE;
+	if (npoints<90) isOK=kFALSE;
 	if (isOK){
 	  fitter.AddPoint(&refX,mean);
 	}
@@ -2471,7 +2391,7 @@ void AliTPCCorrection::MakeLaserDistortionTreeOld(TTree* tree, TObjArray *corrAr
 	    "dtype="<<dtype<<   // detector match type
 	    "ptype="<<itype<<   // parameter type
 	    "theta="<<theta<<   // theta
-	    "phi="<<phi<<       // phi 
+	    "phi="<<phi<<       // phi
 	    "snp="<<snp<<       // snp
 	    "mean="<<mean3<<     // mean dist value
 	    "rms="<<rms3<<       // rms
@@ -2488,7 +2408,7 @@ void AliTPCCorrection::MakeLaserDistortionTreeOld(TTree* tree, TObjArray *corrAr
 	    "gy="<<gy<<         // global position
 	    "gz="<<gz<<         // global position
 	    "dRrec="<<dRrec<<      // delta Radius in reconstruction
-	    "id="<<id<<     //bundle	
+	    "id="<<id<<     //bundle
 	    "entries="<<nentries<<// number of entries in bin
 	    "\n";
 	}
@@ -2497,7 +2417,7 @@ void AliTPCCorrection::MakeLaserDistortionTreeOld(TTree* tree, TObjArray *corrAr
 	  "dtype="<<dtype<<   // detector match type
 	  "ptype="<<itype<<   // parameter type
 	  "theta="<<theta<<   // theta
-	  "phi="<<phi<<       // phi 
+	  "phi="<<phi<<       // phi
 	  "snp="<<snp<<       // snp
 	  "mean="<<mean3<<     // mean dist value
 	  "rms="<<rms3<<       // rms
@@ -2510,10 +2430,10 @@ void AliTPCCorrection::MakeLaserDistortionTreeOld(TTree* tree, TObjArray *corrAr
 	  "gz="<<gz<<         // global position
 	  "dRrec="<<dRrec<<      // delta Radius in reconstruction
 	  "pt="<<pt<<           //pt
-	  "id="<<id<<     //bundle	
+	  "id="<<id<<     //bundle
 	  "entries="<<nentries;// number of entries in bin
 	//
-	//    
+	//
 	Double_t ky = TMath::Tan(TMath::ASin(snp));
 	Int_t ncorr = corrArray->GetEntries();
 	Double_t r0   = TMath::Sqrt(gx*gx+gy*gy);
@@ -2523,7 +2443,7 @@ void AliTPCCorrection::MakeLaserDistortionTreeOld(TTree* tree, TObjArray *corrAr
 	if (iter==1){
 	  for (Int_t icorr=0; icorr<ncorr; icorr++) {
 	    AliTPCCorrection *corr = (AliTPCCorrection*)corrArray->At(icorr);
-	    Float_t distPoint[3]={static_cast<Float_t>(gx),static_cast<Float_t>(gy),static_cast<Float_t>(gz)}; 
+	    Float_t distPoint[3]={static_cast<Float_t>(gx),static_cast<Float_t>(gy),static_cast<Float_t>(gz)};
 	    Int_t sector= (gz>0)? 0:18;
 	    if (r0>80){
 	      corr->DistortPoint(distPoint, sector);
@@ -2553,20 +2473,19 @@ void AliTPCCorrection::MakeLaserDistortionTreeOld(TTree* tree, TObjArray *corrAr
 
 
 void   AliTPCCorrection::MakeDistortionMap(THnSparse * his0, TTreeSRedirector * const pcstream, const char* hname, Int_t run, Float_t refX, Int_t type, Int_t integ){
-  //
-  // make a distortion map out ou fthe residual histogram
-  // Results are written to the debug streamer - pcstream
-  // Parameters:
-  //   his0       - input (4D) residual histogram
-  //   pcstream   - file to write the tree
-  //   run        - run number
-  //   refX       - track matching reference X
-  //   type       - 0- y 1-z,2 -snp, 3-theta, 4=1/pt
-  // THnSparse axes:
-  // OBJ: TAxis     #Delta  #Delta
-  // OBJ: TAxis     tanTheta        tan(#Theta)
-  // OBJ: TAxis     phi     #phi
-  // OBJ: TAxis     snp     snp
+  /// make a distortion map out ou fthe residual histogram
+  /// Results are written to the debug streamer - pcstream
+  /// Parameters:
+  ///   his0       - input (4D) residual histogram
+  ///   pcstream   - file to write the tree
+  ///   run        - run number
+  ///   refX       - track matching reference X
+  ///   type       - 0- y 1-z,2 -snp, 3-theta, 4=1/pt
+  /// THnSparse axes:
+  /// OBJ: TAxis     #Delta  #Delta
+  /// OBJ: TAxis     tanTheta        tan(#Theta)
+  /// OBJ: TAxis     phi     #phi
+  /// OBJ: TAxis     snp     snp
 
   // marian.ivanov@cern.ch
   const Int_t kMinEntries=10;
@@ -2611,8 +2530,8 @@ void   AliTPCCorrection::MakeDistortionMap(THnSparse * his0, TTreeSRedirector *
 	Double_t entries = hisDelta->GetEntries();
 	Double_t mean=0, rms=0;
 	if (entries>kMinEntries){
-	  mean    = hisDelta->GetMean(); 
-	  rms = hisDelta->GetRMS(); 
+	  mean    = hisDelta->GetMean();
+	  rms = hisDelta->GetRMS();
 	}
 	Double_t sector = 9.*x2/TMath::Pi();
 	if (sector<0) sector+=18;
@@ -2646,28 +2565,28 @@ void   AliTPCCorrection::MakeDistortionMap(THnSparse * his0, TTreeSRedirector *
 
 
 void   AliTPCCorrection::MakeDistortionMapCosmic(THnSparse * hisInput, TTreeSRedirector * const pcstream, const char* hname, Int_t run, Float_t refX, Int_t type){
-  //
-  // make a distortion map out ou fthe residual histogram
-  // Results are written to the debug streamer - pcstream
-  // Parameters:
-  //   his0       - input (4D) residual histogram
-  //   pcstream   - file to write the tree
-  //   run        - run number
-  //   refX       - track matching reference X
-  //   type       - 0- y 1-z,2 -snp, 3-theta, 4=1/pt
-  // marian.ivanov@cern.ch
-  //
-  //  Histo axeses
-  //   Collection name='TObjArray', class='TObjArray', size=16
-  //  0. OBJ: TAxis     #Delta  #Delta
-  //  1. OBJ: TAxis     N_{cl}  N_{cl}
-  //  2. OBJ: TAxis     dca_{r} (cm)    dca_{r} (cm)
-  //  3. OBJ: TAxis     z (cm)  z (cm)
-  //  4. OBJ: TAxis     sin(#phi)       sin(#phi)
-  //  5. OBJ: TAxis     tan(#theta)     tan(#theta)
-  //  6. OBJ: TAxis     1/pt (1/GeV)    1/pt (1/GeV)
-  //  7. OBJ: TAxis     pt (GeV)        pt (GeV)
-  //  8. OBJ: TAxis     alpha   alpha
+  /// make a distortion map out ou fthe residual histogram
+  /// Results are written to the debug streamer - pcstream
+  /// Parameters:
+  ///   his0       - input (4D) residual histogram
+  ///   pcstream   - file to write the tree
+  ///   run        - run number
+  ///   refX       - track matching reference X
+  ///   type       - 0- y 1-z,2 -snp, 3-theta, 4=1/pt
+  /// marian.ivanov@cern.ch
+  ///
+  ///  Histo axeses
+  ///   Collection name='TObjArray', class='TObjArray', size=16
+  ///  0. OBJ: TAxis     #Delta  #Delta
+  ///  1. OBJ: TAxis     N_{cl}  N_{cl}
+  ///  2. OBJ: TAxis     dca_{r} (cm)    dca_{r} (cm)
+  ///  3. OBJ: TAxis     z (cm)  z (cm)
+  ///  4. OBJ: TAxis     sin(#phi)       sin(#phi)
+  ///  5. OBJ: TAxis     tan(#theta)     tan(#theta)
+  ///  6. OBJ: TAxis     1/pt (1/GeV)    1/pt (1/GeV)
+  ///  7. OBJ: TAxis     pt (GeV)        pt (GeV)
+  ///  8. OBJ: TAxis     alpha   alpha
+
   const Int_t kMinEntries=10;
   //
   //  1. make default selections
@@ -2694,7 +2613,7 @@ void   AliTPCCorrection::MakeDistortionMapCosmic(THnSparse * hisInput, TTreeSRed
   //
   for (Int_t ibin1=first1; ibin1<=last1; ibin1++){   //axis 1 - theta
     //
-    Double_t       x1= his0->GetAxis(1)->GetBinCenter(ibin1);  
+    Double_t       x1= his0->GetAxis(1)->GetBinCenter(ibin1);
     his0->GetAxis(1)->SetRange(TMath::Max(ibin1-1,1),TMath::Min(ibin1+1,nbins1));
     //
     THnSparse * his1 = his0->Projection(4,idim);  // projected histogram according range1
@@ -2722,8 +2641,8 @@ void   AliTPCCorrection::MakeDistortionMapCosmic(THnSparse * hisInput, TTreeSRed
 	Double_t entries = hisDelta->GetEntries();
 	Double_t mean=0, rms=0;
 	if (entries>kMinEntries){
-	  mean    = hisDelta->GetMean(); 
-	  rms = hisDelta->GetRMS(); 
+	  mean    = hisDelta->GetMean();
+	  rms = hisDelta->GetRMS();
 	}
 	Double_t sector = 9.*x2/TMath::Pi();
 	if (sector<0) sector+=18;
@@ -2757,15 +2676,14 @@ void   AliTPCCorrection::MakeDistortionMapCosmic(THnSparse * hisInput, TTreeSRed
 
 
 void   AliTPCCorrection::MakeDistortionMapSector(THnSparse * hisInput, TTreeSRedirector * const pcstream, const char* hname, Int_t run, Int_t type){
-  //
-  // make a distortion map out of the residual histogram
-  // Results are written to the debug streamer - pcstream
-  // Parameters:
-  //   his0       - input (4D) residual histogram
-  //   pcstream   - file to write the tree
-  //   run        - run number
-  //   type       - 0- y 1-z,2 -snp, 3-theta
-  // marian.ivanov@cern.ch
+  /// make a distortion map out of the residual histogram
+  /// Results are written to the debug streamer - pcstream
+  /// Parameters:
+  ///   his0       - input (4D) residual histogram
+  ///   pcstream   - file to write the tree
+  ///   run        - run number
+  ///   type       - 0- y 1-z,2 -snp, 3-theta
+  /// marian.ivanov@cern.ch
 
   //Collection name='TObjArray', class='TObjArray', size=16
   //0  OBJ: TAxis     delta   delta
@@ -2794,7 +2712,7 @@ void   AliTPCCorrection::MakeDistortionMapSector(THnSparse * hisInput, TTreeSRed
   //       z        - 7  ==> 3
   //         snp    - 3  ==> 2
   //           theta- 4  ==> 1
-  //                  0  ==> 0;           
+  //                  0  ==> 0;
   for (Int_t isec0=0; isec0<72; isec0++){
     Int_t index0[9]={0, 4, 3, 7, 1, 2, 5, 6,8}; //regroup indeces
     //
@@ -2803,11 +2721,11 @@ void   AliTPCCorrection::MakeDistortionMapSector(THnSparse * hisInput, TTreeSRed
     hisSector0=hisInput->Projection(7,index0);
     //
     //
-    for (Int_t isec1=isec0+1; isec1<72; isec1++){    
+    for (Int_t isec1=isec0+1; isec1<72; isec1++){
       //if (isec1!=isec0+36) continue;
       if ( TMath::Abs((isec0%18)-(isec1%18))>1.5 && TMath::Abs((isec0%18)-(isec1%18))<16.5) continue;
       printf("Sectors %d\t%d\n",isec1,isec0);
-      hisSector0->GetAxis(6)->SetRangeUser(isec1-0.1,isec1+0.1);      
+      hisSector0->GetAxis(6)->SetRangeUser(isec1-0.1,isec1+0.1);
       TH1 * hisX=hisSector0->Projection(5);
       Double_t refX= hisX->GetMean();
       delete hisX;
@@ -2834,7 +2752,7 @@ void   AliTPCCorrection::MakeDistortionMapSector(THnSparse * hisInput, TTreeSRed
 	//
 	// Phi loop
 	//
-	Double_t       xPhi= hisSector1->GetAxis(4)->GetBinCenter(ibinPhi);         
+	Double_t       xPhi= hisSector1->GetAxis(4)->GetBinCenter(ibinPhi);
 	Double_t psec    = (9*xPhi/TMath::Pi());
 	if (psec<0) psec+=18;
 	Bool_t isOK0=kFALSE;
@@ -2863,12 +2781,12 @@ void   AliTPCCorrection::MakeDistortionMapSector(THnSparse * hisInput, TTreeSRed
 	  //
 	  hisPhi->GetAxis(3)->SetRange(TMath::Max(ibinZ,firstZ),TMath::Min(ibinZ,lastZ));
 	  if (isec1!=isec0+36) {
-	    hisPhi->GetAxis(3)->SetRange(TMath::Max(ibinZ-1,firstZ),TMath::Min(ibinZ-1,lastZ));	    
+	    hisPhi->GetAxis(3)->SetRange(TMath::Max(ibinZ-1,firstZ),TMath::Min(ibinZ-1,lastZ));
 	  }
 	  htemp = hisPhi->Projection(3);
 	  Double_t      xZ= htemp->GetMean();
 	  delete htemp;
-	  THnSparse * hisZ= hisPhi->Projection(3,idim);         
+	  THnSparse * hisZ= hisPhi->Projection(3,idim);
 	  //projected histogram according selection 3 -z
 	  //
 	  //
@@ -2886,21 +2804,21 @@ void   AliTPCCorrection::MakeDistortionMapSector(THnSparse * hisInput, TTreeSRed
 	    htemp = hisZ->Projection(2);
 	    Double_t      xSnp= htemp->GetMean();
 	    delete htemp;
-	    THnSparse * hisSnp= hisZ->Projection(2,idim);         
+	    THnSparse * hisSnp= hisZ->Projection(2,idim);
 	    //projected histogram according selection 2 - snp
-	    
+
 	    //Int_t nbinsTheta    = hisSnp->GetAxis(1)->GetNbins();
 	    Int_t firstTheta    = hisSnp->GetAxis(1)->GetFirst();
 	    Int_t lastTheta     = hisSnp->GetAxis(1)->GetLast();
 	    //
 	    for (Int_t ibinTheta=firstTheta; ibinTheta<=lastTheta; ibinTheta+=2){  // axis1 theta
-	      
-	      
+
+
 	      hisSnp->GetAxis(1)->SetRange(TMath::Max(ibinTheta-2,firstTheta),TMath::Min(ibinTheta+2,lastTheta));
 	      if (isec1!=isec0+36) {
-		 hisSnp->GetAxis(1)->SetRange(TMath::Max(ibinTheta-3,firstTheta),TMath::Min(ibinTheta+3,lastTheta));		 
+		 hisSnp->GetAxis(1)->SetRange(TMath::Max(ibinTheta-3,firstTheta),TMath::Min(ibinTheta+3,lastTheta));
 	      }
-	      htemp = hisSnp->Projection(1);	      
+	      htemp = hisSnp->Projection(1);
 	      Double_t xTheta=htemp->GetMean();
 	      delete htemp;
 	      hisDelta = hisSnp->Projection(0);
@@ -2908,8 +2826,8 @@ void   AliTPCCorrection::MakeDistortionMapSector(THnSparse * hisInput, TTreeSRed
 	      Double_t entries = hisDelta->GetEntries();
 	      Double_t mean=0, rms=0;
 	      if (entries>kMinEntries){
-		mean    = hisDelta->GetMean(); 
-		rms = hisDelta->GetRMS(); 
+		mean    = hisDelta->GetMean();
+		rms = hisDelta->GetRMS();
 	      }
 	      Double_t sector = 9.*xPhi/TMath::Pi();
 	      if (sector<0) sector+=18;
@@ -2920,19 +2838,19 @@ void   AliTPCCorrection::MakeDistortionMapSector(THnSparse * hisInput, TTreeSRed
 		"bz="<<bz<<             // magnetic field
 		"ptype="<<type<<         // parameter type
 		"dtype="<<dtype<<         // parameter type
-		"isec0="<<isec0<<       // sector 0 
-		"isec1="<<isec1<<       // sector 1		
+		"isec0="<<isec0<<       // sector 0
+		"isec1="<<isec1<<       // sector 1
 		"sector="<<sector<<     // sector as float
 		"dsec="<<dsec<<         // delta sector
 		//
 		"theta="<<xTheta<<      // theta
-		"phi="<<xPhi<<          // phi (alpha)	      
+		"phi="<<xPhi<<          // phi (alpha)
 		"z="<<xZ<<              // z
 		"snp="<<xSnp<<          // snp
 		//
 		"entries="<<entries<<  // entries in bin
 		"mean="<<mean<<        // mean
-		"rms="<<rms<<          // rms 
+		"rms="<<rms<<          // rms
 		"refX="<<refX<<        // track matching reference plane
 		"\n";
 	      delete hisDelta;
@@ -2945,7 +2863,7 @@ void   AliTPCCorrection::MakeDistortionMapSector(THnSparse * hisInput, TTreeSRed
 	}//ibinZ
 	delete hisPhi;
       }//ibinPhi
-      delete hisSector1;      
+      delete hisSector1;
     }//isec1
     delete hisSector0;
   }//isec0
@@ -2958,11 +2876,10 @@ void   AliTPCCorrection::MakeDistortionMapSector(THnSparse * hisInput, TTreeSRed
 
 
 void AliTPCCorrection::StoreInOCDB(Int_t startRun, Int_t endRun, const char *comment){
-  //
-  // Store object in the OCDB
-  // By default the object is stored in the current directory 
-  // default comment consit of user name and the date
-  //
+  /// Store object in the OCDB
+  /// By default the object is stored in the current directory
+  /// default comment consit of user name and the date
+
   TString ocdbStorage="";
   ocdbStorage+="local://"+gSystem->GetFromPipe("pwd")+"/OCDB";
   AliCDBMetaData *metaData= new AliCDBMetaData();
@@ -2983,9 +2900,7 @@ void AliTPCCorrection::StoreInOCDB(Int_t startRun, Int_t endRun, const char *com
 
 
 void AliTPCCorrection::FastSimDistortedVertex(Double_t orgVertex[3], Int_t nTracks, AliESDVertex &aV, AliESDVertex &avOrg, AliESDVertex &cV, AliESDVertex &cvOrg, TTreeSRedirector * const pcstream, Double_t etaCuts){
-  //
-  // Fast method to simulate the influence of the given distortion on the vertex reconstruction
-  //
+  /// Fast method to simulate the influence of the given distortion on the vertex reconstruction
 
   AliMagF* magF= (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
   if (!magF) AliError("Magneticd field - not initialized");
@@ -2996,10 +2911,10 @@ void AliTPCCorrection::FastSimDistortedVertex(Double_t orgVertex[3], Int_t nTrac
   TObjArray   aTrk;              // Original Track array of Aside
   TObjArray   daTrk;             // Distorted Track array of A side
   UShort_t    *aId = new UShort_t[nTracks];      // A side Track ID
-  TObjArray   cTrk;               
+  TObjArray   cTrk;
   TObjArray   dcTrk;
   UShort_t    *cId = new UShort_t [nTracks];
-  Int_t id=0; 
+  Int_t id=0;
   Double_t mass = TDatabasePDG::Instance()->GetParticle("pi+")->Mass();
   TF1 fpt("fpt",Form("x*(1+(sqrt(x*x+%f^2)-%f)/([0]*[1]))^(-[0])",mass,mass),0.4,10);
   fpt.SetParameters(7.24,0.120);
@@ -3049,15 +2964,15 @@ void AliTPCCorrection::FastSimDistortedVertex(Double_t orgVertex[3], Int_t nTrac
 	cId[nn]=id;
       }
     }
-    id++;  
+    id++;
   }// end of track loop
 
   vertexer->SetTPCMode();
   vertexer->SetConstraintOff();
 
-  aV = *((AliESDVertex*)vertexer->FindPrimaryVertex(&daTrk,aId));  
+  aV = *((AliESDVertex*)vertexer->FindPrimaryVertex(&daTrk,aId));
   avOrg = *((AliESDVertex*)vertexer->FindPrimaryVertex(&aTrk,aId));
-  cV = *((AliESDVertex*)vertexer->FindPrimaryVertex(&dcTrk,cId));  
+  cV = *((AliESDVertex*)vertexer->FindPrimaryVertex(&dcTrk,cId));
   cvOrg = *((AliESDVertex*)vertexer->FindPrimaryVertex(&cTrk,cId));
   if (pcstream) (*pcstream)<<"vertex"<<
     "x="<<orgVertex[0]<<
@@ -3073,39 +2988,36 @@ void AliTPCCorrection::FastSimDistortedVertex(Double_t orgVertex[3], Int_t nTrac
 }
 
 void AliTPCCorrection::AddVisualCorrection(AliTPCCorrection* corr, Int_t position){
-  //
-  // make correction available for visualization using 
-  // TFormula, TFX and TTree::Draw 
-  // important in order to check corrections and also compute dervied variables 
-  // e.g correction partial derivatives
-  //
-  // NOTE - class is not owner of correction
-  //     
+  /// make correction available for visualization using
+  /// TFormula, TFX and TTree::Draw
+  /// important in order to check corrections and also compute dervied variables
+  /// e.g correction partial derivatives
+  ///
+  /// NOTE - class is not owner of correction
+
   if (!fgVisualCorrection) fgVisualCorrection=new TObjArray(10000);
   if (position>=fgVisualCorrection->GetEntriesFast())
     fgVisualCorrection->Expand((position+10)*2);
   fgVisualCorrection->AddAt(corr, position);
 }
 
-AliTPCCorrection* AliTPCCorrection::GetVisualCorrection(Int_t position) { 
-  //
-  // Get visula correction registered at index=position
-  //
+AliTPCCorrection* AliTPCCorrection::GetVisualCorrection(Int_t position) {
+  /// Get visula correction registered at index=position
+
   return fgVisualCorrection? (AliTPCCorrection*)fgVisualCorrection->At(position):0;
 }
 
 
 
 Double_t AliTPCCorrection::GetCorrSector(Double_t sector, Double_t r, Double_t kZ, Int_t axisType, Int_t corrType){
-  //
-  // calculate the correction at given position - check the geffCorr
-  //
-  // corrType return values
-  // 0 - delta R
-  // 1 - delta RPhi
-  // 2 - delta Z
-  // 3 - delta RPHI
-  //
+  /// calculate the correction at given position - check the geffCorr
+  ///
+  /// corrType return values
+  /// 0 - delta R
+  /// 1 - delta RPhi
+  /// 2 - delta Z
+  /// 3 - delta RPHI
+
   if (!fgVisualCorrection) return 0;
   AliTPCCorrection *corr = (AliTPCCorrection*)fgVisualCorrection->At(corrType);
   if (!corr) return 0;
@@ -3114,7 +3026,7 @@ Double_t AliTPCCorrection::GetCorrSector(Double_t sector, Double_t r, Double_t k
   Double_t gx = r*TMath::Cos(phi);
   Double_t gy = r*TMath::Sin(phi);
   Double_t gz = r*kZ;
-  Int_t nsector=(gz>=0) ? 0:18; 
+  Int_t nsector=(gz>=0) ? 0:18;
   //
   //
   //
@@ -3132,14 +3044,13 @@ Double_t AliTPCCorrection::GetCorrSector(Double_t sector, Double_t r, Double_t k
 }
 
 Double_t AliTPCCorrection::GetCorrXYZ(Double_t gx, Double_t gy, Double_t gz, Int_t axisType, Int_t corrType){
-  //
-  // return correction at given x,y,z
-  // 
+  /// return correction at given x,y,z
+
   if (!fgVisualCorrection) return 0;
   AliTPCCorrection *corr = (AliTPCCorrection*)fgVisualCorrection->At(corrType);
   if (!corr) return 0;
   Double_t phi0= TMath::ATan2(gy,gx);
-  Int_t nsector=(gz>=0) ? 0:18; 
+  Int_t nsector=(gz>=0) ? 0:18;
   Float_t distPoint[3]={static_cast<Float_t>(gx),static_cast<Float_t>(gy),static_cast<Float_t>(gz)};
   corr->CorrectPoint(distPoint, nsector);
   Double_t r0=TMath::Sqrt(gx*gx+gy*gy);
@@ -3152,14 +3063,13 @@ Double_t AliTPCCorrection::GetCorrXYZ(Double_t gx, Double_t gy, Double_t gz, Int
 }
 
 Double_t AliTPCCorrection::GetCorrXYZDz(Double_t gx, Double_t gy, Double_t gz, Int_t axisType, Int_t corrType,Double_t delta){
-  //
-  // return correction at given x,y,z
-  // 
+  /// return correction at given x,y,z
+
   if (!fgVisualCorrection) return 0;
   AliTPCCorrection *corr = (AliTPCCorrection*)fgVisualCorrection->At(corrType);
   if (!corr) return 0;
   Double_t phi0= TMath::ATan2(gy,gx);
-  Int_t nsector=(gz>=0) ? 0:18; 
+  Int_t nsector=(gz>=0) ? 0:18;
   Float_t distPoint[3]={static_cast<Float_t>(gx),static_cast<Float_t>(gy),static_cast<Float_t>(gz)};
   Float_t dxyz[3]={static_cast<Float_t>(gx),static_cast<Float_t>(gy),static_cast<Float_t>(gz)};
   //
@@ -3177,14 +3087,13 @@ Double_t AliTPCCorrection::GetCorrXYZDz(Double_t gx, Double_t gy, Double_t gz, I
 }
 
 Double_t AliTPCCorrection::GetCorrXYZIntegrateZ(Double_t gx, Double_t gy, Double_t gz, Int_t axisType, Int_t corrType,Double_t delta){
-  //
-  // return correction at given x,y,z
-  // 
+  /// return correction at given x,y,z
+
   if (!fgVisualCorrection) return 0;
   AliTPCCorrection *corr = (AliTPCCorrection*)fgVisualCorrection->At(corrType);
   if (!corr) return 0;
   Double_t phi0= TMath::ATan2(gy,gx);
-  Int_t nsector=(gz>=0) ? 0:18; 
+  Int_t nsector=(gz>=0) ? 0:18;
   Float_t distPoint[3]={static_cast<Float_t>(gx),static_cast<Float_t>(gy),static_cast<Float_t>(gz)};
   Float_t dxyz[3]={static_cast<Float_t>(gx),static_cast<Float_t>(gy),static_cast<Float_t>(gz)};
   //
@@ -3203,9 +3112,8 @@ Double_t AliTPCCorrection::GetCorrXYZIntegrateZ(Double_t gx, Double_t gy, Double
 
 
 Double_t AliTPCCorrection::GetDistXYZ(Double_t gx, Double_t gy, Double_t gz, Int_t axisType, Int_t corrType){
-  //
-  // return correction at given x,y,z
-  //
+  /// return correction at given x,y,z
+
   if (!fgVisualCorrection) return 0;
   AliTPCCorrection *corr = (AliTPCCorrection*)fgVisualCorrection->At(corrType);
   if (!corr) return 0;
@@ -3223,9 +3131,8 @@ Double_t AliTPCCorrection::GetDistXYZ(Double_t gx, Double_t gy, Double_t gz, Int
 }
 
 Double_t AliTPCCorrection::GetDistXYZDz(Double_t gx, Double_t gy, Double_t gz, Int_t axisType, Int_t corrType,Double_t delta){
-  //
-  // return correction at given x,y,z
-  //
+  /// return correction at given x,y,z
+
   if (!fgVisualCorrection) return 0;
   AliTPCCorrection *corr = (AliTPCCorrection*)fgVisualCorrection->At(corrType);
   if (!corr) return 0;
@@ -3248,9 +3155,8 @@ Double_t AliTPCCorrection::GetDistXYZDz(Double_t gx, Double_t gy, Double_t gz, I
 }
 
 Double_t AliTPCCorrection::GetDistXYZIntegrateZ(Double_t gx, Double_t gy, Double_t gz, Int_t axisType, Int_t corrType,Double_t delta){
-  //
-  // return correction at given x,y,z
-  //
+  /// return correction at given x,y,z
+
   if (!fgVisualCorrection) return 0;
   AliTPCCorrection *corr = (AliTPCCorrection*)fgVisualCorrection->At(corrType);
   if (!corr) return 0;
@@ -3275,12 +3181,11 @@ Double_t AliTPCCorrection::GetDistXYZIntegrateZ(Double_t gx, Double_t gy, Double
 
 
 void AliTPCCorrection::MakeLaserDistortionTree(TTree* tree, TObjArray */*corrArray*/, Int_t /*itype*/){
-  //
-  // Make a laser fit tree for global minimization
-  //  
-  AliTPCcalibDB*  calib=AliTPCcalibDB::Instance();  
-  AliTPCCorrection * correction = calib->GetTPCComposedCorrection();  
-  if (!correction) correction = calib->GetTPCComposedCorrection(AliTrackerBase::GetBz());  
+  /// Make a laser fit tree for global minimization
+
+  AliTPCcalibDB*  calib=AliTPCcalibDB::Instance();
+  AliTPCCorrection * correction = calib->GetTPCComposedCorrection();
+  if (!correction) correction = calib->GetTPCComposedCorrection(AliTrackerBase::GetBz());
   correction->AddVisualCorrection(correction,0);  //register correction
 
   //  AliTPCTransform *transform = AliTPCcalibDB::Instance()->GetTransform() ;
@@ -3305,7 +3210,7 @@ void AliTPCCorrection::MakeLaserDistortionTree(TTree* tree, TObjArray */*corrArr
   Int_t entries= tree->GetEntries();
   TTreeSRedirector *pcstream= new TTreeSRedirector("distortionLaser_0.root");
   Double_t bz=AliTrackerBase::GetBz();
-  // 
+  //
   //  Double_t globalXYZ[3];
   //Double_t globalXYZCorr[3];
   for (Int_t ientry=0; ientry<entries; ientry++){
@@ -3318,7 +3223,7 @@ void AliTPCCorrection::MakeLaserDistortionTree(TTree* tree, TObjArray */*corrArr
     TVectorD fit5(5);
     printf("Entry\t%d\n",ientry);
     for (Int_t irow0=0; irow0<158; irow0+=1){
-      //       
+      //
       TLinearFitter fitter10(4,"hyp3");
       TLinearFitter fitter5(2,"hyp1");
       Int_t sector= (Int_t)(*ltr->GetVecSec())[irow0];
@@ -3351,7 +3256,7 @@ void AliTPCCorrection::MakeLaserDistortionTree(TTree* tree, TObjArray */*corrArr
       Double_t mean10  =0;//   fitter10.GetParameter(0);
       Double_t slope10  =0;//   fitter10.GetParameter(0);
       Double_t cosPart10  = 0;//  fitter10.GetParameter(2);
-      Double_t sinPart10   =0;//  fitter10.GetParameter(3); 
+      Double_t sinPart10   =0;//  fitter10.GetParameter(3);
 
       if (fitter10.GetNpoints()>10){
 	fitter10.Eval();
@@ -3359,7 +3264,7 @@ void AliTPCCorrection::MakeLaserDistortionTree(TTree* tree, TObjArray */*corrArr
 	mean10      =   fitter10.GetParameter(0);
 	slope10     =   fitter10.GetParameter(1);
 	cosPart10   =   fitter10.GetParameter(2);
-	sinPart10   =  fitter10.GetParameter(3); 
+	sinPart10   =  fitter10.GetParameter(3);
 	//
 	// make short range fit
 	//
@@ -3375,14 +3280,14 @@ void AliTPCCorrection::MakeLaserDistortionTree(TTree* tree, TObjArray */*corrArr
 	  Double_t gz= (*ltr->GetVecGZ())[irow1];
 	  Double_t measY=(*vecdY)[irow1]+idealY;
 	  Double_t deltaR = GetCorrXYZ(gx, gy, gz, 0,0);
-	  // deltaR = R distorted -R ideal 
+	  // deltaR = R distorted -R ideal
 	  Double_t expY= mean10+slope10*(idealX+deltaR-refX);
 	  if (TMath::Abs(measY-expY)>kSigmaCut*rms10) continue;
 	  //
 	  Double_t corr=cosPart10*TMath::Cos(idealY/padWidth)+sinPart10*TMath::Sin(idealY/padWidth);
 	  Double_t xxx[4]={idealX+deltaR-refX,TMath::Cos(idealY/padWidth), TMath::Sin(idealY/padWidth)};
 	  fitter5.AddPoint(xxx,measY-corr,1);
-	}     
+	}
       }else{
 	isOK=kFALSE;
       }
@@ -3390,12 +3295,12 @@ void AliTPCCorrection::MakeLaserDistortionTree(TTree* tree, TObjArray */*corrArr
 
       Double_t rms5=0;//TMath::Sqrt(fitter5.GetChisquare()/(fitter5.GetNpoints()-4));
       Double_t offset5  =0;//  fitter5.GetParameter(0);
-      Double_t slope5   =0;//  fitter5.GetParameter(0); 
+      Double_t slope5   =0;//  fitter5.GetParameter(0);
       if (isOK){
 	fitter5.Eval();
 	rms5=TMath::Sqrt(fitter5.GetChisquare()/(fitter5.GetNpoints()-4));
 	offset5  =  fitter5.GetParameter(0);
-	slope5   =  fitter5.GetParameter(0); 
+	slope5   =  fitter5.GetParameter(0);
       }
       //
       Double_t dtype=5;
@@ -3414,7 +3319,7 @@ void AliTPCCorrection::MakeLaserDistortionTree(TTree* tree, TObjArray */*corrArr
       gz = (*ltr->GetVecGZ())[irow0];
       Double_t dRrec = GetCorrXYZ(gx, gy, gz, 0,0);
       fitter10.GetParameters(fit10);
-      fitter5.GetParameters(fit5);      
+      fitter5.GetParameters(fit5);
       Double_t idealY= (*ltr->GetVecLY())[irow0];
       Double_t measY=(*vecdY)[irow0]+idealY;
       Double_t corr=cosPart10*TMath::Cos(idealY/padWidth)+sinPart10*TMath::Sin(idealY/padWidth);
@@ -3425,7 +3330,7 @@ void AliTPCCorrection::MakeLaserDistortionTree(TTree* tree, TObjArray */*corrArr
 	"dtype="<<dtype<<   // detector match type
 	"ptype="<<ptype<<   // parameter type
 	"theta="<<theta<<   // theta
-	"phi="<<phi<<       // phi 
+	"phi="<<phi<<       // phi
 	"snp="<<snp<<       // snp
 	"sector="<<sector<<
 	"bundle="<<bundle<<
diff --git a/TPC/TPCbase/AliTPCCorrection.h b/TPC/TPCbase/AliTPCCorrection.h
index 886d662d99e..b1088d997b7 100644
--- a/TPC/TPCbase/AliTPCCorrection.h
+++ b/TPC/TPCbase/AliTPCCorrection.h
@@ -5,9 +5,8 @@
  * See cxx source for full Copyright notice                               */
 
 
-////////////////////////////////////////////////////////////////////////////////
-// AliTPCCorrection class                                                     //
-////////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCCorrection
+/// \brief AliTPCCorrection class
 
 
 #include <TNamed.h>
@@ -41,7 +40,7 @@ public:
 
   virtual void GetCorrectionDz(const Float_t x[], Short_t roc,Float_t dx[], Float_t delta);
   virtual void GetCorrectionIntegralDz(const Float_t x[], Short_t roc,Float_t dx[], Float_t delta);
-  
+
   // functions to distort a space point
           void DistortPoint (      Float_t x[], Short_t roc);
           void DistortPointLocal(Float_t x[], Short_t roc);
@@ -50,7 +49,7 @@ public:
 
   virtual void GetDistortionDz(const Float_t x[], Short_t roc,Float_t dx[], Float_t delta);
   virtual void GetDistortionIntegralDz(const Float_t x[], Short_t roc,Float_t dx[], Float_t delta);
-  
+
   // initialization and update functions
   virtual void Init();
   virtual void Update(const TTimeStamp &timeStamp);
@@ -58,10 +57,10 @@ public:
   // map scaling
   virtual void    SetCorrScaleFactor(Float_t /*val*/) { ; }
   virtual Float_t GetCorrScaleFactor() const { return 1.; }
-  
+
   // convenience functions
   virtual void Print(Option_t* option="") const;
- 
+
   TH2F* CreateHistoDRinXY   (Float_t z=10.,Int_t nx=100,Int_t ny=100);
   TH2F* CreateHistoDRPhiinXY(Float_t z=10.,Int_t nx=100,Int_t nphi=100);
   TH2F* CreateHistoDZinXY   (Float_t z=10.,Int_t nx=100,Int_t ny=100);
@@ -90,7 +89,7 @@ public:
   static AliTPCCorrection*  GetVisualCorrection(Int_t position);
   static AliTPCCorrection*  GetVisualCorrection(const char *corName){return (fgVisualCorrection==NULL) ? 0: ( AliTPCCorrection*) fgVisualCorrection->FindObject(corName);}
   static TObjArray*  GetVisualCorrections() { return fgVisualCorrection;}
-  
+
   static Double_t GetCorrSector(Double_t sector, Double_t r, Double_t kZ, Int_t axisType, Int_t corrType=0);
   static Double_t GetCorrXYZ(Double_t gx, Double_t gy, Double_t gz, Int_t axisType, Int_t corrType=0);
   //
@@ -101,94 +100,96 @@ public:
   //
   static Double_t GetDistXYZDz(Double_t gx, Double_t gy, Double_t gz, Int_t axisType, Int_t corrType=0,Double_t delta=5);
   static Double_t GetDistXYZIntegrateZ(Double_t gx, Double_t gy, Double_t gz, Int_t axisType, Int_t corrType=0, Double_t delta=5);
-  
+
 
 protected:
   TH2F* CreateTH2F(const char *name,const char *title,
 		   const char *xlabel,const char *ylabel,const char *zlabel,
 		   Int_t nbinsx,Double_t xlow,Double_t xup,
 		   Int_t nbinsy,Double_t ylow,Double_t yup);
- 
-  static const Double_t fgkTPCZ0;       // nominal gating grid position 
-  static const Double_t fgkIFCRadius;   // Mean Radius of the Inner Field Cage ( 82.43 min,  83.70 max) (cm)
-  static const Double_t fgkOFCRadius;   // Mean Radius of the Outer Field Cage (252.55 min, 256.45 max) (cm)
-  static const Double_t fgkZOffSet;     // Offset from CE: calculate all distortions closer to CE as if at this point
-  static const Double_t fgkCathodeV;    // Cathode Voltage (volts)
-  static const Double_t fgkGG;          // Gating Grid voltage (volts)
-  static const Double_t fgkdvdE;        // [cm/V] drift velocity dependency on the E field (from Magboltz for NeCO2N2 at standard environment)
-  static const Double_t fgkEM;          // charge/mass in [C/kg]
-  static const Double_t fgke0;          // vacuum permittivity [A·s/(V·m)]
+
+  static const Double_t fgkTPCZ0;       ///< nominal gating grid position
+  static const Double_t fgkIFCRadius;   ///< Mean Radius of the Inner Field Cage ( 82.43 min,  83.70 max) (cm)
+  static const Double_t fgkOFCRadius;   ///< Mean Radius of the Outer Field Cage (252.55 min, 256.45 max) (cm)
+  static const Double_t fgkZOffSet;     ///< Offset from CE: calculate all distortions closer to CE as if at this point
+  static const Double_t fgkCathodeV;    ///< Cathode Voltage (volts)
+  static const Double_t fgkGG;          ///< Gating Grid voltage (volts)
+  static const Double_t fgkdvdE;        ///< [cm/V] drift velocity dependency on the E field (from Magboltz for NeCO2N2 at standard environment)
+  static const Double_t fgkEM;          ///< charge/mass in [C/kg]
+  static const Double_t fgke0;          ///< vacuum permittivity [A·s/(V·m)]
 
 
   enum {kNR=   72  };     // Number of R points in the table for interpolating distortion data
-  enum {kNPhi= 18*10+1};  // Number of Phi points in the table for interpolating distortion data ( plus one extra for 360 == 0 ) 
+  enum {kNPhi= 18*10+1};  // Number of Phi points in the table for interpolating distortion data ( plus one extra for 360 == 0 )
   enum {kNZ=   166};      // Number of Z points in the table for interpolating distortion data
 
-  Double_t fgkRList[kNR]; // points in the radial direction (for the lookup table)
-  Double_t fgkPhiList[kNPhi]; // points in the phi direction (for the lookup table)
-  Double_t fgkZList[kNZ]; // points in the z direction (for the lookup table)
+  Double_t fgkRList[kNR]; ///< points in the radial direction (for the lookup table)
+  Double_t fgkPhiList[kNPhi]; ///< points in the phi direction (for the lookup table)
+  Double_t fgkZList[kNZ]; ///< points in the z direction (for the lookup table)
 
   // Simple Interpolation functions: e.g. with tricubic interpolation (not yet in TH3)
-  Int_t fILow, fJLow, fKLow;          // variable to help in the interpolation 
+  Int_t fILow, fJLow, fKLow;          ///< variable to help in the interpolation
   // Double_t versions
-  void Interpolate2DEdistortion( Int_t order, Double_t r, Double_t z, 
+  void Interpolate2DEdistortion( Int_t order, Double_t r, Double_t z,
 				 const Double_t er[kNZ][kNR], Double_t &erValue );
-  void Interpolate3DEdistortion( Int_t order, Double_t r, Float_t phi, Double_t z, 
-				 const Double_t er[kNZ][kNPhi][kNR], const Double_t ephi[kNZ][kNPhi][kNR], 
+  void Interpolate3DEdistortion( Int_t order, Double_t r, Float_t phi, Double_t z,
+				 const Double_t er[kNZ][kNPhi][kNR], const Double_t ephi[kNZ][kNPhi][kNR],
 				 const Double_t ez[kNZ][kNPhi][kNR],
 				 Double_t &erValue, Double_t &ephiValue, Double_t &ezValue);
   // TMatrixD versions (for e.g. Poisson relaxation)
-  Double_t Interpolate2DTable( Int_t order, Double_t x, Double_t y, 
-			      Int_t nx,  Int_t ny, const Double_t xv[], const Double_t yv[], 
+  Double_t Interpolate2DTable( Int_t order, Double_t x, Double_t y,
+			      Int_t nx,  Int_t ny, const Double_t xv[], const Double_t yv[],
 			      const TMatrixD &array );
   Double_t Interpolate3DTable( Int_t order, Double_t x,   Double_t y,   Double_t z,
 			      Int_t  nx,    Int_t  ny,    Int_t  nz,
 			      const Double_t xv[], const Double_t yv[], const Double_t zv[],
 			      TMatrixD **arrayofArrays );
-  Double_t Interpolate( const Double_t xArray[], const Double_t yArray[], 
+  Double_t Interpolate( const Double_t xArray[], const Double_t yArray[],
 			Int_t order, Double_t x );
   void Search( Int_t n, const Double_t xArray[], Double_t x, Int_t &low );
- 
+
   // TMatrixF versions (smaller size, e.g. for final look up table)
-  Float_t Interpolate2DTable( Int_t order, Double_t x, Double_t y, 
-			      Int_t nx,  Int_t ny, const Double_t xv[], const Double_t yv[], 
+  Float_t Interpolate2DTable( Int_t order, Double_t x, Double_t y,
+			      Int_t nx,  Int_t ny, const Double_t xv[], const Double_t yv[],
 			      const TMatrixF &array );
   Float_t Interpolate3DTable( Int_t order, Double_t x,   Double_t y,   Double_t z,
 			      Int_t  nx,    Int_t  ny,    Int_t  nz,
 			      const Double_t xv[], const Double_t yv[], const Double_t zv[],
-			       TMatrixF **arrayofArrays ); 
-  Float_t Interpolate( const Double_t xArray[], const Float_t yArray[], 
+			       TMatrixF **arrayofArrays );
+  Float_t Interpolate( const Double_t xArray[], const Float_t yArray[],
 			Int_t order, Double_t x );
 
   virtual Int_t IsPowerOfTwo ( Int_t i ) const  ;
 
-  
- 
-  // Algorithms to solve the laplace or poisson equation 
-  void PoissonRelaxation2D(TMatrixD &arrayV, TMatrixD &chargeDensity, 
+
+
+  // Algorithms to solve the laplace or poisson equation
+  void PoissonRelaxation2D(TMatrixD &arrayV, TMatrixD &chargeDensity,
 			   TMatrixD &arrayErOverEz, TMatrixD &arrayDeltaEz,
 			   Int_t rows, Int_t columns, Int_t iterations,
 			   Bool_t rocDisplacement = kTRUE);
 
-  void PoissonRelaxation3D( TMatrixD **arrayofArrayV, TMatrixD **arrayofChargeDensities, 
+  void PoissonRelaxation3D( TMatrixD **arrayofArrayV, TMatrixD **arrayofChargeDensities,
 			    TMatrixD **arrayofEroverEz, TMatrixD **arrayofEPhioverEz, TMatrixD **arrayofEz,
-			    Int_t rows, Int_t columns,  Int_t phislices, 
+			    Int_t rows, Int_t columns,  Int_t phislices,
 			    Float_t deltaphi, Int_t iterations, Int_t summetry,
-			    Bool_t rocDisplacement = kTRUE); 
+			    Bool_t rocDisplacement = kTRUE);
   void   SetIsLocal(Bool_t isLocal){fIsLocal=isLocal;}
   Bool_t IsLocal() const  { return fIsLocal;}
 protected:
-  Double_t fT1;         // tensor term of wt - T1
-  Double_t fT2;         // tensor term of wt - T2
-  Bool_t fIsLocal;      // switch to indicate that the distortion is a local vector drphi/dz, dr/dz
-  static TObjArray *fgVisualCorrection;  // array of orrection for visualization
+  Double_t fT1;         ///< tensor term of wt - T1
+  Double_t fT2;         ///< tensor term of wt - T2
+  Bool_t fIsLocal;      ///< switch to indicate that the distortion is a local vector drphi/dz, dr/dz
+  static TObjArray *fgVisualCorrection;  ///< array of orrection for visualization
 private:
   AliTPCCorrection(const AliTPCCorrection &);               // not implemented
   AliTPCCorrection &operator=(const AliTPCCorrection &);    // not implemented
 
   void InitLookUpfulcrums();   // to initialize the grid of the look up table
 
+  /// \cond CLASSIMP
   ClassDef(AliTPCCorrection,5);
+  /// \endcond
 };
 
 #endif
diff --git a/TPC/TPCbase/AliTPCCorrectionDrift.cxx b/TPC/TPCbase/AliTPCCorrectionDrift.cxx
index 41de930c729..8f3d86b1f36 100644
--- a/TPC/TPCbase/AliTPCCorrectionDrift.cxx
+++ b/TPC/TPCbase/AliTPCCorrectionDrift.cxx
@@ -13,12 +13,9 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-////////////////////////////////////////////////////////////////////////////
-//                                                                        //
-// AliTPCCorrectionDrift class  
-// linear drift corrections                                               //
-//  
-////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCCorrectionDrift
+/// \brief Linear drift corrections
+
 #include "AliMagF.h"
 #include "TGeoGlobalMagField.h"
 #include "AliTPCcalibDB.h"
@@ -28,7 +25,9 @@
 #include "TMath.h"
 #include "AliTPCROC.h"
 #include "AliTPCCorrectionDrift.h"
+/// \cond CLASSIMP
 ClassImp(AliTPCCorrectionDrift)
+/// \endcond
 
 AliTPCCorrectionDrift::AliTPCCorrectionDrift()
   : AliTPCCorrection("CorrectionDrift","CorrectionDrift") ,
@@ -47,35 +46,29 @@ AliTPCCorrectionDrift::AliTPCCorrectionDrift()
 }
 
 AliTPCCorrectionDrift::~AliTPCCorrectionDrift() {
-  //
-  // default destructor
-  //
+  /// default destructor
+
 }
 
 
 
 void AliTPCCorrectionDrift::Init() {
-  //
-  // Initialization funtion
-  //
-  
+  /// Initialization funtion
+
 
 
 }
 
 void AliTPCCorrectionDrift::Update(const TTimeStamp &/*timeStamp*/) {
-  //
-  // Update function 
-  //
+  /// Update function
 
 }
 
 
 
 void AliTPCCorrectionDrift::GetCorrection(const Float_t x[],const Short_t roc,Float_t dx[]) {
-  //
-  // Calculates the correction due conical shape
-  //   
+  /// Calculates the correction due conical shape
+
   AliTPCROC * calROC = AliTPCROC::Instance();
   //const Double_t kRTPC0  =calROC->GetPadRowRadii(0,0);
   const Double_t kRTPC1  =calROC->GetPadRowRadii(36,calROC->GetNRows(36)-1);
@@ -103,20 +96,17 @@ void AliTPCCorrectionDrift::GetCorrection(const Float_t x[],const Short_t roc,Fl
 
 
 void AliTPCCorrectionDrift::Print(const Option_t* option) const {
-  //
-  // Print function to check the settings (e.g. the twist in the X direction)
-  // 
-  //
+  /// Print function to check the settings (e.g. the twist in the X direction)
 
   TString opt = option; opt.ToLower();
   printf("%s\t%s\n",GetName(),GetTitle());
-  
+
   if (opt.Contains("a")) { // Print all details
     printf(" - T0A: %1.4f, T0C: %1.4f (cm)\n",fZ0Aside,fZ0Cside);
     printf(" - Scale0: %1.4f, ScaleR: %1.4f \n",fVScale0,fVScaleR);
     printf(" - ScaleX: %1.4f, ScaleY: %1.4f \n",fVScaleX,fVScaleY);
 
-  }    
- 
- 
+  }
+
+
 }
diff --git a/TPC/TPCbase/AliTPCCorrectionDrift.h b/TPC/TPCbase/AliTPCCorrectionDrift.h
index d81557f6d49..a456d091fda 100644
--- a/TPC/TPCbase/AliTPCCorrectionDrift.h
+++ b/TPC/TPCbase/AliTPCCorrectionDrift.h
@@ -4,12 +4,11 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-////////////////////////////////////////////////////////////////////////////
-//                                                                        //
-// AliTPCCorrectionDrift class                                                   //
-// date: 02/05/2010                                                       //
-// Authors: Maarian Ivanov, Jim Thomas, Magnus Mager, Stefan Rossegger                    //
-////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCCorrectionDrift
+/// \brief AliTPCCorrectionDrift class
+///
+/// \author Maarian Ivanov, Jim Thomas, Magnus Mager, Stefan Rossegger
+/// \date 02/05/2010
 
 #include "AliTPCCorrection.h"
 
@@ -24,19 +23,21 @@ public:
 
 public:
   virtual void GetCorrection(const Float_t x[],const Short_t roc,Float_t dx[]);
-  Double_t fZ0Aside;     // z- t0*vdrift shift A side
-  Double_t fZ0Cside;     // z- t0*vdrift shift C side
-  Double_t fVScale0;     // drift velocity scaling - constant
-  Double_t fVScaleR;     // drift velocity scaling - radial
-  Double_t fVScaleX;     // drift velocity scaling - global x
-  Double_t fVScaleY;     // drift velocity scaling - global y
+  Double_t fZ0Aside;     ///< z- t0*vdrift shift A side
+  Double_t fZ0Cside;     ///< z- t0*vdrift shift C side
+  Double_t fVScale0;     ///< drift velocity scaling - constant
+  Double_t fVScaleR;     ///< drift velocity scaling - radial
+  Double_t fVScaleX;     ///< drift velocity scaling - global x
+  Double_t fVScaleY;     ///< drift velocity scaling - global y
   //
-  Double_t fIROCZ0;      // IROC to OROC shift due unknown reason (clusterer shift Ampl. dependents?)
-  Double_t fOROCDZ;      // IROC to OROC slope shift due unknown reason (clusterer shift amplitude dependent?)
+  Double_t fIROCZ0;      ///< IROC to OROC shift due unknown reason (clusterer shift Ampl. dependents?)
+  Double_t fOROCDZ;      ///< IROC to OROC slope shift due unknown reason (clusterer shift amplitude dependent?)
 private:
   AliTPCCorrectionDrift(const AliTPCCorrectionDrift&);
   AliTPCCorrectionDrift &operator=(const AliTPCCorrectionDrift&);
+  /// \cond CLASSIMP
   ClassDef(AliTPCCorrectionDrift,1);
+  /// \endcond
 };
 
 #endif
diff --git a/TPC/TPCbase/AliTPCCorrectionLookupTable.cxx b/TPC/TPCbase/AliTPCCorrectionLookupTable.cxx
index c47108db66d..621830e9978 100644
--- a/TPC/TPCbase/AliTPCCorrectionLookupTable.cxx
+++ b/TPC/TPCbase/AliTPCCorrectionLookupTable.cxx
@@ -1,3 +1,5 @@
+/// \class AliTPCCorrectionLookupTable
+
 /**************************************************************************
  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  *                                                                        *
@@ -31,7 +33,9 @@
 
 #include "AliTPCCorrectionLookupTable.h"
 
+/// \cond CLASSIMP
 ClassImp(AliTPCCorrectionLookupTable)
+/// \endcond
 
 //_________________________________________________________________________________________
 AliTPCCorrectionLookupTable::AliTPCCorrectionLookupTable()
@@ -58,27 +62,22 @@ AliTPCCorrectionLookupTable::AliTPCCorrectionLookupTable()
 //_________________________________________________________________________________________
 AliTPCCorrectionLookupTable::~AliTPCCorrectionLookupTable()
 {
-  //
-  // dtor
-  //
+  /// dtor
 
   ResetTables();
 }
 
 //_________________________________________________________________________________________
 void AliTPCCorrectionLookupTable::GetDistortion(const Float_t x[],const Short_t roc,Float_t dx[]) {
-  //
-  // Get interpolated Distortion
-  //
+  /// Get interpolated Distortion
 
   GetInterpolation(x,roc,dx,fLookUpDxDist,fLookUpDyDist,fLookUpDzDist);
 }
 
 //_________________________________________________________________________________________
 void AliTPCCorrectionLookupTable::GetCorrection(const Float_t x[],const Short_t roc,Float_t dx[]) {
-  //
-  // Get interplolated correction
-  //
+  /// Get interplolated correction
+
   GetInterpolation(x,roc,dx,fLookUpDxCorr,fLookUpDyCorr,fLookUpDzCorr);
 
   if (fCorrScaleFactor>0) {
@@ -92,38 +91,36 @@ void AliTPCCorrectionLookupTable::GetCorrection(const Float_t x[],const Short_t
 void AliTPCCorrectionLookupTable::GetInterpolation(const Float_t x[],const Short_t roc,Float_t dx[],
                                                    TMatrixF **mDx, TMatrixF **mDy, TMatrixF **mDz)
 {
-  //
-  // Calculates the correction/distotring from a lookup table
-  // type: 0 = correction
-  //       1 = distortion
-  //
+  /// Calculates the correction/distotring from a lookup table
+  /// type: 0 = correction
+  ///       1 = distortion
 
 //   Float_t typeSign=-1;
 //   if (type==1) typeSign=1;
-  
+
   Int_t   order     = 1 ;    // FIXME: hardcoded? Linear interpolation = 1, Quadratic = 2
-  
+
   Double_t r, phi, z ;
   Int_t    sign;
-  
+
   r      =  TMath::Sqrt( x[0]*x[0] + x[1]*x[1] ) ;
   phi    =  TMath::ATan2(x[1],x[0]) ;
   if ( phi < 0 ) phi += TMath::TwoPi() ;                   // Table uses phi from 0 to 2*Pi
   z      =  x[2] ;                                         // Create temporary copy of x[2]
-  
+
   if ( (roc%36) < 18 ) {
     sign =  1;       // (TPC A side)
   } else {
     sign = -1;       // (TPC C side)
   }
-  
+
   if ( sign==1  && z <  fgkZOffSet ) z =  fgkZOffSet;    // Protect against discontinuity at CE
   if ( sign==-1 && z > -fgkZOffSet ) z = -fgkZOffSet;    // Protect against discontinuity at CE
 
 
   if ( (sign==1 && z<0) || (sign==-1 && z>0) ) // just a consistency check
     AliError("ROC number does not correspond to z coordinate! Calculation of distortions is most likely wrong!");
-  
+
   // Get the Er and Ephi field integrals plus the integral over Z
     dx[0] = Interpolate3DTable(order, r, z, phi,
                                fNR, fNZ, fNPhi,
@@ -148,9 +145,7 @@ void AliTPCCorrectionLookupTable::GetInterpolation(const Float_t x[],const Short
 //_________________________________________________________________________________________
 void AliTPCCorrectionLookupTable::CreateLookupTable(AliTPCCorrection &tpcCorr, Float_t stepSize/*=5.*/)
 {
-  //
-  // create lookup table for all phi,r,z bins
-  //
+  /// create lookup table for all phi,r,z bins
 
   if (fNR==0) {
     AliError("Limits are not set yet. Please use one of the Set..Limits functions first");
@@ -158,10 +153,10 @@ void AliTPCCorrectionLookupTable::CreateLookupTable(AliTPCCorrection &tpcCorr, F
   }
 
   TStopwatch s;
-  
+
   ResetTables();
   InitTables();
-  
+
   for (Int_t iPhi=0; iPhi<fNPhi; ++iPhi){
     CreateLookupTablePhiBin(tpcCorr,iPhi,stepSize);
   }
@@ -173,17 +168,15 @@ void AliTPCCorrectionLookupTable::CreateLookupTable(AliTPCCorrection &tpcCorr, F
 //_________________________________________________________________________________________
 void AliTPCCorrectionLookupTable::CreateLookupTableSinglePhi(AliTPCCorrection &tpcCorr, Int_t iPhi, Float_t stepSize)
 {
-  //
-  // Lookup table for only one phi bin. Can be used for parallel processing
-  //
-  
+  /// Lookup table for only one phi bin. Can be used for parallel processing
+
   if (fNR==0) {
     AliError("Limits are not set yet. Please use one of the Set..Limits functions first");
     return;
   }
 
   TStopwatch s;
-  
+
   ResetTables();
   InitTableArrays();
   InitTablesPhiBin(iPhi);
@@ -196,12 +189,10 @@ void AliTPCCorrectionLookupTable::CreateLookupTableSinglePhi(AliTPCCorrection &t
 //_________________________________________________________________________________________
 void AliTPCCorrectionLookupTable::CreateLookupTablePhiBin(AliTPCCorrection &tpcCorr, Int_t iPhi, Float_t stepSize)
 {
-  //
-  //
-  //
+  ///
 
   if (iPhi<0||iPhi>=fNPhi) return;
-  
+
   const Float_t delta=stepSize; // 5cm
   Float_t x[3]={0.,0.,0.};
   Float_t dx[3]={0.,0.,0.};
@@ -215,12 +206,12 @@ void AliTPCCorrectionLookupTable::CreateLookupTablePhiBin(AliTPCCorrection &tpcC
   TMatrixF &mDxCorr   = *fLookUpDxCorr[iPhi];
   TMatrixF &mDyCorr   = *fLookUpDyCorr[iPhi];
   TMatrixF &mDzCorr   = *fLookUpDzCorr[iPhi];
-  
+
   for (Int_t ir=0; ir<fNR; ++ir){
     Double_t r=fLimitsR(ir);
     x[0]=r * TMath::Cos(phi);
     x[1]=r * TMath::Sin(phi);
-    
+
     for (Int_t iz=0; iz<fNZ; ++iz){
       Double_t z=fLimitsZ(iz);
       x[2]=z;
@@ -228,7 +219,7 @@ void AliTPCCorrectionLookupTable::CreateLookupTablePhiBin(AliTPCCorrection &tpcC
       Int_t roc=TMath::Nint(phi*TMath::RadToDeg()/20.)%18;
       if (r>133.) roc+=36;
       if (z<0)    roc+=18;
-      
+
       if (delta>0)
         tpcCorr.GetDistortionIntegralDz(x,roc,dx,delta);
       else
@@ -248,15 +239,13 @@ void AliTPCCorrectionLookupTable::CreateLookupTablePhiBin(AliTPCCorrection &tpcC
       }
     }
   }
-  
+
 }
 
 //_________________________________________________________________________________________
 void AliTPCCorrectionLookupTable::InitTables()
 {
-  //
-  // Init all tables
-  //
+  /// Init all tables
 
   InitTableArrays();
   for (Int_t iPhi=0; iPhi<fNPhi; ++iPhi){
@@ -267,20 +256,19 @@ void AliTPCCorrectionLookupTable::InitTables()
 //_________________________________________________________________________________________
 void AliTPCCorrectionLookupTable::CreateLookupTableFromResidualDistortion(THn &resDist)
 {
-  //
-  // create lookup table from residual distortions stored in a 3d histogram
-  // assume dimensions are r, phi, z
-  //
+  /// create lookup table from residual distortions stored in a 3d histogram
+  /// assume dimensions are r, phi, z
+
   if (fNR==0) {
     AliError("Limits are not set yet. Please use one of the Set..Limits functions first");
     return;
   }
-  
+
   ResetTables();
   InitTables();
 
   Double_t x[3]={0.,0.,0.};
-  
+
   for (Int_t iPhi=0; iPhi<fNPhi; ++iPhi){
     const Double_t phi=fLimitsPhi(iPhi);
     x[1]=phi;
@@ -292,18 +280,18 @@ void AliTPCCorrectionLookupTable::CreateLookupTableFromResidualDistortion(THn &r
     TMatrixF &mDxCorr   = *fLookUpDxCorr[iPhi];
     TMatrixF &mDyCorr   = *fLookUpDyCorr[iPhi];
     TMatrixF &mDzCorr   = *fLookUpDzCorr[iPhi];
-    
+
     for (Int_t ir=0; ir<fNR; ++ir){
       const Double_t r=fLimitsR(ir);
       x[0]=r;
-      
+
       for (Int_t iz=0; iz<fNZ; ++iz){
         const Double_t z=fLimitsZ(iz);
         x[2]=z;
 
         const Double_t drphi = resDist.GetBinContent(resDist.GetBin(x));
         Double_t dx[3]={0.,drphi,0.};
-        
+
         // transform rphi distortions (local y, so dy') to a global distortion
         // assume no radial distortion (dx' = 0)
         // assume no residual distortion in z for the moment
@@ -325,15 +313,13 @@ void AliTPCCorrectionLookupTable::CreateLookupTableFromResidualDistortion(THn &r
 //_________________________________________________________________________________________
 void AliTPCCorrectionLookupTable::CreateResidual(AliTPCCorrection *distortion, AliTPCCorrection* correction)
 {
-  //
-  // create lookup table from residual distortions calculated from distorted - correction
-  //
-  
+  /// create lookup table from residual distortions calculated from distorted - correction
+
   ResetTables();
   InitTables();
-  
+
   Float_t x[3]={0.,0.,0.};
-  
+
   for (Int_t iPhi=0; iPhi<fNPhi; ++iPhi){
     const Double_t phi=fLimitsPhi(iPhi);
     //
@@ -344,19 +330,19 @@ void AliTPCCorrectionLookupTable::CreateResidual(AliTPCCorrection *distortion, A
     TMatrixF &mDxCorr   = *fLookUpDxCorr[iPhi];
     TMatrixF &mDyCorr   = *fLookUpDyCorr[iPhi];
     TMatrixF &mDzCorr   = *fLookUpDzCorr[iPhi];
-    
+
     for (Int_t ir=0; ir<fNR; ++ir){
       const Double_t r=fLimitsR(ir);
       x[0]=r * TMath::Cos(phi);
       x[1]=r * TMath::Sin(phi);
-      
+
       for (Int_t iz=0; iz<fNZ; ++iz){
         const Double_t z=fLimitsZ(iz);
         x[2]=z;
 
         //original point
         Float_t xdc[3]={x[0], x[1], x[2]};
-        
+
         Int_t roc=TMath::Nint(phi*TMath::RadToDeg()/20.)%18;
         if (r>133.) roc+=36;
         if (z<0)    roc+=18;
@@ -365,11 +351,11 @@ void AliTPCCorrectionLookupTable::CreateResidual(AliTPCCorrection *distortion, A
         distortion->DistortPoint(xdc, roc);
         correction->CorrectPoint(xdc, roc);
         Float_t dx[3]={xdc[0]-x[0], xdc[1]-x[1], xdc[2]-x[2]};
-        
+
         mDxDist(ir,iz)=dx[0];
         mDyDist(ir,iz)=dx[1];
         mDzDist(ir,iz)=dx[2];
-        
+
         mDxCorr(ir,iz)=-dx[0];
         mDyCorr(ir,iz)=-dx[1];
         mDzCorr(ir,iz)=-dx[2];
@@ -381,37 +367,33 @@ void AliTPCCorrectionLookupTable::CreateResidual(AliTPCCorrection *distortion, A
 //_________________________________________________________________________________________
 void AliTPCCorrectionLookupTable::InitTablesPhiBin(Int_t iPhi)
 {
-  //
-  //
-  //
+  ///
 
   // check if already initialised
   if (iPhi<0||iPhi>=fNPhi) return;
   if (fLookUpDxCorr[iPhi]) return;
-  
+
   fLookUpDxCorr[iPhi] = new TMatrixF(fNR,fNZ);
   fLookUpDyCorr[iPhi] = new TMatrixF(fNR,fNZ);
   fLookUpDzCorr[iPhi] = new TMatrixF(fNR,fNZ);
-  
+
   fLookUpDxDist[iPhi] = new TMatrixF(fNR,fNZ);
   fLookUpDyDist[iPhi] = new TMatrixF(fNR,fNZ);
   fLookUpDzDist[iPhi] = new TMatrixF(fNR,fNZ);
-  
+
 }
 //_________________________________________________________________________________________
 void AliTPCCorrectionLookupTable::InitTableArrays()
 {
-  //
-  //
-  //
+  ///
 
   // needs to be before the table creation to set the limits
   SetupDefaultLimits();
-  
+
   fLookUpDxCorr = new TMatrixF*[fNPhi];
   fLookUpDyCorr = new TMatrixF*[fNPhi];
   fLookUpDzCorr = new TMatrixF*[fNPhi];
-  
+
   fLookUpDxDist = new TMatrixF*[fNPhi];
   fLookUpDyDist = new TMatrixF*[fNPhi];
   fLookUpDzDist = new TMatrixF*[fNPhi];
@@ -420,7 +402,7 @@ void AliTPCCorrectionLookupTable::InitTableArrays()
     fLookUpDxCorr[iPhi] = 0x0;
     fLookUpDyCorr[iPhi] = 0x0;
     fLookUpDzCorr[iPhi] = 0x0;
-    
+
     fLookUpDxDist[iPhi] = 0x0;
     fLookUpDyDist[iPhi] = 0x0;
     fLookUpDzDist[iPhi] = 0x0;
@@ -430,12 +412,10 @@ void AliTPCCorrectionLookupTable::InitTableArrays()
 //_________________________________________________________________________________________
 void AliTPCCorrectionLookupTable::ResetTables()
 {
-  //
-  // Reset the lookup tables
-  //
+  /// Reset the lookup tables
 
   if (!fLookUpDxCorr) return;
-  
+
   for (Int_t iPhi=0; iPhi<fNPhi; ++iPhi){
     delete fLookUpDxCorr[iPhi];
     delete fLookUpDyCorr[iPhi];
@@ -449,15 +429,15 @@ void AliTPCCorrectionLookupTable::ResetTables()
   delete [] fLookUpDxCorr;
   delete [] fLookUpDyCorr;
   delete [] fLookUpDzCorr;
-  
+
   delete [] fLookUpDxDist;
   delete [] fLookUpDyDist;
   delete [] fLookUpDzDist;
-  
+
   fLookUpDxCorr   = 0x0;
   fLookUpDyCorr = 0x0;
   fLookUpDzCorr    = 0x0;
-  
+
   fLookUpDxDist   = 0x0;
   fLookUpDyDist = 0x0;
   fLookUpDzDist    = 0x0;
@@ -466,9 +446,7 @@ void AliTPCCorrectionLookupTable::ResetTables()
 //_________________________________________________________________________________________
 void AliTPCCorrectionLookupTable::SetupDefaultLimits()
 {
-  //
-  // Set default limits for tables
-  //
+  /// Set default limits for tables
 
   fNR   = kNR;
   fNPhi = kNPhi;
@@ -496,14 +474,12 @@ void AliTPCCorrectionLookupTable::ResetLimits()
 //_________________________________________________________________________________________
 void AliTPCCorrectionLookupTable::MergePhiTables(const char* files)
 {
-  //
-  // merge all lookup tables stored in 'files' with this one
-  // assume that each lookup table in each file has only one phi bin
-  //
+  /// merge all lookup tables stored in 'files' with this one
+  /// assume that each lookup table in each file has only one phi bin
 
   ResetTables();
   ResetLimits(); // use limits from the first file assuming they are all the same
-  
+
   TString sfiles=gSystem->GetFromPipe(Form("ls %s",files));
   TObjArray *arrFiles=sfiles.Tokenize("\n");
 
@@ -555,18 +531,16 @@ void AliTPCCorrectionLookupTable::MergePhiTables(const char* files)
       AliFatal(Form("Phi bin '%d' not initialised from files!",iPhi));
     }
   }
-  
+
   delete arrFiles;
 }
 
 //_________________________________________________________________________________________
 void AliTPCCorrectionLookupTable::BuildExactInverse()
 {
-  //
-  // this method build the exact inverse of the standard distortion map
-  // for the the distortion man first needs to be calculated
-  // then the correction map will be overwritten
-  //
+  /// this method build the exact inverse of the standard distortion map
+  /// for the the distortion man first needs to be calculated
+  /// then the correction map will be overwritten
 
   Float_t x[3]    = {0.,0.,0.};
   Float_t x2[3]   = {0.,0.,0.};
@@ -579,7 +553,7 @@ void AliTPCCorrectionLookupTable::BuildExactInverse()
     TMatrixF &mDxCorr   = *fLookUpDxCorr[iPhi];
     TMatrixF &mDyCorr   = *fLookUpDyCorr[iPhi];
     TMatrixF &mDzCorr   = *fLookUpDzCorr[iPhi];
-    
+
     for (Int_t ir=0; ir<fNR; ++ir){
       for (Int_t iz=0; iz<fNZ; ++iz){
         mDxCorr(ir,iz) = -1000.;
@@ -588,14 +562,14 @@ void AliTPCCorrectionLookupTable::BuildExactInverse()
       }
     }
   }
-  
+
   // get interplolated corrections on standard grid
   for (Int_t iPhi=0; iPhi<fNPhi; ++iPhi){
     Double_t phi=fLimitsPhi(iPhi);
     TMatrixF &mDxDist   = *fLookUpDxDist[iPhi];
     TMatrixF &mDyDist   = *fLookUpDyDist[iPhi];
     TMatrixF &mDzDist   = *fLookUpDzDist[iPhi];
-    
+
     for (Int_t ir=0; ir<fNR; ++ir){
       Double_t r=fLimitsR(ir);
       x[0]=r * TMath::Cos(phi);
@@ -604,7 +578,7 @@ void AliTPCCorrectionLookupTable::BuildExactInverse()
       for (Int_t iz=0; iz<fNZ; ++iz){
         Double_t z=fLimitsZ(iz);
         x[2]=z;
-        
+
         //TODO: change hardcoded value for r>133.?
         Int_t roc=TMath::Nint(phi*TMath::RadToDeg()/20.)%18;
         if (r>133.) roc+=36;
@@ -623,11 +597,11 @@ void AliTPCCorrectionLookupTable::BuildExactInverse()
         const Double_t zd   = xd[2];
 
         Int_t ilow = 0, jlow = 0, klow = 0 ;
-        
+
         Search( fLimitsR.GetNrows(),   fLimitsR.GetMatrixArray(),   rd,   ilow   ) ;
         Search( fLimitsZ.GetNrows(),   fLimitsZ.GetMatrixArray(),   zd,   jlow   ) ;
         Search( fLimitsPhi.GetNrows(), fLimitsPhi.GetMatrixArray(), phid, klow   ) ;
-        
+
         if ( ilow < 0 ) ilow = 0 ;   // check if out of range
         if ( jlow < 0 ) jlow = 0 ;
         if ( klow < 0 ) klow = 0 ;
@@ -638,16 +612,16 @@ void AliTPCCorrectionLookupTable::BuildExactInverse()
         const Double_t phiRef = fLimitsPhi[klow];
         const Double_t rRef   = fLimitsR[ilow];
         const Double_t zRef   = fLimitsZ[jlow];
-        
+
         TMatrixF &mDxCorr   = *fLookUpDxCorr[klow];
         if ( mDxCorr(ilow, jlow) > -1000. ) continue;
         TMatrixF &mDyCorr   = *fLookUpDyCorr[klow];
         TMatrixF &mDzCorr   = *fLookUpDzCorr[klow];
-        
+
         xref[0]= rRef * TMath::Cos(phiRef);
         xref[1]= rRef * TMath::Sin(phiRef);
         xref[2]= zRef;
-        
+
         FindClosestPosition(ir,iz,iPhi, xref, x2);
 
         GetDistortion(x2,roc,dx);
@@ -675,11 +649,11 @@ void AliTPCCorrectionLookupTable::BuildExactInverse()
   TMatrixF &mDxCorr   = *fLookUpDxCorr[0];
   TMatrixF &mDyCorr   = *fLookUpDyCorr[0];
   TMatrixF &mDzCorr   = *fLookUpDzCorr[0];
-  
+
   TMatrixF &mDxCorr2  = *fLookUpDxCorr[fNPhi-1];
   TMatrixF &mDyCorr2  = *fLookUpDyCorr[fNPhi-1];
   TMatrixF &mDzCorr2  = *fLookUpDzCorr[fNPhi-1];
-  
+
   for (Int_t ir=0; ir<fNR; ++ir){
     for (Int_t iz=0; iz<fNZ; ++iz){
       mDxCorr2(ir,iz) = mDxCorr(ir,iz);
@@ -693,7 +667,7 @@ void AliTPCCorrectionLookupTable::BuildExactInverse()
     TMatrixF &mDxCorr   = *fLookUpDxCorr[iPhi];
     TMatrixF &mDyCorr   = *fLookUpDyCorr[iPhi];
     TMatrixF &mDzCorr   = *fLookUpDzCorr[iPhi];
-    
+
     Double_t phi=fLimitsPhi(iPhi);
     for (Int_t ir=0; ir<fNR; ++ir){
       Double_t r=fLimitsR(ir);
@@ -705,17 +679,17 @@ void AliTPCCorrectionLookupTable::BuildExactInverse()
 
         Double_t z=fLimitsZ(iz);
         x[2]=z;
-        
+
         //TODO: change hardcoded value for r>133.?
         Int_t roc=TMath::Nint(phi*TMath::RadToDeg()/20.)%18;
         if (r>133.) roc+=36;
         if (z<0)    roc+=18;
-        
+
         // get last point
         dx[0] = mDxCorr(ir,iz-1);
         dx[1] = mDyCorr(ir,iz-1);
         dx[2] = mDzCorr(ir,iz-1);
-        
+
         xd[0] = x[0]+dx[0];
         xd[1] = x[1]+dx[1];
         xd[2] = x[2]+dx[2];
@@ -724,40 +698,38 @@ void AliTPCCorrectionLookupTable::BuildExactInverse()
         const Double_t phid = TVector2::Phi_0_2pi(TMath::ATan2(xd[1],xd[0]));
         const Double_t rd   = TMath::Sqrt(xd[0]*xd[0] + xd[1]*xd[1]);
         const Double_t zd   = xd[2];
-        
+
         Int_t ilow = 0, jlow = 0, klow = 0 ;
-        
+
         Search( fLimitsR.GetNrows(),   fLimitsR.GetMatrixArray(),   rd,   ilow   ) ;
         Search( fLimitsZ.GetNrows(),   fLimitsZ.GetMatrixArray(),   zd,   jlow   ) ;
         Search( fLimitsPhi.GetNrows(), fLimitsPhi.GetMatrixArray(), phid, klow   ) ;
-        
+
         if ( ilow < 0 ) ilow = 0 ;   // check if out of range
         if ( jlow < 0 ) jlow = 0 ;
         if ( klow < 0 ) klow = 0 ;
         if ( ilow >= fLimitsR.GetNrows())   ilow = fLimitsR.GetNrows() - 1;
         if ( jlow >= fLimitsZ.GetNrows())   jlow = fLimitsZ.GetNrows() - 1;
         if ( klow >= fLimitsPhi.GetNrows()) klow = fLimitsPhi.GetNrows() - 1;
-        
+
         FindClosestPosition(ilow,jlow,klow, x, x2);
-        
+
         GetDistortion(x2,roc,dx);
-        
+
         mDxCorr(ir, iz) = -dx[0];
         mDyCorr(ir, iz) = -dx[1];
         mDzCorr(ir, iz) = -dx[2];
       }
     }
   }
-  
+
 }
 
 //_________________________________________________________________________________________
 void AliTPCCorrectionLookupTable::FindClosestPosition(const Int_t binR, const Int_t binZ, const Int_t binPhi,
                                                       const Float_t xref[3], Float_t xret[3])
 {
-  //
-  //
-  //
+  ///
 
 //   static TLinearFitter fitx(2,"pol2");
 //   static TLinearFitter fity(2,"pol2");
@@ -789,30 +761,30 @@ void AliTPCCorrectionLookupTable::FindClosestPosition(const Int_t binR, const In
   while (rMax>=fNR) {--rMin; --rMax;}
   while (zMax>=fNZ) {--zMin; --zMax;}
   while (phiMax>=fNPhi) {--phiMin; --phiMax;}
-  
+
   Float_t  x[3]    = {0.,0.,0.};
   Double_t xd[3]   = {0.,0.,0.};
   Float_t  dx[3]   = {0.,0.,0.};
-  
+
   for (Int_t iPhi=phiMin; iPhi<phiMax; ++iPhi) {
     TMatrixF &mDxDist   = *fLookUpDxDist[iPhi];
     TMatrixF &mDyDist   = *fLookUpDyDist[iPhi];
     TMatrixF &mDzDist   = *fLookUpDzDist[iPhi];
-    
+
     Double_t phi=fLimitsPhi(iPhi);
     for (Int_t ir=rMin; ir<rMax; ++ir){
       Double_t r=fLimitsR(ir);
       x[0]=r * TMath::Cos(phi);
       x[1]=r * TMath::Sin(phi);
-      
+
       for (Int_t iz=zMin; iz<zMax; ++iz){
         Double_t z=fLimitsZ(iz);
         x[2]=z;
-        
+
         dx[0] = mDxDist(ir,iz);
         dx[1] = mDyDist(ir,iz);
         dx[2] = mDzDist(ir,iz);
-        
+
         xd[0] = x[0]+dx[0];
         xd[1] = x[1]+dx[1];
         xd[2] = x[2]+dx[2];
diff --git a/TPC/TPCbase/AliTPCCorrectionLookupTable.h b/TPC/TPCbase/AliTPCCorrectionLookupTable.h
index 9c0d65db86d..7a09fb304e7 100644
--- a/TPC/TPCbase/AliTPCCorrectionLookupTable.h
+++ b/TPC/TPCbase/AliTPCCorrectionLookupTable.h
@@ -1,10 +1,10 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-////////////////////////////////////////////////////////////////////////////
-// AliTPCCorrectionLookupTable class                                              //
-// Authors: Jens Wiechula                                            //
-////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCCorrectionLookupTable
+/// \brief AliTPCCorrectionLookupTable class
+///
+/// \author Jens Wiechula
 
 #include "AliTPCCorrection.h"
 #include <TVectorD.h>
@@ -26,7 +26,7 @@ public:
 
   void CreateLookupTableFromResidualDistortion(THn &resDist);
   void CreateResidual(AliTPCCorrection *distortion, AliTPCCorrection* correction);
-  
+
   void MergePhiTables(const char* files);
 
   void   SetFillCorrection(Bool_t fill) { fFillCorrection=fill;   }
@@ -40,42 +40,48 @@ public:
   const TVectorD& GetLimitsR()   const { return fLimitsR; }
   const TVectorD& GetLimitsPhi() const { return fLimitsPhi; }
   const TVectorD& GetLimitsZ()   const { return fLimitsZ; }
-  
+
   void SetCorrScaleFactor(Float_t    val) { fCorrScaleFactor = val; }
   Float_t    GetCorrScaleFactor() const { return fCorrScaleFactor; }
-  
+
 private:
 
   // sizes of lookup tables
   // TODO: Remove, since it will be stored in the TVectorD anyhow?
-  Int_t     fNR;                   // number of rows (r) used for lookup table
-  Int_t     fNPhi;                 // number of phi slices used for lookup table
-  Int_t     fNZ;                   // number of columns (z) used for lookup table
+  Int_t     fNR;                   ///< number of rows (r) used for lookup table
+  Int_t     fNPhi;                 ///< number of phi slices used for lookup table
+  Int_t     fNZ;                   ///< number of columns (z) used for lookup table
+
+  Float_t   fCorrScaleFactor;      ///< overall scaling factor for the correction
 
-  Float_t   fCorrScaleFactor;      // overall scaling factor for the correction
-  
-  Bool_t    fFillCorrection;       // whether to also fill the correction tables
+  Bool_t    fFillCorrection;       ///< whether to also fill the correction tables
   //
-  TVectorD  fLimitsR;              // bin limits in row direction
-  TVectorD  fLimitsPhi;            // bin limits in phi direction
-  TVectorD  fLimitsZ;              // bin limits in z direction
+  TVectorD  fLimitsR;              ///< bin limits in row direction
+  TVectorD  fLimitsPhi;            ///< bin limits in phi direction
+  TVectorD  fLimitsZ;              ///< bin limits in z direction
   // for distortion
-  TMatrixF **fLookUpDxDist;        //[fNPhi] Array to store electric field integral (int Er/Ez)
-  TMatrixF **fLookUpDyDist;        //[fNPhi] Array to store electric field integral (int Er/Ez)
-  TMatrixF **fLookUpDzDist;        //[fNPhi] Array to store electric field integral (int Er/Ez)
+  /// Array to store electric field integral (int Er/Ez)
+  TMatrixF **fLookUpDxDist;        //[fNPhi]
+  /// Array to store electric field integral (int Er/Ez)
+  TMatrixF **fLookUpDyDist;        //[fNPhi]
+  /// Array to store electric field integral (int Er/Ez)
+  TMatrixF **fLookUpDzDist;        //[fNPhi]
 
   // for correction
-  TMatrixF **fLookUpDxCorr;        //[fNPhi] Array to store electric field integral (int Er/Ez)
-  TMatrixF **fLookUpDyCorr;        //[fNPhi] Array to store electric field integral (int Er/Ez)
-  TMatrixF **fLookUpDzCorr;        //[fNPhi] Array to store electric field integral (int Er/Ez)
+  /// Array to store electric field integral (int Er/Ez)
+  TMatrixF **fLookUpDxCorr;        //[fNPhi]
+  /// Array to store electric field integral (int Er/Ez)
+  TMatrixF **fLookUpDyCorr;        //[fNPhi]
+  /// Array to store electric field integral (int Er/Ez)
+  TMatrixF **fLookUpDzCorr;        //[fNPhi]
 
   void InitTables();
   void InitTableArrays();
   void InitTablesPhiBin(Int_t iPhi);
-  
+
   void ResetTables();
   void ResetLimits();
-  
+
   void GetInterpolation(const Float_t x[],const Short_t roc,Float_t dx[],
                         TMatrixF **mR, TMatrixF **mPhi, TMatrixF **mZ);
 
@@ -85,8 +91,10 @@ private:
                            const Float_t xref[3], Float_t xret[3]);
   AliTPCCorrectionLookupTable(const AliTPCCorrectionLookupTable &corr);
   AliTPCCorrectionLookupTable& operator= (const AliTPCCorrectionLookupTable &corr);
-  
+
+  /// \cond CLASSIMP
   ClassDef(AliTPCCorrectionLookupTable,3);  // TPC corrections dumped into a lookup table
+  /// \endcond
 };
 
 
diff --git a/TPC/TPCbase/AliTPCDigitsArray.cxx b/TPC/TPCbase/AliTPCDigitsArray.cxx
index 88513d455ad..816243bc931 100644
--- a/TPC/TPCbase/AliTPCDigitsArray.cxx
+++ b/TPC/TPCbase/AliTPCDigitsArray.cxx
@@ -15,25 +15,21 @@
 
 /* $Id$ */
 
-///////////////////////////////////////////////////////////////////////////////
-//                                                                           //
-//  Time Projection Chamber clusters objects                                //
-//
-//  Origin: Marian Ivanov , GSI Darmstadt
-//                                                                           //
-//                                                                           //
-//                                                                          //
-///////////////////////////////////////////////////////////////////////////////
-#include "AliTPCParam.h" 
+/// \class AliTPCDigitsArray
+/// \brief Time Projection Chamber clusters objects
+///
+/// \author Marian Ivanov , GSI Darmstadt
+
+#include "AliTPCParam.h"
 #include "AliTPCPRF2D.h"
 
 #include "TObjArray.h"
-#include "AliSegmentID.h" 
-#include "AliSegmentArray.h" 
+#include "AliSegmentID.h"
+#include "AliSegmentArray.h"
 
 #include "AliDigits.h"
 #include "AliSimDigits.h"
-#include "AliDigitsArray.h" 
+#include "AliDigitsArray.h"
 #include "AliTPCDigitsArray.h"
 #include <TDirectory.h>
 
@@ -41,7 +37,9 @@
 
 //_____________________________________________________________________________
 
-ClassImp(AliTPCDigitsArray) 
+/// \cond CLASSIMP
+ClassImp(AliTPCDigitsArray)
+/// \endcond
 
 AliTPCDigitsArray::AliTPCDigitsArray(Bool_t sim)
                   :AliDigitsArray(),
@@ -58,32 +56,32 @@ AliTPCDigitsArray::AliTPCDigitsArray(Bool_t sim)
     SetClass("AliDigits");
   fParam = 0;
   //  fPRF   = 0;
-  //fRF    = 0;  
+  //fRF    = 0;
   fCompression = 1;
   fTrackLevel = 3;
 }
 
 AliTPCDigitsArray::~AliTPCDigitsArray()
 {
-  //
-  
+  ///
+
   //
 }
 
 AliDigits *  AliTPCDigitsArray::CreateRow(Int_t sector, Int_t row)
 {
-  //
-  //create digits row  
-  //
-  //if row just exist - delete it
+  /// create digits row
+  ///
+  /// if row just exist - delete it
+
   AliTPCParam * param = (AliTPCParam*)fParam;
-  Int_t index = param->GetIndex(sector,row);  
+  Int_t index = param->GetIndex(sector,row);
   AliDigits * dig = (AliDigits *)(*this)[index];
   if (dig !=0) delete dig;
 
   dig = (AliDigits *) AddSegment(index);
   if (dig == 0) return 0;
-  dig->Allocate(param->GetMaxTBin(),param->GetNPads(sector,row));  
+  dig->Allocate(param->GetMaxTBin(),param->GetNPads(sector,row));
   if (fBSim == kTRUE) ((AliSimDigits*) dig)->AllocateTrack(fTrackLevel);
   return dig;
 }
@@ -91,32 +89,29 @@ AliDigits *  AliTPCDigitsArray::CreateRow(Int_t sector, Int_t row)
 
 AliDigits * AliTPCDigitsArray::GetRow(Int_t sector,Int_t row)
 {
-  //
-  //return clusters ((AliTPCDigitsRow *) per given sector and padrow
-  //
+  /// return clusters ((AliTPCDigitsRow *) per given sector and padrow
+
   if (fParam==0) return 0;
-  Int_t index = ((AliTPCParam*)fParam)->GetIndex(sector,row);  
+  Int_t index = ((AliTPCParam*)fParam)->GetIndex(sector,row);
   return (AliDigits *)(*this)[index];
 }
 
 AliDigits * AliTPCDigitsArray::LoadRow(Int_t sector,Int_t row)
 {
-  //
-  //return clusters ((AliTPCDigitsRow *) per given sector and padrow
-  //
+  /// return clusters ((AliTPCDigitsRow *) per given sector and padrow
+
   if (fParam==0) return 0;
-  Int_t index = ((AliTPCParam*)fParam)->GetIndex(sector,row);  
+  Int_t index = ((AliTPCParam*)fParam)->GetIndex(sector,row);
   return (AliDigits *)LoadSegment(index);
 }
 
 Bool_t  AliTPCDigitsArray::StoreRow(Int_t sector,Int_t row)
 {
-  //
-  //return clusters ((AliTPCDigitsRow *) per given sector and padrow
-  //
+  /// return clusters ((AliTPCDigitsRow *) per given sector and padrow
+
   AliTPCParam * param = (AliTPCParam*)fParam;
   if (fParam==0) return 0;
-  Int_t index = param->GetIndex(sector,row);  
+  Int_t index = param->GetIndex(sector,row);
   ( (AliDigits *)At(index))->CompresBuffer(fCompression,param->GetZeroSup());
   if (fBSim == kTRUE) ( (AliSimDigits *)At(index))->CompresTrackBuffer(1);
   StoreSegment(index);
@@ -125,11 +120,10 @@ Bool_t  AliTPCDigitsArray::StoreRow(Int_t sector,Int_t row)
 
 Bool_t  AliTPCDigitsArray::ClearRow(Int_t sector,Int_t row)
 {
-  //
-  //return clusters ((AliTPCDigitsRow *) per given sector and padrow
-  //
+  /// return clusters ((AliTPCDigitsRow *) per given sector and padrow
+
   if (fParam==0) return 0;
-  Int_t index = ((AliTPCParam*)fParam)->GetIndex(sector,row);  
+  Int_t index = ((AliTPCParam*)fParam)->GetIndex(sector,row);
   ClearSegment(index);
   return kTRUE;
 }
@@ -138,9 +132,8 @@ Bool_t  AliTPCDigitsArray::ClearRow(Int_t sector,Int_t row)
 
 Bool_t AliTPCDigitsArray::Setup(AliDetectorParam *param)
 {
-  //
-  //setup  function to adjust array parameters
-  //
+  /// setup  function to adjust array parameters
+
   if (param==0) return kFALSE;
   if (fParam !=0) delete fParam;
   //  fParam = new AliTPCParam((AliTPCParam&)(*param));
@@ -150,9 +143,8 @@ Bool_t AliTPCDigitsArray::Setup(AliDetectorParam *param)
 
 Bool_t AliTPCDigitsArray::Update()
 {
-  //
-  //setup  function to adjust array parameters
-  //
+  /// setup  function to adjust array parameters
+
   if (fParam ==0 ) return kFALSE;
   if (fTree!=0) return MakeDictionary( ((AliTPCParam*)fParam)->GetNRowsTotal()) ;
   ((AliTPCParam*)fParam)->Update();
diff --git a/TPC/TPCbase/AliTPCDigitsArray.h b/TPC/TPCbase/AliTPCDigitsArray.h
index e9a36d0e80f..e69f192c055 100644
--- a/TPC/TPCbase/AliTPCDigitsArray.h
+++ b/TPC/TPCbase/AliTPCDigitsArray.h
@@ -5,14 +5,13 @@
 
 /* $Id$ */
 
-////////////////////////////////////////////////
-//  Manager class for TPC digits                   //
-////////////////////////////////////////////////
+/// \class AliTPCDigitsArray
+/// \brief Manager class for TPC digits
 
 
-#include "AliDigits.h" 
+#include "AliDigits.h"
 #include "AliDigitsArray.h"
-#include "AliTPCParam.h" 
+#include "AliTPCParam.h"
 
 class AliDigits;
 class AliDetectorParam;
@@ -26,15 +25,17 @@ public:
   AliDigits *  LoadRow(Int_t sector,Int_t row);
   Bool_t StoreRow(Int_t sector,Int_t row);
   Bool_t ClearRow(Int_t sector,Int_t row);
-  Bool_t Setup(AliDetectorParam *param);  
-  
+  Bool_t Setup(AliDetectorParam *param);
+
   Bool_t IsSimulated(){return fBSim;}
-  Bool_t  Update(); 
-private:  
-  Bool_t fBSim;             //signalize if we have digits with track ID
-  Int_t  fCompression;      //default compression for AliDigits - used in storing
-  Int_t  fTrackLevel;        //default level for track ID storing
+  Bool_t  Update();
+private:
+  Bool_t fBSim;             ///< signalize if we have digits with track ID
+  Int_t  fCompression;      ///< default compression for AliDigits - used in storing
+  Int_t  fTrackLevel;        ///< default level for track ID storing
+  /// \cond CLASSIMP
   ClassDef(AliTPCDigitsArray,1) // TPC digits manager
+  /// \endcond
 };
-  
+
 #endif //ALITPCCLUSTERSARRAY_H
diff --git a/TPC/TPCbase/AliTPCExB.cxx b/TPC/TPCbase/AliTPCExB.cxx
index 573f47cd2ac..d4df42850c0 100644
--- a/TPC/TPCbase/AliTPCExB.cxx
+++ b/TPC/TPCbase/AliTPCExB.cxx
@@ -6,31 +6,24 @@
 #include "AliTPCcalibDB.h"
 
 
-//
-// Abstract class for ExB effect parameterization
-// 
-//
-// 
-// The ExB correction map is stored in the calib DB
-// The lookup can be dumped to the tree:
-/*
-
-   //
-  char *storage = "local://OCDBres"
-  Int_t RunNumber=0;
-  AliCDBManager::Instance()->SetDefaultStorage(storage);
-  AliCDBManager::Instance()->SetRun(RunNumber) 
-  AliTPCExBFirst * exb = AliTPCcalibDB::Instance()->GetExB();
-  //
-  // See example macro $ALICE_ROOT/TPC/macros/AliTPCExBdraw.C 
-  //
-  .L $ALICE_ROOT/TPC/macros/AliTPCExBdraw.C 
-  Draw(0)
-
-
-
-
-*/
+/// \class AliTPCExB
+/// \brief Abstract class for ExB effect parameterization
+///
+/// The ExB correction map is stored in the calib DB
+/// The lookup can be dumped to the tree:
+///
+/// ~~~{.cxx}
+/// char *storage = "local://OCDBres"
+/// Int_t RunNumber=0;
+/// AliCDBManager::Instance()->SetDefaultStorage(storage);
+/// AliCDBManager::Instance()->SetRun(RunNumber)
+/// AliTPCExBFirst * exb = AliTPCcalibDB::Instance()->GetExB();
+///
+/// // See example macro $ALICE_ROOT/TPC/macros/AliTPCExBdraw.C
+///
+/// .L $ALICE_ROOT/TPC/macros/AliTPCExBdraw.C
+/// Draw(0)
+/// ~~~
 
 AliTPCExB* AliTPCExB::fgInstance = 0;
 
@@ -38,15 +31,17 @@ TObjArray   AliTPCExB::fgArray;
 
 
 
+/// \cond CLASSIMP
 ClassImp(AliTPCExB)
+/// \endcond
 
 AliTPCExB::AliTPCExB():
   TObject(),
   fMatBrBz(0),       //param matrix Br/Bz
   fMatBrfiBz(0),     //param matrix Br/Bz
-  fMatBrBzI0(0),     //param matrix Br/Bz integral  z>0 
-  fMatBrBzI1(0),     //param matrix Br/Bz integral  z<0 
-  fMatBrfiBzI0(0),   //param matrix Br/Bz integral  z>0 
+  fMatBrBzI0(0),     //param matrix Br/Bz integral  z>0
+  fMatBrBzI1(0),     //param matrix Br/Bz integral  z<0
+  fMatBrfiBzI0(0),   //param matrix Br/Bz integral  z>0
   fMatBrfiBzI1(0)    //param matrix Br/Bz integral  z<0
 {
   //
@@ -58,21 +53,19 @@ AliTPCExB::AliTPCExB(const AliTPCExB& exb):
   TObject(exb),
   fMatBrBz(new TVectorD(*(exb.fMatBrBz))),       //param matrix Br/Bz
   fMatBrfiBz(new TVectorD(*(exb.fMatBrfiBz))),     //param matrix Br/Bz
-  fMatBrBzI0(new TVectorD(*(exb.fMatBrBzI0))),     //param matrix Br/Bz integral  z>0 
-  fMatBrBzI1(new TVectorD(*(exb.fMatBrBzI1))),     //param matrix Br/Bz integral  z<0 
-  fMatBrfiBzI0(new TVectorD(*(exb.fMatBrfiBzI0))),   //param matrix Br/Bz integral  z>0 
+  fMatBrBzI0(new TVectorD(*(exb.fMatBrBzI0))),     //param matrix Br/Bz integral  z>0
+  fMatBrBzI1(new TVectorD(*(exb.fMatBrBzI1))),     //param matrix Br/Bz integral  z<0
+  fMatBrfiBzI0(new TVectorD(*(exb.fMatBrfiBzI0))),   //param matrix Br/Bz integral  z>0
   fMatBrfiBzI1(new TVectorD(*(exb.fMatBrfiBzI1)))    //param matrix Br/Bz integral  z<0
 {
-  //
-  // copy constructor
-  //
+  /// copy constructor
+
 }
 
 AliTPCExB& AliTPCExB::operator=(const AliTPCExB &/*exb*/)
 {
-  //
-  // Dummy  assignment
-  //
+  /// Dummy  assignment
+
   return *this;
 }
 
@@ -80,11 +73,9 @@ AliTPCExB& AliTPCExB::operator=(const AliTPCExB &/*exb*/)
 
 
 void AliTPCExB::TestExB(const char* fileName) {
-  //
-  // Test ExB  - 
-  // Dump the filed and corrections to the tree in file fileName  
-  //
-  // 
+  /// Test ExB  -
+  /// Dump the filed and corrections to the tree in file fileName
+
   TTreeSRedirector ts(fileName);
   Double_t x[3];
   for (x[0]=-250.;x[0]<=250.;x[0]+=10.)
@@ -152,11 +143,9 @@ void AliTPCExB::TestExB(const char* fileName) {
 
 
 Double_t AliTPCExB::GetDr(Double_t r, Double_t phi, Double_t z, Double_t bz){
-  //
-  // Static function
-  // Posibble to us it for visualization 
-  // 
-  //
+  /// Static function
+  /// Posibble to us it for visualization
+
   AliTPCExB *exb = Instance();
   if (!exb) exb = AliTPCcalibDB::GetExB(bz,kFALSE);
   if (!exb) return 0;
@@ -166,16 +155,15 @@ Double_t AliTPCExB::GetDr(Double_t r, Double_t phi, Double_t z, Double_t bz){
   Double_t dx=pos1[0]-pos0[0];
   Double_t dy=pos1[1]-pos0[1];
   //  Double_t dz=pos1[2]-pos0[2];
-  // return TMath::Sqrt(dx*dx+dy*dy);  
+  // return TMath::Sqrt(dx*dx+dy*dy);
   Float_t dr = (dx*pos0[0]+dy*pos0[1])/r;
   return dr;
 }
 
 
 Double_t AliTPCExB::GetDrphi(Double_t r, Double_t phi, Double_t z, Double_t bz){
-  //
-  //
-  //
+  ///
+
   AliTPCExB *exb = Instance();
   if (!exb) exb = AliTPCcalibDB::GetExB(bz,kFALSE);
   if (!exb) return 0;
@@ -185,15 +173,14 @@ Double_t AliTPCExB::GetDrphi(Double_t r, Double_t phi, Double_t z, Double_t bz){
   Double_t dphi=TMath::ATan2(pos1[1],pos1[0])-TMath::ATan2(pos0[1],pos0[0]);
   if (dphi>TMath::Pi()) dphi-=TMath::TwoPi();
   if (dphi<-TMath::Pi()) dphi+=TMath::TwoPi();
-  return r*dphi;  
+  return r*dphi;
 
 }
 
 
 Double_t AliTPCExB::GetDphi(Double_t r, Double_t phi, Double_t z, Double_t bz){
-  //
-  //
-  // 
+  ///
+
   AliTPCExB *exb = Instance();
   if (!exb) exb = AliTPCcalibDB::GetExB(bz,kFALSE);
   if (!exb) return 0;
@@ -201,14 +188,13 @@ Double_t AliTPCExB::GetDphi(Double_t r, Double_t phi, Double_t z, Double_t bz){
   Double_t pos1[3];
   exb->Correct(pos0,pos1);
   Double_t dphi=TMath::ATan2(pos1[1],pos1[0])-TMath::ATan2(pos0[1],pos0[0]);
-  return dphi;  
+  return dphi;
 
 }
 
 Double_t AliTPCExB::GetDz(Double_t r, Double_t phi, Double_t z, Double_t bz){
-  //
-  //
-  //
+  ///
+
   AliTPCExB *exb = Instance();
   if (!exb) exb = AliTPCcalibDB::GetExB(bz,kFALSE);
   if (!exb) return 0;
@@ -216,7 +202,7 @@ Double_t AliTPCExB::GetDz(Double_t r, Double_t phi, Double_t z, Double_t bz){
   Double_t pos1[3];
   exb->Correct(pos0,pos1);
   Double_t dz=pos1[2]-pos0[2];
-  return dz;  
+  return dz;
 }
 
 //
@@ -227,18 +213,16 @@ Double_t AliTPCExB::GetDz(Double_t r, Double_t phi, Double_t z, Double_t bz){
 
 
 void AliTPCExB::RegisterField(Int_t index, AliMagF * magf){
-  //
-  // add the filed to the list
-  //
+  /// add the filed to the list
+
   fgArray.AddAt(magf,index);
 }
 
 
 
 Double_t AliTPCExB::GetBx(Double_t r, Double_t phi, Double_t z,Int_t index){
-  //
-  // 
-  //
+  ///
+
   AliMagF *mag = (AliMagF*)fgArray.At(index);
   if (!mag) return 0;
   Double_t xyz[3]={r*TMath::Cos(phi),r*TMath::Sin(phi),z};
@@ -246,12 +230,11 @@ Double_t AliTPCExB::GetBx(Double_t r, Double_t phi, Double_t z,Int_t index){
   Double_t bxyz[3];
   mag->Field(xyz,bxyz);
   return bxyz[0];
-}  
+}
 
 Double_t AliTPCExB::GetBy(Double_t r, Double_t phi, Double_t z,Int_t index){
-  //
-  // 
-  //
+  ///
+
   AliMagF *mag = (AliMagF*)fgArray.At(index);
   if (!mag) return 0;
   Double_t xyz[3]={r*TMath::Cos(phi),r*TMath::Sin(phi),z};
@@ -259,12 +242,11 @@ Double_t AliTPCExB::GetBy(Double_t r, Double_t phi, Double_t z,Int_t index){
   Double_t bxyz[3];
   mag->Field(xyz,bxyz);
   return bxyz[1];
-}  
+}
 
 Double_t AliTPCExB::GetBz(Double_t r, Double_t phi, Double_t z,Int_t index){
-  //
-  // 
-  //
+  ///
+
   AliMagF *mag = (AliMagF*)fgArray.At(index);
   if (!mag) return 0;
   Double_t xyz[3]={r*TMath::Cos(phi),r*TMath::Sin(phi),z};
@@ -272,14 +254,13 @@ Double_t AliTPCExB::GetBz(Double_t r, Double_t phi, Double_t z,Int_t index){
   Double_t bxyz[3];
   mag->Field(xyz,bxyz);
   return bxyz[2];
-}  
+}
 
 
 
 Double_t AliTPCExB::GetBr(Double_t r, Double_t phi, Double_t z,Int_t index){
-  //
-  // 
-  //
+  ///
+
   AliMagF *mag = (AliMagF*)fgArray.At(index);
   if (!mag) return 0;
   Double_t xyz[3]={r*TMath::Cos(phi),r*TMath::Sin(phi),z};
@@ -289,12 +270,11 @@ Double_t AliTPCExB::GetBr(Double_t r, Double_t phi, Double_t z,Int_t index){
   if (r==0) return 0;
   Double_t br = (bxyz[0]*xyz[0]+bxyz[1]*xyz[1])/r;
   return br;
-}  
+}
 
 Double_t AliTPCExB::GetBrfi(Double_t r, Double_t phi, Double_t z,Int_t index){
-  //
-  // 
-  //
+  ///
+
   AliMagF *mag = (AliMagF*)fgArray.At(index);
   if (!mag) return 0;
   Double_t xyz[3]={r*TMath::Cos(phi),r*TMath::Sin(phi),z};
@@ -304,7 +284,7 @@ Double_t AliTPCExB::GetBrfi(Double_t r, Double_t phi, Double_t z,Int_t index){
   if (r==0) return 0;
   Double_t br = (-bxyz[0]*xyz[1]+bxyz[1]*xyz[0])/r;
   return br;
-}  
+}
 
 
 
@@ -392,15 +372,15 @@ Double_t AliTPCExB::GetBrfiI(Double_t r, Double_t phi, Double_t z,Int_t index)
 
 
 Double_t AliTPCExB::Eval(Int_t type, Double_t r, Double_t phi, Double_t z){
-  //
-  // Evaluate parameterization
-  //
-  // br integral param 
+  /// Evaluate parameterization
+  ///
+  /// br integral param
+
   if (type==0) {
     if (z>0 && fMatBrBzI0) return EvalMat(*fMatBrBzI0,r,phi,z);
     if (z<0 && fMatBrBzI1) return EvalMat(*fMatBrBzI1,r,phi,z);
   }
-  // brfi integral param   
+  // brfi integral param
   if (type==1) {
     if (z>0 && fMatBrfiBzI0) return EvalMat(*fMatBrfiBzI0,r,phi,z);
     if (z<0 && fMatBrfiBzI1) return EvalMat(*fMatBrfiBzI1,r,phi,z);
@@ -414,38 +394,38 @@ Double_t AliTPCExB::Eval(Int_t type, Double_t r, Double_t phi, Double_t z){
 
 
 Double_t AliTPCExB::EvalMat(const TVectorD &vec, Double_t r, Double_t phi, Double_t z){
-  //
-  // Evaluate taylor expansion in r,phi,z
-  //
-  // Variables  
-  //tree->SetAlias("sa","sin(phi+0.0)");
-  //tree->SetAlias("ca","cos(phi+0.0)");
-  //tree->SetAlias("sa2","sin(phi*2+0.0)");
-  //tree->SetAlias("ca2","cos(phi*2+0.0)");
-  //tree->SetAlias("zn","(x2/250.)");
-  //tree->SetAlias("rn","(r/250.)")
-  //   TString fstringSym="";
-  //   //  
-  //   fstringSym+="zn++";
-  //   fstringSym+="rn++";
-  //   fstringSym+="zn*rn++";
-  //   fstringSym+="zn*zn++";
-  //   fstringSym+="zn*zn*rn++";
-  //   fstringSym+="zn*rn*rn++";
-  //   //
-  //   fstringSym+="sa++";
-  //   fstringSym+="ca++";  
-  //   fstringSym+="ca2++";
-  //   fstringSym+="sa2++";
-  //   fstringSym+="ca*zn++";
-  //   fstringSym+="sa*zn++";
-  //   fstringSym+="ca2*zn++";
-  //   fstringSym+="sa2*zn++";
-  //   fstringSym+="ca*zn*zn++";
-  //   fstringSym+="sa*zn*zn++";
-  //   fstringSym+="ca*zn*rn++";
-  //   fstringSym+="sa*zn*rn++";
-
+  /// Evaluate taylor expansion in r,phi,z
+  ///
+  /// Variables:
+  /// ~~~
+  /// tree->SetAlias("sa","sin(phi+0.0)");
+  /// tree->SetAlias("ca","cos(phi+0.0)");
+  /// tree->SetAlias("sa2","sin(phi*2+0.0)");
+  /// tree->SetAlias("ca2","cos(phi*2+0.0)");
+  /// tree->SetAlias("zn","(x2/250.)");
+  /// tree->SetAlias("rn","(r/250.)")
+  /// TString fstringSym="";
+  ///
+  /// fstringSym+="zn++";
+  /// fstringSym+="rn++";
+  /// fstringSym+="zn*rn++";
+  /// fstringSym+="zn*zn++";
+  /// fstringSym+="zn*zn*rn++";
+  /// fstringSym+="zn*rn*rn++";
+  ///
+  /// fstringSym+="sa++";
+  /// fstringSym+="ca++";
+  /// fstringSym+="ca2++";
+  /// fstringSym+="sa2++";
+  /// fstringSym+="ca*zn++";
+  /// fstringSym+="sa*zn++";
+  /// fstringSym+="ca2*zn++";
+  /// fstringSym+="sa2*zn++";
+  /// fstringSym+="ca*zn*zn++";
+  /// fstringSym+="sa*zn*zn++";
+  /// fstringSym+="ca*zn*rn++";
+  /// fstringSym+="sa*zn*rn++";
+  /// ~~~
 
   Double_t sa  = TMath::Sin(phi);
   Double_t ca  = TMath::Cos(phi);
@@ -463,7 +443,7 @@ Double_t AliTPCExB::EvalMat(const TVectorD &vec, Double_t r, Double_t phi, Doubl
   res+=vec[ipoint++]*zn*rn*rn;
   //
   res+=vec[ipoint++]*sa;
-  res+=vec[ipoint++]*ca;  
+  res+=vec[ipoint++]*ca;
   res+=vec[ipoint++]*ca2;
   res+=vec[ipoint++]*sa2;
   res+=vec[ipoint++]*ca*zn;
@@ -491,14 +471,14 @@ Double_t AliTPCExB::EvalMat(const TVectorD &vec, Double_t r, Double_t phi, Doubl
 
 
 /*
-  
+
  AliTPCExB draw;
  draw.RegisterField(0,new AliMagWrapCheb("Maps","Maps", 2, 1., 10., AliMagWrapCheb::k5kG));
  draw.RegisterField(1,new AliMagFMaps("Maps","Maps", 2, 1., 10., 2));
 
  TF2 fbz_rz_0pi("fbz_rz_0pi","AliTPCExB::GetBz(x,0*pi,y)",0,250,-250,250);
  fbz_rz_0pi->Draw("surf2");
- 
+
  TF1 fbz_z_90_00pi("fbz_z_90_00pi","AliTPCExB::GetBz(90,0*pi,x)",-250,250);
   TF1 fbz_z_90_05pi("fbz_z_90_05pi","AliTPCExB::GetBz(90,0.5*pi,x)",-250,250);
   TF1 fbz_z_90_10pi("fbz_z_90_10pi","AliTPCExB::GetBz(90,1.0*pi,x)",-250,250);
@@ -511,7 +491,7 @@ Double_t AliTPCExB::EvalMat(const TVectorD &vec, Double_t r, Double_t phi, Doubl
   fbz_z_90_05pi->Draw("same")
   fbz_z_90_15pi->Draw("same")
   fbz_z_90_10pi->Draw("same")
-  
+
 
   TF1 fbr_z_90_00pi("fbz_z_90_00pi","AliTPCExB::GetBr(90,0*pi,x)",-250,250);
   TF1 fbr_z_90_05pi("fbz_z_90_05pi","AliTPCExB::GetBr(90,0.5*pi,x)",-250,250);
diff --git a/TPC/TPCbase/AliTPCExB.h b/TPC/TPCbase/AliTPCExB.h
index 9e23a5d9a52..abb61819ae8 100644
--- a/TPC/TPCbase/AliTPCExB.h
+++ b/TPC/TPCbase/AliTPCExB.h
@@ -1,3 +1,5 @@
+/// \class AliTPCExB
+
 #ifndef ALITPCEXB_H
 #define ALITPCEXB_H
 
@@ -47,19 +49,21 @@ public:
   Double_t Eval(Int_t type, Double_t r, Double_t phi, Double_t z);
   Double_t SEval(Int_t type, Double_t r, Double_t phi, Double_t z){return Instance()->Eval(type,r,phi,z);}
   static Double_t EvalMat(const TVectorD &vec, Double_t r, Double_t phi, Double_t z);     // evalute parameterization
- 
+
  private:
-  TVectorD *          fMatBrBz;       //param matrix Br/Bz
-  TVectorD *          fMatBrfiBz;     //param matrix Br/Bz
-  TVectorD *          fMatBrBzI0;     //param matrix Br/Bz integral  z>0 
-  TVectorD *          fMatBrBzI1;     //param matrix Br/Bz integral  z<0 
-  TVectorD *          fMatBrfiBzI0;   //param matrix Br/Bz integral  z>0 
-  TVectorD *          fMatBrfiBzI1;   //param matrix Br/Bz integral  z<0
-  
-  static AliTPCExB*   fgInstance;  //! Instance of this class (singleton implementation)
-  static TObjArray    fgArray;     //! array of magnetic fields
+  TVectorD *          fMatBrBz;       ///< param matrix Br/Bz
+  TVectorD *          fMatBrfiBz;     ///< param matrix Br/Bz
+  TVectorD *          fMatBrBzI0;     ///< param matrix Br/Bz integral  z>0
+  TVectorD *          fMatBrBzI1;     ///< param matrix Br/Bz integral  z<0
+  TVectorD *          fMatBrfiBzI0;   ///< param matrix Br/Bz integral  z>0
+  TVectorD *          fMatBrfiBzI1;   ///< param matrix Br/Bz integral  z<0
+
+  static AliTPCExB*   fgInstance;  //!< Instance of this class (singleton implementation)
+  static TObjArray    fgArray;     //!< array of magnetic fields
   //
+  /// \cond CLASSIMP
   ClassDef(AliTPCExB,2)
+  /// \endcond
 };
 
 #endif
diff --git a/TPC/TPCbase/AliTPCExBBShape.cxx b/TPC/TPCbase/AliTPCExBBShape.cxx
index bf1dafafd88..074cc55524f 100644
--- a/TPC/TPCbase/AliTPCExBBShape.cxx
+++ b/TPC/TPCbase/AliTPCExBBShape.cxx
@@ -13,9 +13,8 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-////////////////////////////////////////////////////////////////////////////
-// AliTPCExBBShape class                                                  //
-////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCExBBShape
+/// \brief AliTPCExBBShape class
 
 #include <AliMagF.h>
 #include "TGeoGlobalMagField.h"
@@ -31,30 +30,28 @@ AliTPCExBBShape::AliTPCExBBShape()
     fScaling(1.),
     fBField(0)
 {
-  //
-  // default constructor
-  //
+  /// default constructor
+
 }
 
 AliTPCExBBShape::~AliTPCExBBShape() {
-  //
-  // virtual destructor
-  //
+  /// virtual destructor
+
 }
 
 
 
 
 Bool_t AliTPCExBBShape::AddCorrectionCompact(AliTPCCorrection* corr, Double_t weight){
-  //
-  // Add correction  and make them compact
-  // Assumptions:
-  //  - origin of distortion/correction are additive
-  //  - only correction ot the same type supported ()
+  /// Add correction  and make them compact
+  /// Assumptions:
+  ///  - origin of distortion/correction are additive
+  ///  - only correction ot the same type supported ()
+
   if (corr==NULL) {
-    AliError("Zerro pointer - correction"); 
+    AliError("Zerro pointer - correction");
     return kFALSE;
-  }  
+  }
   AliTPCExBBShape* corrC = dynamic_cast<AliTPCExBBShape *>(corr);
   if (corrC == NULL) {
     AliError(TString::Format("Inconsistent class types: %s\%s",IsA()->GetName(),corr->IsA()->GetName()).Data());
@@ -67,10 +64,8 @@ Bool_t AliTPCExBBShape::AddCorrectionCompact(AliTPCCorrection* corr, Double_t we
 
 
 void AliTPCExBBShape::Init() {
-  //
-  // Initialization funtion
-  //
-  
+  /// Initialization funtion
+
   AliMagF* magF= (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
   if (!magF) AliError("Magneticd field - not initialized");
   Double_t bzField = magF->SolenoidField()/10.; //field in T
@@ -79,7 +74,7 @@ void AliTPCExBBShape::Init() {
   if (!param) AliError("Parameters - not initialized");
   Double_t vdrift = param->GetDriftV()/1000000.; // [cm/us]   // From dataBase: to be updated: per second (ideally)
   Double_t ezField = 400; // [V/cm]   // to be updated: never (hopefully)
-  Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ; 
+  Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ;
   // Correction Terms for effective omegaTau; obtained by a laser calibration run
   SetOmegaTauT1T2(wt,fT1,fT2);
 
@@ -87,9 +82,8 @@ void AliTPCExBBShape::Init() {
 }
 
 void AliTPCExBBShape::Update(const TTimeStamp &/*timeStamp*/) {
-  //
-  // Update function 
-  //
+  /// Update function
+
   AliMagF* magF= (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
   if (!magF) AliError("Magneticd field - not initialized");
   Double_t bzField = magF->SolenoidField()/10.; //field in T
@@ -98,7 +92,7 @@ void AliTPCExBBShape::Update(const TTimeStamp &/*timeStamp*/) {
   if (!param) AliError("Parameters - not initialized");
   Double_t vdrift = param->GetDriftV()/1000000.; // [cm/us]   // From dataBase: to be updated: per second (ideally)
   Double_t ezField = 400; // [V/cm]   // to be updated: never (hopefully)
-  Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ; 
+  Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ;
   // Correction Terms for effective omegaTau; obtained by a laser calibration run
   SetOmegaTauT1T2(wt,fT1,fT2);
 
@@ -108,9 +102,7 @@ void AliTPCExBBShape::Update(const TTimeStamp &/*timeStamp*/) {
 
 
 void AliTPCExBBShape::GetCorrection(const Float_t x[],const Short_t roc,Float_t dx[]) {
-  //
-  // Calculates the space point corrections of the B field inperfections (B field shape) 
-  //
+  /// Calculates the space point corrections of the B field inperfections (B field shape)
 
   if (!fBField) {
     for (Int_t j=0;j<3;++j) dx[j]=0.;
@@ -128,7 +120,7 @@ void AliTPCExBBShape::GetCorrection(const Float_t x[],const Short_t roc,Float_t
 
   const Float_t intBxOverBz=fScaling*(intBEnd[0]-intBStart[0]);
   const Float_t intByOverBz=fScaling*(intBEnd[1]-intBStart[1]);
-  
+
   dx[0]=fC2*intBxOverBz-fC1*intByOverBz;
   dx[1]=fC1*intBxOverBz+fC2*intByOverBz;
   dx[2]=0.;
@@ -137,10 +129,8 @@ void AliTPCExBBShape::GetCorrection(const Float_t x[],const Short_t roc,Float_t
 }
 
 void AliTPCExBBShape::GetBxAndByOverBz(const Float_t x[],const Short_t roc,Float_t BxByOverBz[]) {
-  //
-  // This function is purely for calibration purposes
-  // Returns the via AliMagF obtaind B field integrals  
-  // 
+  /// This function is purely for calibration purposes
+  /// Returns the via AliMagF obtaind B field integrals
 
   if (!fBField) {
     for (Int_t j=0;j<3;++j) BxByOverBz[j]=0.;
@@ -158,32 +148,30 @@ void AliTPCExBBShape::GetBxAndByOverBz(const Float_t x[],const Short_t roc,Float
 
   const Float_t intBxOverBz=fScaling*(intBEnd[0]-intBStart[0]);
   const Float_t intByOverBz=fScaling*(intBEnd[1]-intBStart[1]);
-  
+
   BxByOverBz[0]=intBxOverBz;
   BxByOverBz[1]=intByOverBz;
 
 }
 
 void AliTPCExBBShape::Print(Option_t* option) const {
-  //
-  // Print function to check the settings (e.g. voltage offsets)
-  // option=="a" prints details of the B field settings and the 
-  // C0 and C1 coefficents (for calibration purposes)
-  //
+  /// Print function to check the settings (e.g. voltage offsets)
+  /// option=="a" prints details of the B field settings and the
+  /// C0 and C1 coefficents (for calibration purposes)
+
   TString opt = option; opt.ToLower();
   printf("%s\t%s\n - B field settings:\n",GetTitle(),GetName());
   fBField->Print(option);
   //  printf(" - B field: X-Twist: %1.5lf rad, Y-Twist: %1.5lf rad \n",fBField->Print(option));
-  if (opt.Contains("a")) { // Print all details  
+  if (opt.Contains("a")) { // Print all details
     printf(" - T1: %1.4f, T2: %1.4f \n",fT1,fT2);
     printf(" - C1: %1.4f, C2: %1.4f \n",fC1,fC2);
-  }    
+  }
 }
 
 Double_t AliTPCExBBShape::GetBFieldXYZ(Double_t gx, Double_t gy, Double_t gz, Int_t axisType){
-  //
-  // return B field at given x,y,z
-  // 
+  /// return B field at given x,y,z
+
   AliMagF* field = (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
   if (!field) return 0;
   Double_t xyz[3]={gx,gy,gz};
diff --git a/TPC/TPCbase/AliTPCExBBShape.h b/TPC/TPCbase/AliTPCExBBShape.h
index 2e3db4478fd..52ad1ee476e 100644
--- a/TPC/TPCbase/AliTPCExBBShape.h
+++ b/TPC/TPCbase/AliTPCExBBShape.h
@@ -4,35 +4,19 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-// _________________________________________________________________
-//
-// Begin_Html
-//   <h2>AliExBBShape class </h2>                                                    
-//   The class calculates the space point distortions due to the B field    
-//   shape imperfections using a second order technique based on integrals  
-//   over Bz (e.g. int By/Bz) obtained via the AliMagF class. The essential 
-//   input for this class is the magnetic field maps which can be set via the function SetBField.  
-//   <p>
-//   The class allows "effective Omega Tau" corrections.                    
-//   End_Html
-//   Begin_Macro(source)
-//   {
-//   gROOT->SetStyle("Plain"); gStyle->SetPalette(1);
-//   TCanvas *c2 = new TCanvas("cAliTPCExBBShape","cAliTPCExBBShape",500,300); 
-//   AliTPCExBBShape exb;                                                 
-//   AliMagF mag("mag","mag");        // 0.5 Tesla (solenoid)
-//   exb.SetBField(&mag);             // use Bfield from AliMagF        
-//   exb.SetOmegaTauT1T2(-0.32,1.,1.); // values ideally from OCDB     
-//   exb.CreateHistoDRPhiinZR(0,100,100)->Draw("surf2"); 
-//   return c2;
-//   } 
-// End_Macro
-// Begin_Html
-//   <p>
-//   Date: 27/04/2010 <br>                                                      
-//   Authors: Magnus Mager, Jim Thomas, Stefan Rossegger                    
-// End_Html 
-// _________________________________________________________________
+/// \class AliTPCExBBShape
+/// \brief AliExBBShape class
+///
+/// The class calculates the space point distortions due to the B field
+/// shape imperfections using a second order technique based on integrals
+/// over Bz (e.g. int By/Bz) obtained via the AliMagF class. The essential
+/// input for this class is the magnetic field maps which can be set via the function SetBField.
+///
+/// The class allows "effective Omega Tau" corrections.
+/// ![Picture from ROOT macro](AliTPCExBBShape_h_32a8c9f.png)
+///
+/// \author Magnus Mager, Jim Thomas, Stefan Rossegger
+/// \date 27/04/2010
 
 #include "AliTPCCorrection.h"
 
@@ -41,7 +25,7 @@ class AliMagF;
 class AliTPCExBBShape : public AliTPCCorrection {
 public:
   AliTPCExBBShape();
-  virtual ~AliTPCExBBShape();  
+  virtual ~AliTPCExBBShape();
   virtual Bool_t AddCorrectionCompact(AliTPCCorrection* corr, Double_t weight);
 
  // initialization and update functions
@@ -69,15 +53,17 @@ public:
   static Double_t GetBFieldXYZ(Double_t gx, Double_t gy, Double_t gz, Int_t axisType);
   Double_t GetScaling() const {return fScaling;}
 private:
-  Float_t fC1; // coefficient C1          (compare Jim Thomas's notes for definitions)
-  Float_t fC2; // coefficient C2          (compare Jim Thomas's notes for definitions)
-  Float_t fScaling; // scaling factor to rescale distortion    - for tests purposes only
-  AliMagF *fBField;       // pointer to magnetic field
+  Float_t fC1; ///< coefficient C1          (compare Jim Thomas's notes for definitions)
+  Float_t fC2; ///< coefficient C2          (compare Jim Thomas's notes for definitions)
+  Float_t fScaling; ///< scaling factor to rescale distortion    - for tests purposes only
+  AliMagF *fBField;       ///< pointer to magnetic field
 
   AliTPCExBBShape & operator =(const AliTPCExBBShape &); // dummy assignment operator
   AliTPCExBBShape(const AliTPCExBBShape&); //dummy copy contructor
 
+  /// \cond CLASSIMP
   ClassDef(AliTPCExBBShape,2);
+  /// \endcond
 };
 
 #endif
diff --git a/TPC/TPCbase/AliTPCExBEffective.cxx b/TPC/TPCbase/AliTPCExBEffective.cxx
index 13b217bb001..b457318abdc 100644
--- a/TPC/TPCbase/AliTPCExBEffective.cxx
+++ b/TPC/TPCbase/AliTPCExBEffective.cxx
@@ -13,25 +13,22 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-////////////////////////////////////////////////////////////////////////////
-//                                                                        //
-// AliTPCExBEffective class                                                   //
-// Correct for the rest of ExB effect which are not covered by physical models
-//
-// Motivation:
-//   ExB correction: 
-//      dr    =  c0* integral(Er/Ez) + c1* integral(Erphi/Ez)
-//      drphi = -c1* integral(Er/Ez) + c0* integral(Erphi/Ez)
-//   Where:      
-//   wt = Bz*(k*vdrift/E)           ~ 0.3 at B=0.5 T 
-//   c0 = 1/(1+T2*T2*wt*wt) 
-//   c1 = T1*wt/(1+T1*T1*wt*wt)
-//   
-// Residual integral(Er/Ez,Erphi/Ez) obtained comparing the B field 0 and B field +-0.5 T setting
-// minimizing track matching residuals 
-// delta(Er/Ez) ~ sum[ poln(r) * polm(z) * cos(n,phi)] 
-//  
-////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCExBEffective
+/// \brief Correct for the rest of ExB effect which are not covered by physical models
+///
+/// Motivation:
+///  ExB correction:
+///     dr    =  c0* integral(Er/Ez) + c1* integral(Erphi/Ez)
+///     drphi = -c1* integral(Er/Ez) + c0* integral(Erphi/Ez)
+///  Where:
+///  wt = Bz*(k*vdrift/E)           ~ 0.3 at B=0.5 T
+///  c0 = 1/(1+T2*T2*wt*wt)
+///  c1 = T1*wt/(1+T1*T1*wt*wt)
+///
+/// Residual integral(Er/Ez,Erphi/Ez) obtained comparing the B field 0 and B field +-0.5 T setting
+/// minimizing track matching residuals
+/// delta(Er/Ez) ~ sum[ poln(r) * polm(z) * cos(n,phi)]
+
 #include "AliMagF.h"
 #include "TGeoGlobalMagField.h"
 #include "AliTPCcalibDB.h"
@@ -41,11 +38,13 @@
 #include "TMath.h"
 #include "AliTPCROC.h"
 #include "AliTPCExBEffective.h"
+/// \cond CLASSIMP
 ClassImp(AliTPCExBEffective)
+/// \endcond
 
 AliTPCExBEffective::AliTPCExBEffective()
   : AliTPCCorrection("ExB_effective","ExB effective"),
-    fC0(1.),fC1(0.), 
+    fC0(1.),fC1(0.),
     fPolynomA(0),
     fPolynomC(0),
     fPolynomValA(0),
@@ -57,18 +56,15 @@ AliTPCExBEffective::AliTPCExBEffective()
 }
 
 AliTPCExBEffective::~AliTPCExBEffective() {
-  //
-  // default destructor
-  //
+  /// default destructor
+
 }
 
 
 
 void AliTPCExBEffective::Init() {
-  //
-  // Initialization funtion
-  //
-  
+  /// Initialization funtion
+
   AliMagF* magF= (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
   if (!magF) AliError("Magneticd field - not initialized");
   Double_t bzField = magF->SolenoidField()/10.; //field in T
@@ -76,7 +72,7 @@ void AliTPCExBEffective::Init() {
   if (!param) AliError("Parameters - not initialized");
   Double_t vdrift = param->GetDriftV()/1000000.; // [cm/us]   // From dataBase: to be updated: per second (ideally)
   Double_t ezField = 400; // [V/cm]   // to be updated: never (hopefully)
-  Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ; 
+  Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ;
   // Correction Terms for effective omegaTau; obtained by a laser calibration run
   SetOmegaTauT1T2(wt,fT1,fT2);
 
@@ -84,9 +80,8 @@ void AliTPCExBEffective::Init() {
 }
 
 void AliTPCExBEffective::Update(const TTimeStamp &/*timeStamp*/) {
-  //
-  // Update function 
-  //
+  /// Update function
+
   AliMagF* magF= (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
   if (!magF) AliError("Magneticd field - not initialized");
   Double_t bzField = magF->SolenoidField()/10.; //field in T
@@ -94,7 +89,7 @@ void AliTPCExBEffective::Update(const TTimeStamp &/*timeStamp*/) {
   if (!param) AliError("Parameters - not initialized");
   Double_t vdrift = param->GetDriftV()/1000000.; // [cm/us]   // From dataBase: to be updated: per second (ideally)
   Double_t ezField = 400; // [V/cm]   // to be updated: never (hopefully)
-  Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ; 
+  Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ;
   // Correction Terms for effective omegaTau; obtained by a laser calibration run
   SetOmegaTauT1T2(wt,fT1,fT2);
 
@@ -104,9 +99,8 @@ void AliTPCExBEffective::Update(const TTimeStamp &/*timeStamp*/) {
 
 
 void AliTPCExBEffective::GetCorrection(const Float_t x[],const Short_t roc,Float_t dx[]) {
-  //
-  // Calculates the correction due conical shape
-  //   
+  /// Calculates the correction due conical shape
+
   if (!fPolynomA) return;
   AliTPCROC * calROC = AliTPCROC::Instance();
   const Double_t kRTPC0  =calROC->GetPadRowRadii(0,0);
@@ -127,7 +121,7 @@ void AliTPCExBEffective::GetCorrection(const Float_t x[],const Short_t roc,Float
 
   Double_t dr    =   fC0 * erez + fC1 * erphiez;
   Double_t drphi =  -fC1 * erez + fC0 * erphiez;
-  
+
   // Calculate distorted position
   if ( r > 0.0 ) {
     r   =  r   + dr;
@@ -143,9 +137,8 @@ void AliTPCExBEffective::GetCorrection(const Float_t x[],const Short_t roc,Float
 
 
 Double_t AliTPCExBEffective::GetSum(const TMatrixD& mpol, const TMatrixD&mcoef, Double_t r, Double_t drift, Double_t phi, Int_t coord) const {
-  //
-  // Summation of the polynomials
-  //
+  /// Summation of the polynomials
+
   Int_t npols=mpol.GetNrows();
   Double_t sum=0;
   for (Int_t ipol=0;ipol<npols; ipol++){
@@ -164,20 +157,18 @@ Double_t AliTPCExBEffective::GetSum(const TMatrixD& mpol, const TMatrixD&mcoef,
   }
   return sum;
 }
- 
+
 
 void AliTPCExBEffective::SetPolynoms(const TMatrixD *polA,const TMatrixD *polC){
-  //
-  // Set correction polynom - coefficients
-  //
+  /// Set correction polynom - coefficients
+
   fPolynomA = new TMatrixD(*polA);
   fPolynomC = new TMatrixD(*polC);
 }
 
 void AliTPCExBEffective::SetCoeficients(const TMatrixD *valA,const TMatrixD *valC){
-  //
-  // Set correction polynom - coefficients
-  //
+  /// Set correction polynom - coefficients
+
   fPolynomValA = new TMatrixD(*valA);
   fPolynomValC = new TMatrixD(*valC);
 }
@@ -186,20 +177,18 @@ void AliTPCExBEffective::SetCoeficients(const TMatrixD *valA,const TMatrixD *val
 
 
 void AliTPCExBEffective::Print(const Option_t* option) const {
-  //
-  // Print function to check the settings (e.g. the twist in the X direction)
-  // option=="a" prints the C0 and C1 coefficents for calibration purposes
-  //
+  /// Print function to check the settings (e.g. the twist in the X direction)
+  /// option=="a" prints the C0 and C1 coefficents for calibration purposes
 
   TString opt = option; opt.ToLower();
   printf("%s\t%s\n",GetName(),GetTitle());
-  
+
   if (opt.Contains("a")) { // Print all details
     printf(" - T1: %1.4f, T2: %1.4f \n",fT1,fT2);
     printf(" - C0: %1.4f, C1: %1.4f \n",fC0,fC1);
     fPolynomValA->Print();
     fPolynomValC->Print();
-  }    
- 
- 
+  }
+
+
 }
diff --git a/TPC/TPCbase/AliTPCExBEffective.h b/TPC/TPCbase/AliTPCExBEffective.h
index f9cee605cff..838fcdfbf13 100644
--- a/TPC/TPCbase/AliTPCExBEffective.h
+++ b/TPC/TPCbase/AliTPCExBEffective.h
@@ -4,12 +4,10 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-////////////////////////////////////////////////////////////////////////////
-//                                                                        //
-// AliTPCExBEffective class                                                   //
-// date: 02/05/2010                                                       //
-// Authors: Maarian Ivanov, Jim Thomas, Magnus Mager, Stefan Rossegger                    //
-////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCExBEffective
+///
+/// \author Maarian Ivanov, Jim Thomas, Magnus Mager, Stefan Rossegger
+/// \date 02/05/2010
 
 #include "AliTPCCorrection.h"
 
@@ -37,16 +35,18 @@ public:
   virtual void GetCorrection(const Float_t x[],const Short_t roc,Float_t dx[]);
 
 private:
-  Double_t fC0;                // coefficient C0 (compare Jim Thomas's notes for definitions)
-  Double_t fC1;                // coefficient C1 (compare Jim Thomas's notes for definitions)
-  TMatrixD *fPolynomA;         // correction polynoms A
-  TMatrixD *fPolynomC;         // correction polynoms C
-  TMatrixD *fPolynomValA;      // correction polynoms coefficient A
-  TMatrixD *fPolynomValC;      //  correction polynoms coefficient C
+  Double_t fC0;                ///< coefficient C0 (compare Jim Thomas's notes for definitions)
+  Double_t fC1;                ///< coefficient C1 (compare Jim Thomas's notes for definitions)
+  TMatrixD *fPolynomA;         ///< correction polynoms A
+  TMatrixD *fPolynomC;         ///< correction polynoms C
+  TMatrixD *fPolynomValA;      ///< correction polynoms coefficient A
+  TMatrixD *fPolynomValC;      ///< correction polynoms coefficient C
 
   AliTPCExBEffective(const AliTPCExBEffective&);
   AliTPCExBEffective &operator=(const AliTPCExBEffective&);
+  /// \cond CLASSIMP
   ClassDef(AliTPCExBEffective,1);
+  /// \endcond
 };
 
 #endif
diff --git a/TPC/TPCbase/AliTPCExBEffectiveSector.cxx b/TPC/TPCbase/AliTPCExBEffectiveSector.cxx
index e11b8e882bb..3b5a90fd82b 100644
--- a/TPC/TPCbase/AliTPCExBEffectiveSector.cxx
+++ b/TPC/TPCbase/AliTPCExBEffectiveSector.cxx
@@ -13,34 +13,31 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-////////////////////////////////////////////////////////////////////////////
-//                                                                        //
-// AliTPCExBEffectiveSector class                                                   //
-// Correct for the rest of ExB effect which are not covered yet by physical models
-//
-// Motivation:
-//   ExB correction: 
-//      dr    =  c0* integral(Er/Ez) + c1* integral(Erphi/Ez)
-//      drphi = -c1* integral(Er/Ez) + c0* integral(Erphi/Ez)
-//   Where:      
-//   wt = Bz*(k*vdrift/E)           ~ 0.3 at B=0.5 T 
-//   c0 = 1/(1+T2*T2*wt*wt) 
-//   c1 = T1*wt/(1+T1*T1*wt*wt)
-//   
-//  
-//  3 correction maps 0 implemented as histogram used
-//  R-Phi correction map obtained minimizing residuals betwee the track
-//        and space points (AliTPCcalibAlign class). Track is defined using
-//        the points from the refernce plain at the middle of the TPC
-//        and vertex
-//        Corrected primar tracks straight pointing to the primary vertex
-//
-//  R distortion - obtained using the cluster residuals in the setup with
-//                 plus and minus field 
-//                 Only high momenta tracks used for this calibration (1 GeV threshold)
-//     drphi_plus-drphi_minus=-2*c1 integral(Er/Ez)
-//               - Erphi/Ez cancels   
-////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCExBEffectiveSector
+/// \brief Correct for the rest of ExB effect which are not covered yet by physical models
+///
+/// Motivation:
+///  ExB correction:
+///     dr    =  c0* integral(Er/Ez) + c1* integral(Erphi/Ez)
+///     drphi = -c1* integral(Er/Ez) + c0* integral(Erphi/Ez)
+///  Where:
+///  wt = Bz*(k*vdrift/E)           ~ 0.3 at B=0.5 T
+///  c0 = 1/(1+T2*T2*wt*wt)
+///  c1 = T1*wt/(1+T1*T1*wt*wt)
+///
+/// 3 correction maps 0 implemented as histogram used
+/// R-Phi correction map obtained minimizing residuals betwee the track
+///       and space points (AliTPCcalibAlign class). Track is defined using
+///       the points from the refernce plain at the middle of the TPC
+///       and vertex
+///       Corrected primar tracks straight pointing to the primary vertex
+///
+/// R distortion - obtained using the cluster residuals in the setup with
+/// plus and minus field
+/// Only high momenta tracks used for this calibration (1 GeV threshold)
+///    drphi_plus-drphi_minus=-2*c1 integral(Er/Ez)
+/// - Erphi/Ez cancels
+
 #include "AliMagF.h"
 #include "TGeoGlobalMagField.h"
 #include "AliTPCcalibDB.h"
@@ -60,11 +57,13 @@
 #include "TH3F.h"
 #include "TROOT.h"
 #include "AliTPCExBEffectiveSector.h"
+/// \cond CLASSIMP
 ClassImp(AliTPCExBEffectiveSector)
+/// \endcond
 
 AliTPCExBEffectiveSector::AliTPCExBEffectiveSector()
   : AliTPCCorrection("ExB_effectiveSector","ExB effective sector"),
-    fC0(1.),fC1(0.), 
+    fC0(1.),fC1(0.),
     fCorrectionR(0),        // radial correction
     fCorrectionRPhi(0),     // r-phi correction
     fCorrectionZ(0)        // z correction
@@ -75,9 +74,8 @@ AliTPCExBEffectiveSector::AliTPCExBEffectiveSector()
 }
 
 AliTPCExBEffectiveSector::~AliTPCExBEffectiveSector() {
-  //
-  // default destructor
-  //
+  /// default destructor
+
   delete fCorrectionR;        // radial correction
   delete fCorrectionRPhi;     // r-phi correction
   delete fCorrectionZ;        // z correction
@@ -86,10 +84,8 @@ AliTPCExBEffectiveSector::~AliTPCExBEffectiveSector() {
 
 
 void AliTPCExBEffectiveSector::Init() {
-  //
-  // Initialization funtion
-  //
-  
+  /// Initialization funtion
+
   AliMagF* magF= (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
   if (!magF) AliError("Magneticd field - not initialized");
   Double_t bzField = magF->SolenoidField()/10.; //field in T
@@ -97,15 +93,14 @@ void AliTPCExBEffectiveSector::Init() {
   if (!param) AliError("Parameters - not initialized");
   Double_t vdrift = param->GetDriftV()/1000000.; // [cm/us]   // From dataBase: to be updated: per second (ideally)
   Double_t ezField = 400; // [V/cm]   // to be updated: never (hopefully)
-  Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ; 
+  Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ;
   // Correction Terms for effective omegaTau; obtained by a laser calibration run
   SetOmegaTauT1T2(wt,fT1,fT2);
 }
 
 void AliTPCExBEffectiveSector::Update(const TTimeStamp &/*timeStamp*/) {
-  //
-  // Update function 
-  //
+  /// Update function
+
   AliMagF* magF= (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
   if (!magF) AliError("Magneticd field - not initialized");
   Double_t bzField = magF->SolenoidField()/10.; //field in T
@@ -113,7 +108,7 @@ void AliTPCExBEffectiveSector::Update(const TTimeStamp &/*timeStamp*/) {
   if (!param) AliError("Parameters - not initialized");
   Double_t vdrift = param->GetDriftV()/1000000.; // [cm/us]   // From dataBase: to be updated: per second (ideally)
   Double_t ezField = 400; // [V/cm]   // to be updated: never (hopefully)
-  Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ; 
+  Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ;
   // Correction Terms for effective omegaTau; obtained by a laser calibration run
   SetOmegaTauT1T2(wt,fT1,fT2);
 }
@@ -121,10 +116,9 @@ void AliTPCExBEffectiveSector::Update(const TTimeStamp &/*timeStamp*/) {
 
 
 void AliTPCExBEffectiveSector::GetCorrection(const Float_t x[],const Short_t roc,Float_t dx[]) {
-  //
-  // Calculates the correction using the lookup table (histogram) of distortion
-  // The histogram is created as poscl - postrack
-  //   
+  /// Calculates the correction using the lookup table (histogram) of distortion
+  /// The histogram is created as poscl - postrack
+
   dx[0]=0;
   dx[1]=0;
   dx[2]=0;
@@ -141,7 +135,7 @@ void AliTPCExBEffectiveSector::GetCorrection(const Float_t x[],const Short_t roc
   if (roc%36>=18) kZ=-TMath::Abs(kZ);
   if (TMath::Abs(kZ)<0.15){
     kZ = (roc%36<18) ? 0.15:-0.15;
-  }  
+  }
   //
   Double_t dlR=0;
   Double_t dlRPhi=0;
@@ -151,7 +145,7 @@ void AliTPCExBEffectiveSector::GetCorrection(const Float_t x[],const Short_t roc
   Double_t kZZ=TMath::Max(kZ,fCorrectionRPhi->GetZaxis()->GetXmin()+0.001);
   kZZ=TMath::Min(kZZ,fCorrectionRPhi->GetZaxis()->GetXmax()-0.001);
 
-  if (fCorrectionRPhi) {  
+  if (fCorrectionRPhi) {
     //    dlRPhi= -fCorrectionRPhi->Interpolate(sector,rr,kZZ);
     dlRPhi= -fCorrectionRPhi->GetBinContent(fCorrectionRPhi->FindBin(sector,rr,kZZ));
   }
@@ -173,21 +167,19 @@ void AliTPCExBEffectiveSector::GetCorrection(const Float_t x[],const Short_t roc
   // Calculate correction in cartesian coordinates
   dx[0] = r * TMath::Cos(phi) - x[0];
   dx[1] = r * TMath::Sin(phi) - x[1];
-  dx[2] = dlZ; 
+  dx[2] = dlZ;
 
 }
 
 void AliTPCExBEffectiveSector::Print(const Option_t* option) const {
-  //
-  // Print function to check the settings (e.g. the twist in the X direction)
-  // option=="a" prints the C0 and C1 coefficents for calibration purposes
-  //
+  /// Print function to check the settings (e.g. the twist in the X direction)
+  /// option=="a" prints the C0 and C1 coefficents for calibration purposes
 
   TString opt = option; opt.ToLower();
-  printf("%s\t%s\n",GetName(),GetTitle());  
+  printf("%s\t%s\n",GetName(),GetTitle());
   if (opt.Contains("a")) { // Print all details
     printf(" - T1: %1.4f, T2: %1.4f \n",fT1,fT2);
     printf(" - C0: %1.4f, C1: %1.4f \n",fC0,fC1);
-  }    
+  }
 }
 
diff --git a/TPC/TPCbase/AliTPCExBEffectiveSector.h b/TPC/TPCbase/AliTPCExBEffectiveSector.h
index 4143c2786d2..031b4f030ff 100644
--- a/TPC/TPCbase/AliTPCExBEffectiveSector.h
+++ b/TPC/TPCbase/AliTPCExBEffectiveSector.h
@@ -4,12 +4,10 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-////////////////////////////////////////////////////////////////////////////
-//                                                                        //
-// AliTPCExBEffectiveSector class                                                   //
-// date: 02/05/2010                                                       //
-// Authors: Maarian Ivanov, Jim Thomas, Magnus Mager, Stefan Rossegger                    //
-////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCExBEffectiveSector
+///
+/// \author Maarian Ivanov, Jim Thomas, Magnus Mager, Stefan Rossegger
+/// \date 02/05/2010
 
 #include "AliTPCCorrection.h"
 class TH3F;
@@ -35,15 +33,17 @@ public:
 public:
   virtual void GetCorrection(const Float_t x[],const Short_t roc,Float_t dx[]);
 public:
-  Double_t fC0;                // coefficient C0 (compare Jim Thomas's notes for definitions)
-  Double_t fC1;                // coefficient C1 (compare Jim Thomas's notes for definitions)
-  TH3F *fCorrectionR;        // radial correction
-  TH3F *fCorrectionRPhi;     // r-phi correction
-  TH3F *fCorrectionZ;        // z correction
+  Double_t fC0;                ///< coefficient C0 (compare Jim Thomas's notes for definitions)
+  Double_t fC1;                ///< coefficient C1 (compare Jim Thomas's notes for definitions)
+  TH3F *fCorrectionR;        ///< radial correction
+  TH3F *fCorrectionRPhi;     ///< r-phi correction
+  TH3F *fCorrectionZ;        ///< z correction
 private:
   AliTPCExBEffectiveSector(const AliTPCExBEffectiveSector&);
   AliTPCExBEffectiveSector &operator=(const AliTPCExBEffectiveSector&);
+  /// \cond CLASSIMP
   ClassDef(AliTPCExBEffectiveSector,2);
+  /// \endcond
 };
 
 #endif
diff --git a/TPC/TPCbase/AliTPCExBExact.cxx b/TPC/TPCbase/AliTPCExBExact.cxx
index 2991ae0ce11..1fa941699c9 100644
--- a/TPC/TPCbase/AliTPCExBExact.cxx
+++ b/TPC/TPCbase/AliTPCExBExact.cxx
@@ -13,20 +13,22 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-////
-// This implementation AliTPCExB is using an "exact" calculation of the ExB
-// effect. That is, it uses the drift ODE to calculate the distortion
-// without any further assumption.
-// Due to the numerical integration of the ODE, there are some numerical
-// uncertencies involed.
-////
+/// \class AliTPCExBExact
+/// \brief This implementation AliTPCExB is using an "exact" calculation of the ExB effect.
+///
+/// That is, it uses the drift ODE to calculate the distortion
+/// without any further assumption.
+/// Due to the numerical integration of the ODE, there are some numerical
+/// uncertencies involed.
 
 #include "TMath.h"
 #include "TTreeStream.h"
 #include "AliMagF.h"
 #include "AliTPCExBExact.h"
 
+/// \cond CLASSIMP
 ClassImp(AliTPCExBExact)
+/// \endcond
 
 const Double_t AliTPCExBExact::fgkEM=1.602176487e-19/9.10938215e-31;
 const Double_t AliTPCExBExact::fgkDriftField=-40.e3;
@@ -39,9 +41,8 @@ AliTPCExBExact::AliTPCExBExact()
     fkXMin(-250.),fkXMax(250.),fkYMin(-250.),fkYMax(250.),
     fkZMin(-250.),fkZMax(250.),
     fkNLook(0),fkLook(0) {
-  //
-  // purely for I/O
-  //
+  /// purely for I/O
+
 }
 
 AliTPCExBExact::AliTPCExBExact(const AliMagF *bField,
@@ -54,21 +55,20 @@ AliTPCExBExact::AliTPCExBExact(const AliMagF *bField,
     fkXMin(-250.),fkXMax(250.),fkYMin(-250.),fkYMax(250.),
     fkZMin(-250.),fkZMax(250.),
     fkNLook(0),fkLook(0) {
-  //
-  // The constructor. One has to supply a magnetic field and an (initial)
-  // drift velocity. Since some kind of lookuptable is created the
-  // number of its meshpoints can be supplied.
-  // n sets the number of integration steps to be used when integrating
-  // over the full drift length.
-  //
+  /// The constructor. One has to supply a magnetic field and an (initial)
+  /// drift velocity. Since some kind of lookuptable is created the
+  /// number of its meshpoints can be supplied.
+  /// n sets the number of integration steps to be used when integrating
+  /// over the full drift length.
+
   CreateLookupTable();
 }
 
 /*
 AliTPCExBExact::AliTPCExBExact(const AliFieldMap *bFieldMap,
-			       Double_t driftVelocity,Int_t n) 
+			       Double_t driftVelocity,Int_t n)
   : fDriftVelocity(driftVelocity),
-    fkMap(bFieldMap),fkField(0),fkN(n), 
+    fkMap(bFieldMap),fkField(0),fkN(n),
     fkNX(0),fkNY(0),fkNZ(0),
     fkXMin(-250.),fkXMax(250.),fkYMin(-250.),fkYMax(250.),
     fkZMin(-250.),fkZMax(250.),
@@ -106,30 +106,28 @@ AliTPCExBExact::AliTPCExBExact(const AliFieldMap *bFieldMap,
 */
 
 AliTPCExBExact::~AliTPCExBExact() {
-  //
-  // destruct the poor object.
-  //
+  /// destruct the poor object.
+
   delete[] fkLook;
 }
 
 void AliTPCExBExact::Correct(const Double_t *position, Double_t *corrected) {
-  //
-  // correct for the distortion
-  //
+  /// correct for the distortion
+
   Double_t x=(position[0]-fkXMin)/(fkXMax-fkXMin)*(fkNX-1);
   Int_t xi1=static_cast<Int_t>(x);
   xi1=TMath::Max(TMath::Min(xi1,fkNX-2),0);
   Int_t xi2=xi1+1;
   Double_t dx=(x-xi1);
   Double_t dx1=(xi2-x);
-  
+
   Double_t y=(position[1]-fkYMin)/(fkYMax-fkYMin)*(fkNY-1);
   Int_t yi1=static_cast<Int_t>(y);
   yi1=TMath::Max(TMath::Min(yi1,fkNY-2),0);
   Int_t yi2=yi1+1;
   Double_t dy=(y-yi1);
   Double_t dy1=(yi2-y);
-  
+
   Double_t z=position[2]/fkZMax*(fkNZ-1);
   Int_t side;
   if (z>0) {
@@ -144,7 +142,7 @@ void AliTPCExBExact::Correct(const Double_t *position, Double_t *corrected) {
   Int_t zi2=zi1+1;
   Double_t dz=(z-zi1);
   Double_t dz1=(zi2-z);
-  
+
   for (int i=0;i<3;++i)
     corrected[i]
       =fkLook[(((xi1*fkNY+yi1)*fkNZ+zi1)*2+side)*3+i]*dx1*dy1*dz1
@@ -172,18 +170,16 @@ void AliTPCExBExact::TestThisBeautifulObject(const AliFieldMap *bFieldMap,
 
 void AliTPCExBExact::TestThisBeautifulObject(const AliMagF *bField,
 					     const char* fileName) {
-  //
-  // Have a look at the common part "TestThisBeautifulObjectGeneric".
-  //
+  /// Have a look at the common part "TestThisBeautifulObjectGeneric".
+
   fkField=bField;
   //fkMap=0;
   TestThisBeautifulObjectGeneric(fileName);
 }
 
 void AliTPCExBExact::TestThisBeautifulObjectGeneric(const char* fileName) {
-  //
-  // Well, as the name sais... it tests the object.
-  //
+  /// Well, as the name sais... it tests the object.
+
   TTreeSRedirector ts(fileName);
   Double_t x[3];
   for (x[0]=-250.;x[0]<=250.;x[0]+=10.)
@@ -232,9 +228,8 @@ void AliTPCExBExact::TestThisBeautifulObjectGeneric(const char* fileName) {
 }
 
 void AliTPCExBExact::CreateLookupTable() {
-  //
-  // Helper function to fill the lookup table.
-  //
+  /// Helper function to fill the lookup table.
+
   fkNLook=fkNX*fkNY*fkNZ*2*3;
   fkLook=new Double_t[fkNLook];
   Double_t x[3];
@@ -254,20 +249,18 @@ void AliTPCExBExact::CreateLookupTable() {
 }
 
 void AliTPCExBExact::GetE(Double_t *e,const Double_t *x) const {
-  //
-  // Helper function returning the E field in SI units (V/m).
-  //
+  /// Helper function returning the E field in SI units (V/m).
+
   e[0]=0.;
   e[1]=0.;
   e[2]=(x[2]<0.?-1.:1.)*fgkDriftField; // in V/m
 }
 
 void AliTPCExBExact::GetB(Double_t *b,const Double_t *x) const {
-  //
-  // Helper function returning the B field in SI units (T).
-  //
+  /// Helper function returning the B field in SI units (T).
+
   Double_t xm[3];
-  // the beautiful m to cm (and the ugly "const_cast") and Double_t 
+  // the beautiful m to cm (and the ugly "const_cast") and Double_t
   // to Float_t read the NRs introduction!:
   for (int i=0;i<3;++i) xm[i]=x[i]*100.;
   Double_t bf[3];
@@ -280,9 +273,8 @@ void AliTPCExBExact::GetB(Double_t *b,const Double_t *x) const {
 
 void AliTPCExBExact::Motion(const Double_t *x,Double_t,
 			    Double_t *dxdt) const {
-  //
-  // The differential equation of motion of the electrons.
-  //
+  /// The differential equation of motion of the electrons.
+
   Double_t tau=fDriftVelocity/fgkDriftField/fgkEM;
   Double_t tau2=tau*tau;
   Double_t e[3];
@@ -307,10 +299,9 @@ void AliTPCExBExact::Motion(const Double_t *x,Double_t,
 
 void AliTPCExBExact::CalculateDistortion(const Double_t *x0,
 					 Double_t *dist) const {
-  //
-  // Helper function that calculates one distortion by integration
-  // (only used to fill the lookup table).
-  //
+  /// Helper function that calculates one distortion by integration
+  /// (only used to fill the lookup table).
+
   Double_t h=0.01*250./fDriftVelocity/fkN;
   Double_t t=0.;
   Double_t xt[3];
@@ -342,10 +333,9 @@ void AliTPCExBExact::CalculateDistortion(const Double_t *x0,
 }
 
 void AliTPCExBExact::DGLStep(Double_t *x,Double_t t,Double_t h) const {
-  //
-  // An elementary integration step.
-  // (simple Euler Method)
-  //
+  /// An elementary integration step.
+  /// (simple Euler Method)
+
   Double_t dxdt[3];
   Motion(x,t,dxdt);
   for (int i=0;i<3;++i)
diff --git a/TPC/TPCbase/AliTPCExBExact.h b/TPC/TPCbase/AliTPCExBExact.h
index 2115654dac6..38c55d9c066 100644
--- a/TPC/TPCbase/AliTPCExBExact.h
+++ b/TPC/TPCbase/AliTPCExBExact.h
@@ -1,9 +1,8 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-////
-// An exact implementation of the ExB effect.
-////
+/// \class AliTPCExBExact
+/// \brief An exact implementation of the ExB effect.
 
 #ifndef ALITPCEXBEXACT_H
 #define ALITPCEXBEXACT_H
@@ -23,7 +22,7 @@ public:
   //void TestThisBeautifulObject(const AliFieldMap *bFieldMap,const char* fileName);
   void TestThisBeautifulObject(const AliMagF *bField,const char* fileName);
 protected:
-  Double_t fDriftVelocity; // The electron drift velocity.
+  Double_t fDriftVelocity; ///< The electron drift velocity.
 private:
   AliTPCExBExact& operator=(const AliTPCExBExact&); // don't assign me
   AliTPCExBExact(const AliTPCExBExact&); // don't copy me
@@ -35,23 +34,26 @@ private:
   void CalculateDistortion(const Double_t *x,Double_t *dist) const;
   void DGLStep(Double_t *x,Double_t t,Double_t h) const;
   //const AliFieldMap *fkMap; //! the magnetic field map as supplied by the user
-  const AliMagF *fkField;   //! the magnetic field as supplied by the user
-  Int_t fkN;        // max number of integration steps
-  Int_t fkNX;       // field mesh points in x direction
-  Int_t fkNY;       // field mesh points in y direction
-  Int_t fkNZ;       // field mesh points in z direction
-  Double_t fkXMin;  // the first grid point in x direction
-  Double_t fkXMax;  // the last grid point in x direction
-  Double_t fkYMin;  // the first grid point in y direction
-  Double_t fkYMax;  // the last grid point in y direction
-  Double_t fkZMin;  // the first grid point in z direction
-  Double_t fkZMax;  // the last grid point in z direction
-  Int_t fkNLook;    // size of the lookup table
-  Double_t *fkLook; //[fkNLook] the great lookup table
-  static const Double_t fgkEM; //! elementary charge over electron mass (C/kg)
-  static const Double_t fgkDriftField; //! the TPC drift field (V/m) (modulus)
+  const AliMagF *fkField;   //!< the magnetic field as supplied by the user
+  Int_t fkN;        ///< max number of integration steps
+  Int_t fkNX;       ///< field mesh points in x direction
+  Int_t fkNY;       ///< field mesh points in y direction
+  Int_t fkNZ;       ///< field mesh points in z direction
+  Double_t fkXMin;  ///< the first grid point in x direction
+  Double_t fkXMax;  ///< the last grid point in x direction
+  Double_t fkYMin;  ///< the first grid point in y direction
+  Double_t fkYMax;  ///< the last grid point in y direction
+  Double_t fkZMin;  ///< the first grid point in z direction
+  Double_t fkZMax;  ///< the last grid point in z direction
+  Int_t fkNLook;    ///< size of the lookup table
+  /// the great lookup table
+  Double_t *fkLook; //[fkNLook]
+  static const Double_t fgkEM; //!< elementary charge over electron mass (C/kg)
+  static const Double_t fgkDriftField; //!< the TPC drift field (V/m) (modulus)
 
+  /// \cond CLASSIMP
   ClassDef(AliTPCExBExact,1)
+  /// \endcond
 };
 
 #endif
diff --git a/TPC/TPCbase/AliTPCExBFirst.cxx b/TPC/TPCbase/AliTPCExBFirst.cxx
index 9a56a4cdf85..cb620cff049 100644
--- a/TPC/TPCbase/AliTPCExBFirst.cxx
+++ b/TPC/TPCbase/AliTPCExBFirst.cxx
@@ -13,25 +13,26 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-//
-// This implementation AliTPCExB is using an aproximate calculation of the ExB
-// effect. Therefore the drift ODE is Taylor expanded and only the first
-// order part is taken.
-//
-// 
-// The ExB correction map is stored in the calib DB
-// To test current version:
-/*
-  char *storage = "local://OCDBres"
-  Int_t RunNumber=0;
-  AliCDBManager::Instance()->SetDefaultStorage(storage);
-  AliCDBManager::Instance()->SetRun(RunNumber) 
-  AliTPCExBFirst * exb = AliTPCcalibDB::Instance()->GetExB();
-
-  //  exb->TestExB("exb.root");
-  // TFile f("exb.root");
-  //positions->Draw("drphi");
-*/
+/// \class AliTPCExBFirst
+/// \brief This implementation AliTPCExB is using an aproximate calculation of the ExB effect
+///
+/// Therefore the drift ODE is Taylor expanded and only the first
+/// order part is taken.
+///
+/// The ExB correction map is stored in the calib DB
+/// To test current version:
+///
+/// ~~~
+/// char *storage = "local://OCDBres"
+/// Int_t RunNumber=0;
+/// AliCDBManager::Instance()->SetDefaultStorage(storage);
+/// AliCDBManager::Instance()->SetRun(RunNumber)
+/// AliTPCExBFirst * exb = AliTPCcalibDB::Instance()->GetExB();
+///
+/// //  exb->TestExB("exb.root");
+/// // TFile f("exb.root");
+/// //positions->Draw("drphi");
+/// ~~~
 
 
 
@@ -41,7 +42,9 @@
 #include "TTreeStream.h"
 #include "AliTPCExBFirst.h"
 
+/// \cond CLASSIMP
 ClassImp(AliTPCExBFirst)
+/// \endcond
 
 const Double_t AliTPCExBFirst::fgkEM=1.602176487e-19/9.10938215e-31;
 const Double_t AliTPCExBFirst::fgkDriftField=-40.e3;
@@ -53,9 +56,8 @@ AliTPCExBFirst::AliTPCExBFirst()
     fkZMin(-250.),fkZMax(250.),
     fkNMean(0),
     fkMeanBx(0),fkMeanBy(0),fkMeanBz(0.) {
-  //
-  // purely for I/O
-  //
+  /// purely for I/O
+
   SetInstance(this);
 }
 
@@ -68,19 +70,19 @@ AliTPCExBFirst::AliTPCExBFirst(const AliMagF *bField,
     fkZMin(-250.),fkZMax(250.),
     fkNMean(0),
     fkMeanBx(0),fkMeanBy(0),fkMeanBz(0.) {
-  //
-  // The constructor. One has to supply a magnetic field and an (initial)
-  // drift velocity. Since some kind of lookuptable is created the
-  // number of its meshpoints can be supplied.
-  //
-  //  ConstructCommon(0,bField);
+  /// The constructor. One has to supply a magnetic field and an (initial)
+  /// drift velocity. Since some kind of lookuptable is created the
+  /// number of its meshpoints can be supplied.
+  ///
+  ///  ConstructCommon(0,bField);
+
   ConstructCommon(bField);
   SetInstance(this);
 }
 
 /*
 AliTPCExBFirst::AliTPCExBFirst(const AliFieldMap *bFieldMap,
-			       Double_t driftVelocity) 
+			       Double_t driftVelocity)
   : fDriftVelocity(driftVelocity),
     fkNX(0),fkNY(0),fkNZ(0),
     fkXMin(-250.),fkXMax(250.),fkYMin(-250.),fkYMax(250.),
@@ -119,18 +121,16 @@ AliTPCExBFirst::AliTPCExBFirst(const AliFieldMap *bFieldMap,
 }
 */
 
-AliTPCExBFirst::~AliTPCExBFirst() { 
-  //
-  // destruct the poor object.
-  //
+AliTPCExBFirst::~AliTPCExBFirst() {
+  /// destruct the poor object.
+
   delete[] fkMeanBx;
   delete[] fkMeanBy;
 }
 
 void AliTPCExBFirst::Correct(const Double_t *position,Double_t *corrected) {
-  //
-  // correct for the distortion
-  //
+  /// correct for the distortion
+
   Double_t bx,by;
   GetMeanFields(position[0],position[1],position[2],&bx,&by);
   if (position[2]>0.) {
@@ -145,13 +145,13 @@ void AliTPCExBFirst::Correct(const Double_t *position,Double_t *corrected) {
       by=bye;
     }
   }
-  
+
   Double_t mu=fDriftVelocity/fgkDriftField;
   Double_t wt=mu*fkMeanBz;
-  
+
   corrected[0]=mu*(wt*bx-by)/(1.+wt*wt);
   corrected[1]=mu*(wt*by+bx)/(1.+wt*wt);
-  
+
   if (position[2]>0.) {
     corrected[0]*=(250.-position[2]);
     corrected[1]*=(250.-position[2]);
@@ -167,9 +167,8 @@ void AliTPCExBFirst::Correct(const Double_t *position,Double_t *corrected) {
 }
 
 void AliTPCExBFirst::TestThisBeautifulObject(const char* fileName) {
-  //
-  // well, as the name sais...
-  //
+  /// well, as the name sais...
+
   TTreeSRedirector ts(fileName);
   Double_t x[3];
   for (x[0]=-250.;x[0]<=250.;x[0]+=10.)
@@ -207,9 +206,8 @@ void AliTPCExBFirst::TestThisBeautifulObject(const char* fileName) {
 
 void AliTPCExBFirst::ConstructCommon(//const AliFieldMap *bFieldMap,
 				     const AliMagF *bField) {
-  //
-  // THIS IS PRIVATE! (a helper for the constructor)
-  //
+  /// THIS IS PRIVATE! (a helper for the constructor)
+
   fkNMean=fkNX*fkNY*fkNZ;
   fkMeanBx=new Double_t[fkNMean];
   fkMeanBy=new Double_t[fkNMean];
@@ -232,7 +230,7 @@ void AliTPCExBFirst::ConstructCommon(//const AliFieldMap *bFieldMap,
 	// that happens due to the lack of a sophisticated class design:
 	//	if (bFieldMap!=0)
 	//	  bFieldMap->Field(xt,b);
-	//	else 
+	//	else
 	((AliMagF*)bField)->Field(xt,b);
 	bx+=b[0]/10.;
 	by+=b[1]/10.;
@@ -251,9 +249,8 @@ void AliTPCExBFirst::ConstructCommon(//const AliFieldMap *bFieldMap,
 
 void AliTPCExBFirst::GetMeanFields(Double_t rx,Double_t ry,Double_t rz,
 				   Double_t *Bx,Double_t *By) const {
-  //
-  // THIS IS PRIVATE! (calculates the mean field utilising a lookup table)
-  //
+  /// THIS IS PRIVATE! (calculates the mean field utilising a lookup table)
+
   Double_t x=(fkNX-1)*(rx-fkXMin)/(fkXMax-fkXMin);
   Int_t xi1=static_cast<Int_t>(x);
   xi1=TMath::Max(TMath::Min(xi1,fkNX-2),0);
@@ -267,7 +264,7 @@ void AliTPCExBFirst::GetMeanFields(Double_t rx,Double_t ry,Double_t rz,
   Int_t yi2=yi1+1;
   Double_t dy=(y-yi1);
   Double_t dy1=(yi2-y);
-  
+
   Double_t z=(fkNZ-1)*(rz-fkZMin)/(fkZMax-fkZMin);
   Int_t zi1=static_cast<Int_t>(z);
   zi1=TMath::Max(TMath::Min(zi1,fkNZ-2),0);
diff --git a/TPC/TPCbase/AliTPCExBFirst.h b/TPC/TPCbase/AliTPCExBFirst.h
index 8b0943642b8..b09d7663a5a 100644
--- a/TPC/TPCbase/AliTPCExBFirst.h
+++ b/TPC/TPCbase/AliTPCExBFirst.h
@@ -1,9 +1,8 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-////
-// An approximate (first order) implementation of the ExB effect.
-////
+/// \class AliTPCExBFirst
+/// \brief An approximate (first order) implementation of the ExB effect.
 
 #ifndef ALITPCEXBFIRST_H
 #define ALITPCEXBFIRST_H
@@ -25,7 +24,7 @@ public:
     fDriftVelocity=driftVelocity;
   };
 protected:
-  Double_t fDriftVelocity; // The electron drift velocity.
+  Double_t fDriftVelocity; ///< The electron drift velocity.
 private:
   AliTPCExBFirst& operator=(const AliTPCExBFirst&); // don't assign me
   AliTPCExBFirst(const AliTPCExBFirst&); // don't copy me
@@ -33,23 +32,27 @@ private:
   void ConstructCommon(const AliMagF *bField);
   void GetMeanFields(Double_t rx,Double_t ry,Double_t rz,
 		     Double_t *Bx,Double_t *By) const;
-  Int_t fkNX;         // field mesh points in x direction
-  Int_t fkNY;         // field mesh points in y direction
-  Int_t fkNZ;         // field mesh points in z direction
-  Double_t fkXMin;    // the first grid point in x direction
-  Double_t fkXMax;    // the last grid point in x direction
-  Double_t fkYMin;    // the first grid point in y direction
-  Double_t fkYMax;    // the last grid point in y direction
-  Double_t fkZMin;    // the first grid point in z direction
-  Double_t fkZMax;    // the last grid point in z direction
-  Int_t fkNMean;      // size of the tablE the mean fields
-  Double_t *fkMeanBx; //[fkNMean] the mean field in x direction upto a certain z value
-  Double_t *fkMeanBy; //[fkNMean] the mean field in y direction upto a certain z value
-  Double_t fkMeanBz;  // the mean field in z direction inside the TPC volume
-  static const Double_t fgkEM; //! elementary charge over electron mass (C/kg)
-  static const Double_t fgkDriftField; //! the TPC drift field (V/m) (modulus)
+  Int_t fkNX;         ///< field mesh points in x direction
+  Int_t fkNY;         ///< field mesh points in y direction
+  Int_t fkNZ;         ///< field mesh points in z direction
+  Double_t fkXMin;    ///< the first grid point in x direction
+  Double_t fkXMax;    ///< the last grid point in x direction
+  Double_t fkYMin;    ///< the first grid point in y direction
+  Double_t fkYMax;    ///< the last grid point in y direction
+  Double_t fkZMin;    ///< the first grid point in z direction
+  Double_t fkZMax;    ///< the last grid point in z direction
+  Int_t fkNMean;      ///< size of the tablE the mean fields
+  /// the mean field in x direction upto a certain z value
+  Double_t *fkMeanBx; //[fkNMean]
+  /// the mean field in y direction upto a certain z value
+  Double_t *fkMeanBy; //[fkNMean]
+  Double_t fkMeanBz;  ///< the mean field in z direction inside the TPC volume
+  static const Double_t fgkEM; //!< elementary charge over electron mass (C/kg)
+  static const Double_t fgkDriftField; //!< the TPC drift field (V/m) (modulus)
 
+  /// \cond CLASSIMP
   ClassDef(AliTPCExBFirst,2)
+  /// \endcond
 };
 
 #endif
diff --git a/TPC/TPCbase/AliTPCExBTwist.cxx b/TPC/TPCbase/AliTPCExBTwist.cxx
index c60d8804613..28fe0a6e5a4 100644
--- a/TPC/TPCbase/AliTPCExBTwist.cxx
+++ b/TPC/TPCbase/AliTPCExBTwist.cxx
@@ -13,9 +13,8 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-////////////////////////////////////////////////////////////////////////////
-// AliTPCExBTwist class                                                   //
-////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCExBTwist
+/// \brief AliTPCExBTwist class
 
 
 #include "AliMagF.h"
@@ -31,27 +30,25 @@ AliTPCExBTwist::AliTPCExBTwist()
     fC1(0.),fC2(0.),
     fXTwist(0.),fYTwist(0.)
 {
-  //
-  // default constructor
-  //
+  /// default constructor
+
 }
 
 AliTPCExBTwist::~AliTPCExBTwist() {
-  //
-  // default destructor
-  //
+  /// default destructor
+
 }
 
 Bool_t AliTPCExBTwist::AddCorrectionCompact(AliTPCCorrection* corr, Double_t weight){
-  //
-  // Add correction  and make them compact
-  // Assumptions:
-  //  - origin of distortion/correction are additive
-  //  - only correction ot the same type supported ()
+  /// Add correction  and make them compact
+  /// Assumptions:
+  ///  - origin of distortion/correction are additive
+  ///  - only correction ot the same type supported ()
+
   if (corr==NULL) {
     AliError("Zerro pointer - correction");
     return kFALSE;
-  }  
+  }
   AliTPCExBTwist * corrC = dynamic_cast< AliTPCExBTwist*>(corr);
   if (corrC == NULL) return kFALSE;
   fXTwist+=weight*corrC->fXTwist;        // Twist of E to B field in X-Z [rad]
@@ -62,10 +59,8 @@ Bool_t AliTPCExBTwist::AddCorrectionCompact(AliTPCCorrection* corr, Double_t wei
 
 
 void AliTPCExBTwist::Init() {
-  //
-  // Initialization funtion
-  //
-  
+  /// Initialization funtion
+
   AliMagF* magF= (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
   if (!magF) AliError("Magneticd field - not initialized");
   Double_t bzField = magF->SolenoidField()/10.; //field in T
@@ -73,7 +68,7 @@ void AliTPCExBTwist::Init() {
   if (!param) AliError("Parameters - not initialized");
   Double_t vdrift = param->GetDriftV()/1000000.; // [cm/us]   // From dataBase: to be updated: per second (ideally)
   Double_t ezField = 400; // [V/cm]   // to be updated: never (hopefully)
-  Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ; 
+  Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ;
   // Correction Terms for effective omegaTau; obtained by a laser calibration run
   SetOmegaTauT1T2(wt,fT1,fT2);
 
@@ -81,9 +76,8 @@ void AliTPCExBTwist::Init() {
 }
 
 void AliTPCExBTwist::Update(const TTimeStamp &/*timeStamp*/) {
-  //
-  // Update function 
-  //
+  /// Update function
+
   AliMagF* magF= (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
   if (!magF) AliError("Magneticd field - not initialized");
   Double_t bzField = magF->SolenoidField()/10.; //field in T
@@ -91,7 +85,7 @@ void AliTPCExBTwist::Update(const TTimeStamp &/*timeStamp*/) {
   if (!param) AliError("Parameters - not initialized");
   Double_t vdrift = param->GetDriftV()/1000000.; // [cm/us]   // From dataBase: to be updated: per second (ideally)
   Double_t ezField = 400; // [V/cm]   // to be updated: never (hopefully)
-  Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ; 
+  Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ;
   // Correction Terms for effective omegaTau; obtained by a laser calibration run
   SetOmegaTauT1T2(wt,fT1,fT2);
 
@@ -101,33 +95,29 @@ void AliTPCExBTwist::Update(const TTimeStamp &/*timeStamp*/) {
 
 
 void AliTPCExBTwist::GetCorrection(const Float_t x[],const Short_t roc,Float_t dx[]) {
-  //
-  // Calculates the correction of a mismatch between the E and B field axis
-  // 
-  
+  /// Calculates the correction of a mismatch between the E and B field axis
+
   const Float_t zstart=x[2];
   const Float_t zend  =(roc%36<18?fgkTPCZ0:-fgkTPCZ0);
   const Float_t zdrift=zstart-zend;
-  
+
   dx[0]=(fC2*fXTwist-fC1*fYTwist)*zdrift;
   dx[1]=(fC1*fXTwist+fC2*fYTwist)*zdrift;
   dx[2]=0.;
 }
 
 void AliTPCExBTwist::Print(const Option_t* option) const {
-  //
-  // Print function to check the settings (e.g. the twist in the X direction)
-  // option=="a" prints the C0 and C1 coefficents for calibration purposes
-  //
+  /// Print function to check the settings (e.g. the twist in the X direction)
+  /// option=="a" prints the C0 and C1 coefficents for calibration purposes
 
   TString opt = option; opt.ToLower();
   printf("%s\n",GetTitle());
-  
+
   printf(" - Twist settings: X-Twist: %1.5f rad, Y-Twist: %1.5f rad \n",fXTwist,fYTwist);
   if (opt.Contains("a")) { // Print all details
     printf(" - T1: %1.4f, T2: %1.4f \n",fT1,fT2);
     printf(" - C1: %1.4f, C2: %1.4f \n",fC1,fC2);
-  }    
- 
- 
+  }
+
+
 }
diff --git a/TPC/TPCbase/AliTPCExBTwist.h b/TPC/TPCbase/AliTPCExBTwist.h
index 0ec6e467414..91a06f666e7 100644
--- a/TPC/TPCbase/AliTPCExBTwist.h
+++ b/TPC/TPCbase/AliTPCExBTwist.h
@@ -4,40 +4,24 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-// _________________________________________________________________
-//
-// Begin_Html
-//   <h2> AliTPCExBTwist class    </h2>       
-//   The class calculates the space point distortions due to a mismatch     
-//   of the E and B field axis (original code from STAR)                    
-//   <p>
-//   It assumes a homogeneous magnetic and electric field. The calculations performed 
-//   within this class can be written in a compact form as well (compare notes of Jim Thomas)
-//   <p>
-//   The inputs to this class are the twist angles in the x and y plane ($\theta_x,\theta_y$) 
-//   in cartesian coordinates. They can be set via the member functions SetXTwist and SetYTwist.
-// End_Html
-//
-// Begin_Macro(source)
-//   {
-//   gROOT->SetStyle("Plain"); gStyle->SetPalette(1);
-//   TCanvas *c2 = new TCanvas("cAliTPCExBTwist","cAliTPCExBTwist",500,300); 
-//   AliTPCExBTwist twist;
-//   twist.SetXTwist(0.001);  // x angle in [rad]
-//   twist.SetXTwist(0.0005); // y angle in [rad]
-//   twist.SetOmegaTauT1T2(0.32,1,1);
-//   twist.CreateHistoDRPhiinXY(1.)->Draw("surf2"); // A side
-//   return c2;
-//   } 
-// End_Macro
-//
-// Begin_Html
-//   <p>
-// Date: 27/04/2010  <br>
-// Authors: Jim Thomas, Magnus Mager, Stefan Rossegger 
-// Support since 2010: mrain.ivanov@cern.ch
-// End_Html 
-// _________________________________________________________________
+/// \class AliTPCExBTwist
+/// \brief AliTPCExBTwist class
+///
+/// The class calculates the space point distortions due to a mismatch
+/// of the E and B field axis (original code from STAR)
+///
+/// It assumes a homogeneous magnetic and electric field. The calculations performed
+/// within this class can be written in a compact form as well (compare notes of Jim Thomas)
+///
+/// The inputs to this class are the twist angles in the x and y plane ($\theta_x,\theta_y$)
+/// in cartesian coordinates. They can be set via the member functions SetXTwist and SetYTwist.
+///
+/// ![Picture from ROOT macro](AliTPCExBTwist_h_76e03fd.png)
+///
+/// Support since 2010: mrain.ivanov@cern.ch
+///
+/// \author Jim Thomas, Magnus Mager, Stefan Rossegger
+/// \date 27/04/2010
 
 #include "AliTPCCorrection.h"
 
@@ -53,7 +37,7 @@ public:
 
   // common setters and getters for ExB
   virtual void SetOmegaTauT1T2(Float_t omegaTau,Float_t t1,Float_t t2) {
-    fT1=t1; fT2=t2; 
+    fT1=t1; fT2=t2;
     const Float_t wt1=t1*omegaTau;     fC1=wt1/(1.+wt1*wt1);
     const Float_t wt2=t2*omegaTau;     fC2=wt2*wt2/(1.+wt2*wt2);
   };
@@ -73,13 +57,15 @@ protected:
   virtual void GetCorrection(const Float_t x[],const Short_t roc,Float_t dx[]);
 
 private:
-  Float_t fC1; // coefficient C1                 (compare Jim Thomas's notes for definitions)
-  Float_t fC2; // coefficient C2                 (compare Jim Thomas's notes for definitions)
+  Float_t fC1; ///< coefficient C1                 (compare Jim Thomas's notes for definitions)
+  Float_t fC2; ///< coefficient C2                 (compare Jim Thomas's notes for definitions)
 
-  Float_t fXTwist;               // Twist of E to B field in X-Z [rad]
-  Float_t fYTwist;               // Twist of E to B field in Y-Z [rad]
+  Float_t fXTwist;               ///< Twist of E to B field in X-Z [rad]
+  Float_t fYTwist;               ///< Twist of E to B field in Y-Z [rad]
 
+  /// \cond CLASSIMP
   ClassDef(AliTPCExBTwist,1);
+  /// \endcond
 };
 
 #endif
diff --git a/TPC/TPCbase/AliTPCFCVoltError3D.cxx b/TPC/TPCbase/AliTPCFCVoltError3D.cxx
index dd77326ed01..abc98e18f6e 100644
--- a/TPC/TPCbase/AliTPCFCVoltError3D.cxx
+++ b/TPC/TPCbase/AliTPCFCVoltError3D.cxx
@@ -13,60 +13,40 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-// _________________________________________________________________
-//
-// Begin_Html
-//   <h2>AliTPCFCVoltError3D class   </h2>       
-//   The class calculates the space point distortions due to residual voltage errors 
-//   on the Field Cage (FC) boundaries (rods and strips) of the TPC in 3D. It uses 
-//   the Poisson relaxation technique in three dimension as implemented in the parent class. 
-//   <p>
-//   Although the calculation is performed in 3D, the calculation time was significantly 
-//   reduced by using certain symmetry conditions within the calculation.
-//   <p>
-//   The input parameters can be set via the functions (e.g.) SetRodVoltShift(rod,dV) where 
-//   rod is the number of the rod on which the voltage offset dV is set. The corresponding 
-//   shift in z direction would be $dz=dV/40$ with an opposite sign for the C side. The 
-//   rods are numbered in anti-clock-wise direction starting at $\phi=0$. Rods in the IFC 
-//   are from 0 to 17, rods on the OFC go from 18 to 35. <br>
-//   This convention is following the offline numbering scheme of the ROCs.
-//   <p>
-//   Different misalignment scenarios can be modeled: 
-//   <ul>
-//   <li> A rotated clip scenario is only possible at two positions (Rod 11 at IFC, rod 3(+18) at OFC) 
-//        and can be set via SetRotatedClipVolt. The key feature is that at the mentioned positions,
-//        the strip-ends were combined. At these positions, a systematic offset of one strip-end in
-//        respect to the other is possible. 
-//   <li> A normal rod offset, where the strips follow the movement of the rod, can be set via 
-//        SetRodVoltShift. It has a anti-mirrored signature in terms of distortions when compared 
-//        to the rotated clip. This misalignment is possible at each single rod of the FC.
-//   <li> A simple rod offset, where the strips do not follow the shift, results in an even more 
-//        localized distortion close to the rod. The difference to a rod shift, where the strips follow,
-//        is more dominant on the OFC. This effect can be set via the function SetCopperRodShift.
-//   </ul>
-// End_Html
-//
-// Begin_Macro(source)
-//   {
-//   gROOT->SetStyle("Plain"); gStyle->SetPalette(1);
-//   TCanvas *c2 = new TCanvas("cAliTPCVoltError3D","cAliTPCVoltError3D",500,450); 
-//   AliTPCFCVoltError3D fc;
-//   fc.SetOmegaTauT1T2(0,1,1); 
-//   fc.SetRotatedClipVoltA(0,40);
-//   fc.SetRodVoltShiftA(3,40); 
-//   fc.SetCopperRodShiftA(7+18,40);
-//   fc.SetRodVoltShiftA(15+18,40); 
-//   fc.CreateHistoDRPhiinXY(10)->Draw("cont4z");
-//   return c2;
-//   } 
-// End_Macro
-//
-// Begin_Html
-//   <p>
-//   Date: 08/08/2010  <br>
-//   Authors: Jim Thomas, Stefan Rossegger  
-// End_Html 
-// _________________________________________________________________
+/// \class AliTPCFCVoltError3D
+/// \brief AliTPCFCVoltError3D class
+///
+/// The class calculates the space point distortions due to residual voltage errors
+/// on the Field Cage (FC) boundaries (rods and strips) of the TPC in 3D. It uses
+/// the Poisson relaxation technique in three dimension as implemented in the parent class.
+///
+/// Although the calculation is performed in 3D, the calculation time was significantly
+/// reduced by using certain symmetry conditions within the calculation.
+///
+/// The input parameters can be set via the functions (e.g.) SetRodVoltShift(rod,dV) where
+/// rod is the number of the rod on which the voltage offset dV is set. The corresponding
+/// shift in z direction would be $dz=dV/40$ with an opposite sign for the C side. The
+/// rods are numbered in anti-clock-wise direction starting at $\phi=0$. Rods in the IFC
+/// are from 0 to 17, rods on the OFC go from 18 to 35.
+/// This convention is following the offline numbering scheme of the ROCs.
+///
+/// Different misalignment scenarios can be modeled:
+/// <ul>
+/// <li> A rotated clip scenario is only possible at two positions (Rod 11 at IFC, rod 3(+18) at OFC)
+///     and can be set via SetRotatedClipVolt. The key feature is that at the mentioned positions,
+///     the strip-ends were combined. At these positions, a systematic offset of one strip-end in
+///     respect to the other is possible.
+/// <li> A normal rod offset, where the strips follow the movement of the rod, can be set via
+///     SetRodVoltShift. It has a anti-mirrored signature in terms of distortions when compared
+///     to the rotated clip. This misalignment is possible at each single rod of the FC.
+/// <li> A simple rod offset, where the strips do not follow the shift, results in an even more
+///     localized distortion close to the rod. The difference to a rod shift, where the strips follow,
+///     is more dominant on the OFC. This effect can be set via the function SetCopperRodShift.
+/// </ul>
+/// ![Picture from ROOT macro](AliTPCFCVoltError3D_cxx_ee7b060.png)
+///
+/// \author Jim Thomas, Stefan Rossegger
+/// \date 08/08/2010
 
 
 #include "AliMagF.h"
@@ -81,7 +61,9 @@
 #include "AliTPCROC.h"
 #include "AliTPCFCVoltError3D.h"
 
+/// \cond CLASSIMP
 ClassImp(AliTPCFCVoltError3D)
+/// \endcond
 
 AliTPCFCVoltError3D::AliTPCFCVoltError3D()
   : AliTPCCorrection("FieldCageVoltErrors","FieldCage (Rods) Voltage Errors"),
@@ -94,66 +76,64 @@ AliTPCFCVoltError3D::AliTPCFCVoltError3D()
 
   // flags for filled 'basic lookup tables'
   for (Int_t i=0; i<6; i++){
-    fInitLookUpBasic[i]= kFALSE;  
+    fInitLookUpBasic[i]= kFALSE;
   }
 
-  // Boundary settings 
+  // Boundary settings
   for (Int_t i=0; i<36; i++){
-    fRodVoltShiftA[i] = 0;  
-    fRodVoltShiftC[i] = 0;  
+    fRodVoltShiftA[i] = 0;
+    fRodVoltShiftC[i] = 0;
   }
   for (Int_t i=0; i<2; i++){
-    fRotatedClipVoltA[i] = 0;  
-    fRotatedClipVoltC[i] = 0;  
+    fRotatedClipVoltA[i] = 0;
+    fRotatedClipVoltC[i] = 0;
   }
-  // 
+  //
   for (Int_t i=0; i<36; i++){
-    fCopperRodShiftA[i] = 0;  
-    fCopperRodShiftC[i] = 0;  
+    fCopperRodShiftA[i] = 0;
+    fCopperRodShiftC[i] = 0;
   }
 
   // Array which will contain the solution according to the setted boundary conditions
   // it represents a sum up of the 4 basic look up tables (created individually)
   // see InitFCVoltError3D() function
   for ( Int_t k = 0 ; k < kNPhi ; k++ ) {
-    fLookUpErOverEz[k]   =  new TMatrixF(kNR,kNZ);  
+    fLookUpErOverEz[k]   =  new TMatrixF(kNR,kNZ);
     fLookUpEphiOverEz[k] =  new TMatrixF(kNR,kNZ);
-    fLookUpDeltaEz[k]    =  new TMatrixF(kNR,kNZ);   
+    fLookUpDeltaEz[k]    =  new TMatrixF(kNR,kNZ);
   }
-  
+
   for ( Int_t k = 0 ; k < kPhiSlices ; k++ ) {
     fLookUpBasic1ErOverEz[k]   = 0;
-    fLookUpBasic1EphiOverEz[k] = 0; 
+    fLookUpBasic1EphiOverEz[k] = 0;
     fLookUpBasic1DeltaEz[k]    = 0;
 
     fLookUpBasic2ErOverEz[k]   = 0;
-    fLookUpBasic2EphiOverEz[k] = 0; 
+    fLookUpBasic2EphiOverEz[k] = 0;
     fLookUpBasic2DeltaEz[k]    = 0;
 
     fLookUpBasic3ErOverEz[k]   = 0;
-    fLookUpBasic3EphiOverEz[k] = 0; 
+    fLookUpBasic3EphiOverEz[k] = 0;
     fLookUpBasic3DeltaEz[k]    = 0;
 
     fLookUpBasic4ErOverEz[k]   = 0;
-    fLookUpBasic4EphiOverEz[k] = 0; 
+    fLookUpBasic4EphiOverEz[k] = 0;
     fLookUpBasic4DeltaEz[k]    = 0;
-    
+
     fLookUpBasic5ErOverEz[k]   = 0;
-    fLookUpBasic5EphiOverEz[k] = 0; 
+    fLookUpBasic5EphiOverEz[k] = 0;
     fLookUpBasic5DeltaEz[k]    = 0;
 
     fLookUpBasic6ErOverEz[k]   = 0;
-    fLookUpBasic6EphiOverEz[k] = 0; 
+    fLookUpBasic6EphiOverEz[k] = 0;
     fLookUpBasic6DeltaEz[k]    = 0;
   }
 
 }
 
 AliTPCFCVoltError3D::~AliTPCFCVoltError3D() {
-  //
-  // destructor
-  //
-  
+  /// destructor
+
   for ( Int_t k = 0 ; k < kNPhi ; k++ ) {
     delete fLookUpErOverEz[k];
     delete fLookUpEphiOverEz[k];
@@ -162,43 +142,43 @@ AliTPCFCVoltError3D::~AliTPCFCVoltError3D() {
 
   for ( Int_t k = 0 ; k < kPhiSlices ; k++ ) {
     delete fLookUpBasic1ErOverEz[k];  // does nothing if pointer is zero!
-    delete fLookUpBasic1EphiOverEz[k]; 
-    delete fLookUpBasic1DeltaEz[k]; 
+    delete fLookUpBasic1EphiOverEz[k];
+    delete fLookUpBasic1DeltaEz[k];
 
     delete fLookUpBasic2ErOverEz[k];  // does nothing if pointer is zero!
-    delete fLookUpBasic2EphiOverEz[k]; 
-    delete fLookUpBasic2DeltaEz[k]; 
-    
+    delete fLookUpBasic2EphiOverEz[k];
+    delete fLookUpBasic2DeltaEz[k];
+
     delete fLookUpBasic3ErOverEz[k];  // does nothing if pointer is zero!
-    delete fLookUpBasic3EphiOverEz[k]; 
-    delete fLookUpBasic3DeltaEz[k]; 
+    delete fLookUpBasic3EphiOverEz[k];
+    delete fLookUpBasic3DeltaEz[k];
 
     delete fLookUpBasic4ErOverEz[k];  // does nothing if pointer is zero!
-    delete fLookUpBasic4EphiOverEz[k]; 
-    delete fLookUpBasic4DeltaEz[k]; 
+    delete fLookUpBasic4EphiOverEz[k];
+    delete fLookUpBasic4DeltaEz[k];
 
     delete fLookUpBasic5ErOverEz[k];  // does nothing if pointer is zero!
-    delete fLookUpBasic5EphiOverEz[k]; 
-    delete fLookUpBasic5DeltaEz[k]; 
+    delete fLookUpBasic5EphiOverEz[k];
+    delete fLookUpBasic5DeltaEz[k];
 
     delete fLookUpBasic6ErOverEz[k];  // does nothing if pointer is zero!
-    delete fLookUpBasic6EphiOverEz[k]; 
-    delete fLookUpBasic6DeltaEz[k]; 
+    delete fLookUpBasic6EphiOverEz[k];
+    delete fLookUpBasic6DeltaEz[k];
 
   }
 }
 
 
 Bool_t AliTPCFCVoltError3D::AddCorrectionCompact(AliTPCCorrection* corr, Double_t weight){
-  //
-  // Add correction  and make them compact
-  // Assumptions:
-  //  - origin of distortion/correction are additive
-  //  - only correction ot the same type supported ()
+  /// Add correction  and make them compact
+  /// Assumptions:
+  ///  - origin of distortion/correction are additive
+  ///  - only correction ot the same type supported ()
+
   if (corr==NULL) {
     AliError("Zerro pointer - correction");
     return kFALSE;
-  }  
+  }
   AliTPCFCVoltError3D * corrC = dynamic_cast<AliTPCFCVoltError3D *>(corr);
   if (corrC == NULL)  {
     AliError(TString::Format("Inconsistent class types: %s\%s",IsA()->GetName(),corr->IsA()->GetName()).Data());
@@ -206,12 +186,12 @@ Bool_t AliTPCFCVoltError3D::AddCorrectionCompact(AliTPCCorrection* corr, Double_
   }
   //
   for (Int_t isec=0; isec<36; isec++){
-    fRodVoltShiftA[isec]+= weight*corrC->fRodVoltShiftA[isec];      // Rod (&strips) shift in Volt (40V~1mm) 
-    fRodVoltShiftC[isec]+=weight*corrC->fRodVoltShiftC[isec];      // Rod (&strips) shift in Volt (40V~1mm) 
-    fCopperRodShiftA[isec]+=weight*corrC->fCopperRodShiftA[isec];    // only Rod shift 
-    fCopperRodShiftC[isec]+=weight*corrC->fCopperRodShiftC[isec];    // only Rod shift 
+    fRodVoltShiftA[isec]+= weight*corrC->fRodVoltShiftA[isec];      // Rod (&strips) shift in Volt (40V~1mm)
+    fRodVoltShiftC[isec]+=weight*corrC->fRodVoltShiftC[isec];      // Rod (&strips) shift in Volt (40V~1mm)
+    fCopperRodShiftA[isec]+=weight*corrC->fCopperRodShiftA[isec];    // only Rod shift
+    fCopperRodShiftC[isec]+=weight*corrC->fCopperRodShiftC[isec];    // only Rod shift
   }
-  for (Int_t isec=0; isec<2; isec++){  
+  for (Int_t isec=0; isec<2; isec++){
     fRotatedClipVoltA[isec]+= weight*corrC->fRotatedClipVoltA[isec];    // rotated clips at HV rod
     fRotatedClipVoltC[isec]+= weight*corrC-> fRotatedClipVoltC[isec];    // rotated clips at HV rod
   }
@@ -222,10 +202,8 @@ Bool_t AliTPCFCVoltError3D::AddCorrectionCompact(AliTPCCorrection* corr, Double_
 
 
 void AliTPCFCVoltError3D::Init() {
-  //
-  // Initialization funtion
-  //
-  
+  /// Initialization funtion
+
   AliMagF* magF= (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
   if (!magF) AliError("Magneticd field - not initialized");
   Double_t bzField = magF->SolenoidField()/10.; //field in T
@@ -233,7 +211,7 @@ void AliTPCFCVoltError3D::Init() {
   if (!param) AliError("Parameters - not initialized");
   Double_t vdrift = param->GetDriftV()/1000000.; // [cm/us]   // From dataBase: to be updated: per second (ideally)
   Double_t ezField = 400; // [V/cm]   // to be updated: never (hopefully)
-  Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ; 
+  Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ;
   // Correction Terms for effective omegaTau; obtained by a laser calibration run
   SetOmegaTauT1T2(wt,fT1,fT2);
 
@@ -241,9 +219,8 @@ void AliTPCFCVoltError3D::Init() {
 }
 
 void AliTPCFCVoltError3D::Update(const TTimeStamp &/*timeStamp*/) {
-  //
-  // Update function 
-  //
+  /// Update function
+
   AliMagF* magF= (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
   if (!magF) AliError("Magneticd field - not initialized");
   Double_t bzField = magF->SolenoidField()/10.; //field in T
@@ -251,7 +228,7 @@ void AliTPCFCVoltError3D::Update(const TTimeStamp &/*timeStamp*/) {
   if (!param) AliError("Parameters - not initialized");
   Double_t vdrift = param->GetDriftV()/1000000.; // [cm/us]  // From dataBase: to be updated: per second (ideally)
   Double_t ezField = 400; // [V/cm]   // to be updated: never (hopefully)
-  Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ; 
+  Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ;
   // Correction Terms for effective omegaTau; obtained by a laser calibration run
   SetOmegaTauT1T2(wt,fT1,fT2);
 
@@ -261,9 +238,8 @@ void AliTPCFCVoltError3D::Update(const TTimeStamp &/*timeStamp*/) {
 
 
 void AliTPCFCVoltError3D::GetCorrection(const Float_t x[],const Short_t roc,Float_t dx[]) {
-  //
-  // Calculates the correction due e.g. residual voltage errors on the TPC boundaries
-  //   
+  /// Calculates the correction due e.g. residual voltage errors on the TPC boundaries
+
   const Double_t kEpsilon=Double_t(FLT_MIN);
 
   if (!fInitLookUp) {
@@ -280,7 +256,7 @@ void AliTPCFCVoltError3D::GetCorrection(const Float_t x[],const Short_t roc,Floa
   }
 
 
-  Int_t   order     = 1 ;               // FIXME: hardcoded? Linear interpolation = 1, Quadratic = 2         
+  Int_t   order     = 1 ;               // FIXME: hardcoded? Linear interpolation = 1, Quadratic = 2
                                         // note that the poisson solution was linearly mirroed on this grid!
   Float_t intEr, intEphi, intDeltaEz;
   Float_t r, phi, z ;
@@ -296,59 +272,57 @@ void AliTPCFCVoltError3D::GetCorrection(const Float_t x[],const Short_t roc,Floa
   } else {
     sign = -1;       // (TPC C side)
   }
-  
+
   if ( sign==1  && z <  fgkZOffSet ) z =  fgkZOffSet;    // Protect against discontinuity at CE
   if ( sign==-1 && z > -fgkZOffSet ) z = -fgkZOffSet;    // Protect against discontinuity at CE
-  
+
 
   if ( (sign==1 && z<0) || (sign==-1 && z>0) ) // just a consistency check
     AliError("ROC number does not correspond to z coordinate! Calculation of distortions is most likely wrong!");
 
-  // Get the Er and Ephi field integrals plus the integral over DeltaEz 
-  intEr      = Interpolate3DTable(order, r, z, phi, kNR, kNZ, kNPhi, 
+  // Get the Er and Ephi field integrals plus the integral over DeltaEz
+  intEr      = Interpolate3DTable(order, r, z, phi, kNR, kNZ, kNPhi,
 				  fgkRList, fgkZList, fgkPhiList, fLookUpErOverEz  );
-  intEphi    = Interpolate3DTable(order, r, z, phi, kNR, kNZ, kNPhi, 
+  intEphi    = Interpolate3DTable(order, r, z, phi, kNR, kNZ, kNPhi,
 				  fgkRList, fgkZList, fgkPhiList, fLookUpEphiOverEz  );
-  intDeltaEz = Interpolate3DTable(order, r, z, phi, kNR, kNZ, kNPhi, 
+  intDeltaEz = Interpolate3DTable(order, r, z, phi, kNR, kNZ, kNPhi,
 				  fgkRList, fgkZList, fgkPhiList, fLookUpDeltaEz  );
 
   //  printf("%lf %lf %lf\n",intEr,intEphi,intDeltaEz);
 
   // Calculate distorted position
   if ( r > 0.0 ) {
-    phi =  phi + ( fC0*intEphi - fC1*intEr ) / r;      
-    r   =  r   + ( fC0*intEr   + fC1*intEphi );  
+    phi =  phi + ( fC0*intEphi - fC1*intEr ) / r;
+    r   =  r   + ( fC0*intEr   + fC1*intEphi );
   }
-  
+
   // Calculate correction in cartesian coordinates
   dx[0] = r * TMath::Cos(phi) - x[0];
-  dx[1] = r * TMath::Sin(phi) - x[1]; 
-  dx[2] = intDeltaEz;  // z distortion - (internally scaled with driftvelocity dependency 
+  dx[1] = r * TMath::Sin(phi) - x[1];
+  dx[2] = intDeltaEz;  // z distortion - (internally scaled with driftvelocity dependency
                        // on the Ez field plus the actual ROC misalignment (if set TRUE)
 
 }
 
 void AliTPCFCVoltError3D::InitFCVoltError3D() {
-  //
-  // Initialization of the Lookup table which contains the solutions of the 
-  // Dirichlet boundary problem
-  // Calculation of the single 3D-Poisson solver is done just if needed
-  // (see basic lookup tables in header file)
-  //
+  /// Initialization of the Lookup table which contains the solutions of the
+  /// Dirichlet boundary problem
+  /// Calculation of the single 3D-Poisson solver is done just if needed
+  /// (see basic lookup tables in header file)
 
-  const Int_t   order       =    1  ;  // Linear interpolation = 1, Quadratic = 2  
+  const Int_t   order       =    1  ;  // Linear interpolation = 1, Quadratic = 2
   const Float_t gridSizeR   =  (fgkOFCRadius-fgkIFCRadius) / (kRows-1) ;
   const Float_t gridSizeZ   =  fgkTPCZ0 / (kColumns-1) ;
   const Float_t gridSizePhi =  TMath::TwoPi() / ( 18.0 * kPhiSlicesPerSector);
 
   // temporary arrays to create the boundary conditions
-  TMatrixD *arrayofArrayV[kPhiSlices], *arrayofCharge[kPhiSlices] ; 
+  TMatrixD *arrayofArrayV[kPhiSlices], *arrayofCharge[kPhiSlices] ;
   for ( Int_t k = 0 ; k < kPhiSlices ; k++ ) {
     arrayofArrayV[k]     =   new TMatrixD(kRows,kColumns) ;
     arrayofCharge[k]     =   new TMatrixD(kRows,kColumns) ;
   }
   Double_t  innerList[kPhiSlices], outerList[kPhiSlices] ;
-  
+
   // list of point as used in the poisson relation and the interpolation (during sum up)
   Double_t  rlist[kRows], zedlist[kColumns] , philist[kPhiSlices];
   for ( Int_t k = 0 ; k < kPhiSlices ; k++ ) {
@@ -364,7 +338,7 @@ void AliTPCFCVoltError3D::InitFCVoltError3D() {
   // ==========================================================================
   // Solve Poisson's equation in 3D cylindrical coordinates by relaxation technique
   // Allow for different size grid spacing in R and Z directions
-  
+
   const Int_t   symmetry[6] =    {1,1,-1,-1,1,1}; // shifted rod (2x), rotated clip (2x), only rod shift on OFC (1x)
 
   // check which lookup tables are needed ---------------------------------
@@ -383,13 +357,13 @@ void AliTPCFCVoltError3D::InitFCVoltError3D() {
   // Rotated clips
   if (fRotatedClipVoltA[0]!=0 || fRotatedClipVoltC[0]!=0) needTable[2]=kTRUE;
   if (fRotatedClipVoltA[1]!=0 || fRotatedClipVoltC[1]!=0) needTable[3]=kTRUE;
- 
-  // shifted Copper rods 
+
+  // shifted Copper rods
   for ( Int_t rod = 0 ; rod < 18 ; rod++ ) {
     if (fCopperRodShiftA[rod]!=0) needTable[4]=kTRUE;
     if (fCopperRodShiftC[rod]!=0) needTable[4]=kTRUE;
   }
-  // shifted Copper rods 
+  // shifted Copper rods
   for ( Int_t rod = 18; rod < 36 ; rod++ ) {
     if (fCopperRodShiftA[rod]!=0) needTable[5]=kTRUE;
     if (fCopperRodShiftC[rod]!=0) needTable[5]=kTRUE;
@@ -445,48 +419,48 @@ void AliTPCFCVoltError3D::InitFCVoltError3D() {
       // will be deleted in destructor
     }
   }
- 
+
   // Set bondaries and solve Poisson's equation --------------------------
- 
+
   for (Int_t look=0; look<6; look++) {
-   
-    Float_t inner18[18] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } ;  
-    Float_t outer18[18] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } ; 
-  
+
+    Float_t inner18[18] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } ;
+    Float_t outer18[18] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } ;
+
     if (needTable[look] && !fInitLookUpBasic[look]) {
 
       // Specify which rod is the reference; other distortions calculated by summing over multiple rotations of refrence
       // Note: the interpolation later on depends on it!! Do not change if not really needed!
       if (look==0) {
 	AliInfo(Form("IFC - ROD&Strip shift : Filling table (~ %d sec)",3*(int)(kPhiSlices/5)));
-	inner18[0] = 1;  
+	inner18[0] = 1;
       } else if (look==1) {
 	AliInfo(Form("OFC - ROD&Strip shift : Filling table (~ %d sec)",3*(int)(kPhiSlices/5)));
-	outer18[0] = 1;  
+	outer18[0] = 1;
       } else if (look==2) {
 	AliInfo(Form("IFC - Clip rot. : Filling table (~ %d sec)",3*(int)(kPhiSlices/5)));
-	inner18[0] = 1; 
+	inner18[0] = 1;
       } else if (look==3) {
 	AliInfo(Form("OFC - Clip rot. : Filling table (~ %d sec)",3*(int)(kPhiSlices/5)));
-	outer18[0] = 1;  
+	outer18[0] = 1;
       } else if (look==4) {
 	AliInfo(Form("IFC - CopperRod shift : Filling table (~ %d sec)",3*(int)(kPhiSlices/5)));
-	inner18[0] = 1;  
+	inner18[0] = 1;
       } else if (look==5) {
 	AliInfo(Form("OFC - CopperRod shift : Filling table (~ %d sec)",3*(int)(kPhiSlices/5)));
-	outer18[0] = 1;  
+	outer18[0] = 1;
       }
       // Build potentials on boundary stripes for a rotated clip (SYMMETRY==-1) or a shifted rod (SYMMETRY==1)
       if (look<4) {
 	// in these cases, the strips follow the actual rod shift (linear interpolation between the rods)
 	for ( Int_t k = 0 ; k < kPhiSlices ; k++ ) {
 	  Int_t slices = kPhiSlicesPerSector ;
-	  Int_t ipoint = k/slices  ;  
+	  Int_t ipoint = k/slices  ;
 	  innerList[k] = (((ipoint+1)*slices-k)*inner18[ipoint]-(k-ipoint*slices)*inner18[ipoint+1])/slices ;
 	  outerList[k] = (((ipoint+1)*slices-k)*outer18[ipoint]-(k-ipoint*slices)*outer18[ipoint+1])/slices ;
-	  if ( (k%slices) == 0 && symmetry[look] == -1 ) { innerList[k] = 0.0 ; outerList[k] = 0.0 ; } 
+	  if ( (k%slices) == 0 && symmetry[look] == -1 ) { innerList[k] = 0.0 ; outerList[k] = 0.0 ; }
 	  // above, force Zero if Anti-Sym
-	} 
+	}
       } else if (look==4){
 	// in this case, we assume that the strips stay at the correct position, but the rods move
 	// the distortion is then much more localized around the rod (indicated by real data)
@@ -509,59 +483,59 @@ void AliTPCFCVoltError3D::InitFCVoltError3D() {
 	TMatrixD &charge    =  *arrayofCharge[k] ;
        	for ( Int_t i = 0 ; i < kRows ; i++ )    {
 	  for ( Int_t j = 0 ; j < kColumns ; j++ ) { // Fill Vmatrix with Boundary Conditions
-	    arrayV(i,j) = 0.0 ; 
+	    arrayV(i,j) = 0.0 ;
 	    charge(i,j) = 0.0 ;
-	    if ( i == 0 )       arrayV(i,j) = innerList[k] ; 
-	    if ( i == kRows-1 ) arrayV(i,j) = outerList[k] ; 
+	    if ( i == 0 )       arrayV(i,j) = innerList[k] ;
+	    if ( i == kRows-1 ) arrayV(i,j) = outerList[k] ;
 	  }
-	}      
+	}
 	// no charge in the volume
-	for ( Int_t i = 1 ; i < kRows-1 ; i++ )  { 
+	for ( Int_t i = 1 ; i < kRows-1 ; i++ )  {
 	  for ( Int_t j = 1 ; j < kColumns-1 ; j++ ) {
 	    charge(i,j)  =  0.0 ;
 	  }
 	}
-      }      
-     
+      }
+
       // Solve Poisson's equation in 3D cylindrical coordinates by relaxation technique
       // Allow for different size grid spacing in R and Z directions
       if (look==0) {
-	PoissonRelaxation3D( arrayofArrayV, arrayofCharge, 
+	PoissonRelaxation3D( arrayofArrayV, arrayofCharge,
 			     fLookUpBasic1ErOverEz, fLookUpBasic1EphiOverEz, fLookUpBasic1DeltaEz,
 			     kRows, kColumns, kPhiSlices, gridSizePhi, kIterations, symmetry[0]) ;
 	AliInfo("IFC - ROD&Strip shift : done ");
       } else if (look==1) {
-	PoissonRelaxation3D( arrayofArrayV, arrayofCharge, 
+	PoissonRelaxation3D( arrayofArrayV, arrayofCharge,
 			     fLookUpBasic2ErOverEz, fLookUpBasic2EphiOverEz, fLookUpBasic2DeltaEz,
 			     kRows, kColumns, kPhiSlices, gridSizePhi, kIterations, symmetry[1]) ;
-	
+
 	AliInfo("OFC - ROD&Strip shift : done ");
       } else if (look==2) {
-	PoissonRelaxation3D( arrayofArrayV, arrayofCharge, 
+	PoissonRelaxation3D( arrayofArrayV, arrayofCharge,
 			     fLookUpBasic3ErOverEz, fLookUpBasic3EphiOverEz, fLookUpBasic3DeltaEz,
 			     kRows, kColumns, kPhiSlices, gridSizePhi, kIterations, symmetry[2]) ;
 	AliInfo("IFC - Clip rot. : done ");
       } else if (look==3) {
-	PoissonRelaxation3D( arrayofArrayV, arrayofCharge, 
+	PoissonRelaxation3D( arrayofArrayV, arrayofCharge,
 			     fLookUpBasic4ErOverEz, fLookUpBasic4EphiOverEz, fLookUpBasic4DeltaEz,
 			     kRows, kColumns, kPhiSlices, gridSizePhi, kIterations, symmetry[3]) ;
 	AliInfo("OFC - Clip rot. : done ");
       } else if (look==4) {
-	PoissonRelaxation3D( arrayofArrayV, arrayofCharge, 
+	PoissonRelaxation3D( arrayofArrayV, arrayofCharge,
 			     fLookUpBasic5ErOverEz, fLookUpBasic5EphiOverEz, fLookUpBasic5DeltaEz,
 			     kRows, kColumns, kPhiSlices, gridSizePhi, kIterations, symmetry[4]) ;
 	AliInfo("IFC - CopperRod shift : done ");
       } else if (look==5) {
-	PoissonRelaxation3D( arrayofArrayV, arrayofCharge, 
+	PoissonRelaxation3D( arrayofArrayV, arrayofCharge,
 			     fLookUpBasic6ErOverEz, fLookUpBasic6EphiOverEz, fLookUpBasic6DeltaEz,
 			     kRows, kColumns, kPhiSlices, gridSizePhi, kIterations, symmetry[5]) ;
 	AliInfo("OFC - CopperRod shift : done ");
       }
-      
+
       fInitLookUpBasic[look] = kTRUE;
     }
   }
-  
+
 
   // =============================================================================
   // Create the final lookup table with corresponding ROD shifts or clip rotations
@@ -589,53 +563,53 @@ void AliTPCFCVoltError3D::InitFCVoltError3D() {
 
     for ( Int_t i = 0 ; i < kNZ ; i++ ) {
       z = TMath::Abs(fgkZList[i]) ;  // Symmetric solution in Z that depends only on ABS(Z)
-      for ( Int_t j = 0 ; j < kNR ; j++ ) { 
+      for ( Int_t j = 0 ; j < kNR ; j++ ) {
 	r = fgkRList[j] ;
 	// Interpolate basicLookup tables; once for each rod, then sum the results
-	
+
 	erIntegralSum   = 0.0 ;
 	ephiIntegralSum = 0.0 ;
 	ezIntegralSum   = 0.0 ;
- 
+
 	// SHIFTED RODS =========================================================
 
 	// IFC ROD SHIFTS +++++++++++++++++++++++++++++
 	for ( Int_t rod = 0 ; rod < 18 ; rod++ ) {
-	  
+
 	  erIntegral = ephiIntegral = ezIntegral = 0.0 ;
-	  
+
 	  if ( fRodVoltShiftA[rod] == 0 && fgkZList[i] > 0) continue ;
 	  if ( fRodVoltShiftC[rod] == 0 && fgkZList[i] < 0) continue ;
 
 	  // Rotate to a position where we have maps and prepare to sum
-	  phiPrime =  phi - rod*kPhiSlicesPerSector*gridSizePhi ;  
+	  phiPrime =  phi - rod*kPhiSlicesPerSector*gridSizePhi ;
 
-	  if ( phiPrime < 0 ) phiPrime += TMath::TwoPi() ;   // Stay in range from 0 to TwoPi    
+	  if ( phiPrime < 0 ) phiPrime += TMath::TwoPi() ;   // Stay in range from 0 to TwoPi
 
 	  if ( (phiPrime >= 0) && (phiPrime <= kPhiSlices*gridSizePhi) ) {
-	    
-	    erIntegral   = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices, 
+
+	    erIntegral   = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
 					      rlist, zedlist, philist, fLookUpBasic1ErOverEz  );
 	    ephiIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
 					      rlist, zedlist, philist, fLookUpBasic1EphiOverEz);
 	    ezIntegral   = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
 					      rlist, zedlist, philist, fLookUpBasic1DeltaEz   );
-	    
+
 	  }  else if ( (phiPrime <= TMath::TwoPi()) && (phiPrime >= (TMath::TwoPi()-kPhiSlices*gridSizePhi)) ){
-	    
+
 	    phiPrime     = TMath::TwoPi() - phiPrime ;
-	    
-	    erIntegral   = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices, 
+
+	    erIntegral   = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
 					      rlist, zedlist, philist, fLookUpBasic1ErOverEz  );
 	    ephiIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
 					      rlist, zedlist, philist, fLookUpBasic1EphiOverEz);
 	    ezIntegral   = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
 					      rlist, zedlist, philist, fLookUpBasic1DeltaEz   );
-	    
+
 	    // Flip symmetry of phi integral for symmetric boundary conditions
-	    if ( symmetry[0] ==  1 ) ephiIntegral *= -1  ;    
-	    // Flip symmetry of r integral if anti-symmetric boundary conditions 
-	    if ( symmetry[0] == -1 ) erIntegral   *= -1  ;    
+	    if ( symmetry[0] ==  1 ) ephiIntegral *= -1  ;
+	    // Flip symmetry of r integral if anti-symmetric boundary conditions
+	    if ( symmetry[0] == -1 ) erIntegral   *= -1  ;
 
 	  }
 
@@ -654,39 +628,39 @@ void AliTPCFCVoltError3D::InitFCVoltError3D() {
 	for ( Int_t rod = 18 ; rod < 36 ; rod++ ) {
 
 	  erIntegral = ephiIntegral = ezIntegral = 0.0 ;
-	  
+
 	  if ( fRodVoltShiftA[rod] == 0 && fgkZList[i] > 0) continue ;
 	  if ( fRodVoltShiftC[rod] == 0 && fgkZList[i] < 0) continue ;
 
 	  // Rotate to a position where we have maps and prepare to sum
-	  phiPrime =  phi - (rod-18)*kPhiSlicesPerSector*gridSizePhi ;  
-		  
-	  if ( phiPrime < 0 ) phiPrime += TMath::TwoPi() ;   // Stay in range from 0 to TwoPi    
+	  phiPrime =  phi - (rod-18)*kPhiSlicesPerSector*gridSizePhi ;
+
+	  if ( phiPrime < 0 ) phiPrime += TMath::TwoPi() ;   // Stay in range from 0 to TwoPi
 
 	  if ( (phiPrime >= 0) && (phiPrime <= kPhiSlices*gridSizePhi) ) {
-	    
-	    erIntegral   = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices, 
+
+	    erIntegral   = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
 					      rlist, zedlist, philist, fLookUpBasic2ErOverEz  );
 	    ephiIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
 					      rlist, zedlist, philist, fLookUpBasic2EphiOverEz);
 	    ezIntegral   = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
 					      rlist, zedlist, philist, fLookUpBasic2DeltaEz   );
-	    
+
 	  }  else if ( (phiPrime <= TMath::TwoPi()) && (phiPrime >= (TMath::TwoPi()-kPhiSlices*gridSizePhi)) ){
-	    
+
 	    phiPrime     = TMath::TwoPi() - phiPrime ;
-	    
-	    erIntegral   = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices, 
+
+	    erIntegral   = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
 					      rlist, zedlist, philist, fLookUpBasic2ErOverEz  );
 	    ephiIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
 					      rlist, zedlist, philist, fLookUpBasic2EphiOverEz);
 	    ezIntegral   = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
 					      rlist, zedlist, philist, fLookUpBasic2DeltaEz   );
-	    
+
 	    // Flip symmetry of phi integral for symmetric boundary conditions
-	    if ( symmetry[1] ==  1 ) ephiIntegral *= -1  ;    
-	    // Flip symmetry of r integral if anti-symmetric boundary conditions 
-	    if ( symmetry[1] == -1 ) erIntegral   *= -1  ;    
+	    if ( symmetry[1] ==  1 ) ephiIntegral *= -1  ;
+	    // Flip symmetry of r integral if anti-symmetric boundary conditions
+	    if ( symmetry[1] == -1 ) erIntegral   *= -1  ;
 
 	  }
 
@@ -717,37 +691,37 @@ void AliTPCFCVoltError3D::InitFCVoltError3D() {
 	  if ( fRotatedClipVoltC[0] == 0 && fgkZList[i] < 0) continue ;
 
 	  // Rotate to a position where we have maps and prepare to sum
-	  phiPrime =  phi - rod*kPhiSlicesPerSector*gridSizePhi ;  
-	  
-	  if ( phiPrime < 0 ) phiPrime += TMath::TwoPi() ;   // Stay in range from 0 to TwoPi    
-	  
+	  phiPrime =  phi - rod*kPhiSlicesPerSector*gridSizePhi ;
+
+	  if ( phiPrime < 0 ) phiPrime += TMath::TwoPi() ;   // Stay in range from 0 to TwoPi
+
 	  if ( (phiPrime >= 0) && (phiPrime <= kPhiSlices*gridSizePhi) ) {
-	    
-	    erIntegral   = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices, 
+
+	    erIntegral   = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
 					      rlist, zedlist, philist, fLookUpBasic3ErOverEz  );
 	    ephiIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
 					      rlist, zedlist, philist, fLookUpBasic3EphiOverEz);
 	    ezIntegral   = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
 					      rlist, zedlist, philist, fLookUpBasic3DeltaEz   );
-	    
+
 	  }  else if ( (phiPrime <= TMath::TwoPi()) && (phiPrime >= (TMath::TwoPi()-kPhiSlices*gridSizePhi)) ){
-	    
+
 	    phiPrime     = TMath::TwoPi() - phiPrime ;
-	    
-	    erIntegral   = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices, 
+
+	    erIntegral   = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
 					      rlist, zedlist, philist, fLookUpBasic3ErOverEz  );
 	    ephiIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
 					      rlist, zedlist, philist, fLookUpBasic3EphiOverEz);
 	    ezIntegral   = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
 					      rlist, zedlist, philist, fLookUpBasic3DeltaEz   );
-	    
+
 	    // Flip symmetry of phi integral for symmetric boundary conditions
-	    if ( symmetry[2] ==  1 ) ephiIntegral *= -1  ;    
-	    // Flip symmetry of r integral if anti-symmetric boundary conditions 
-	    if ( symmetry[2] == -1 ) erIntegral   *= -1  ;    
-	    
+	    if ( symmetry[2] ==  1 ) ephiIntegral *= -1  ;
+	    // Flip symmetry of r integral if anti-symmetric boundary conditions
+	    if ( symmetry[2] == -1 ) erIntegral   *= -1  ;
+
 	  }
-	  
+
 	  if ( fgkZList[i] > 0 ) {
 	    erIntegralSum   += fRotatedClipVoltA[0]*erIntegral   ;
 	    ephiIntegralSum += fRotatedClipVoltA[0]*ephiIntegral ;
@@ -761,45 +735,45 @@ void AliTPCFCVoltError3D::InitFCVoltError3D() {
 
 	// OFC: ROTATED CLIP  +++++++++++++++++++++++++++++
 	for ( Int_t rod = rodOFC ; rod < rodOFC+1 ; rod++ ) { // loop over 1 to keep the "ignore"-functionality
-	  
+
 	  erIntegral = ephiIntegral = ezIntegral = 0.0 ;
-	  
+
 	  if ( fRotatedClipVoltA[1] == 0 && fgkZList[i] > 0) continue ;
 	  if ( fRotatedClipVoltC[1] == 0 && fgkZList[i] < 0) continue ;
 
 	  // Rotate to a position where we have maps and prepare to sum
-	  phiPrime =  phi - rod*kPhiSlicesPerSector*gridSizePhi ;  
-	  
-	  
-	  if ( phiPrime < 0 ) phiPrime += TMath::TwoPi() ;   // Stay in range from 0 to TwoPi    
-	  
+	  phiPrime =  phi - rod*kPhiSlicesPerSector*gridSizePhi ;
+
+
+	  if ( phiPrime < 0 ) phiPrime += TMath::TwoPi() ;   // Stay in range from 0 to TwoPi
+
 	  if ( (phiPrime >= 0) && (phiPrime <= kPhiSlices*gridSizePhi) ) {
-	    
-	    erIntegral   = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices, 
+
+	    erIntegral   = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
 					      rlist, zedlist, philist, fLookUpBasic4ErOverEz  );
 	    ephiIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
 					      rlist, zedlist, philist, fLookUpBasic4EphiOverEz);
 	    ezIntegral   = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
 					      rlist, zedlist, philist, fLookUpBasic4DeltaEz   );
-	    
+
 	  }  else if ( (phiPrime <= TMath::TwoPi()) && (phiPrime >= (TMath::TwoPi()-kPhiSlices*gridSizePhi)) ){
-	    
+
 	    phiPrime     = TMath::TwoPi() - phiPrime ;
-	    
-	    erIntegral   = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices, 
+
+	    erIntegral   = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
 					      rlist, zedlist, philist, fLookUpBasic4ErOverEz  );
 	    ephiIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
 					      rlist, zedlist, philist, fLookUpBasic4EphiOverEz);
 	    ezIntegral   = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
 					      rlist, zedlist, philist, fLookUpBasic4DeltaEz   );
-	    
+
 	    // Flip symmetry of phi integral for symmetric boundary conditions
-	    if ( symmetry[3] ==  1 ) ephiIntegral *= -1  ;    
-	    // Flip symmetry of r integral if anti-symmetric boundary conditions 
-	    if ( symmetry[3] == -1 ) erIntegral   *= -1  ;    
-	    
+	    if ( symmetry[3] ==  1 ) ephiIntegral *= -1  ;
+	    // Flip symmetry of r integral if anti-symmetric boundary conditions
+	    if ( symmetry[3] == -1 ) erIntegral   *= -1  ;
+
 	  }
-	  
+
 	  if ( fgkZList[i] > 0 ) {
 	    erIntegralSum   += fRotatedClipVoltA[1]*erIntegral   ;
 	    ephiIntegralSum += fRotatedClipVoltA[1]*ephiIntegral ;
@@ -813,41 +787,41 @@ void AliTPCFCVoltError3D::InitFCVoltError3D() {
 
 	// IFC Cooper rod shift  +++++++++++++++++++++++++++++
 	for ( Int_t rod = 0 ; rod < 18 ; rod++ ) {
-	  
+
 	  erIntegral = ephiIntegral = ezIntegral = 0.0 ;
-	  
+
 	  if ( fCopperRodShiftA[rod] == 0 && fgkZList[i] > 0) continue ;
 	  if ( fCopperRodShiftC[rod] == 0 && fgkZList[i] < 0) continue ;
 
 	  // Rotate to a position where we have maps and prepare to sum
-	  phiPrime =  phi - rod*kPhiSlicesPerSector*gridSizePhi ;  
+	  phiPrime =  phi - rod*kPhiSlicesPerSector*gridSizePhi ;
 
-	  if ( phiPrime < 0 ) phiPrime += TMath::TwoPi() ;   // Stay in range from 0 to TwoPi    
+	  if ( phiPrime < 0 ) phiPrime += TMath::TwoPi() ;   // Stay in range from 0 to TwoPi
 
 	  if ( (phiPrime >= 0) && (phiPrime <= kPhiSlices*gridSizePhi) ) {
-	    
-	    erIntegral   = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices, 
+
+	    erIntegral   = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
 					      rlist, zedlist, philist, fLookUpBasic5ErOverEz  );
 	    ephiIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
 					      rlist, zedlist, philist, fLookUpBasic5EphiOverEz);
 	    ezIntegral   = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
 					      rlist, zedlist, philist, fLookUpBasic5DeltaEz   );
-	    
+
 	  }  else if ( (phiPrime <= TMath::TwoPi()) && (phiPrime >= (TMath::TwoPi()-kPhiSlices*gridSizePhi)) ){
-	    
+
 	    phiPrime     = TMath::TwoPi() - phiPrime ;
-	    
-	    erIntegral   = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices, 
+
+	    erIntegral   = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
 					      rlist, zedlist, philist, fLookUpBasic5ErOverEz  );
 	    ephiIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
 					      rlist, zedlist, philist, fLookUpBasic5EphiOverEz);
 	    ezIntegral   = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
 					      rlist, zedlist, philist, fLookUpBasic5DeltaEz   );
-	    
+
 	    // Flip symmetry of phi integral for symmetric boundary conditions
-	    if ( symmetry[4] ==  1 ) ephiIntegral *= -1  ;    
-	    // Flip symmetry of r integral if anti-symmetric boundary conditions 
-	    if ( symmetry[4] == -1 ) erIntegral   *= -1  ;    
+	    if ( symmetry[4] ==  1 ) ephiIntegral *= -1  ;
+	    // Flip symmetry of r integral if anti-symmetric boundary conditions
+	    if ( symmetry[4] == -1 ) erIntegral   *= -1  ;
 
 	  }
 
@@ -864,41 +838,41 @@ void AliTPCFCVoltError3D::InitFCVoltError3D() {
 
 	// OFC Cooper rod shift  +++++++++++++++++++++++++++++
 	for ( Int_t rod = 18 ; rod < 36 ; rod++ ) {
-	  
+
 	  erIntegral = ephiIntegral = ezIntegral = 0.0 ;
-	  
+
 	  if ( fCopperRodShiftA[rod] == 0 && fgkZList[i] > 0) continue ;
 	  if ( fCopperRodShiftC[rod] == 0 && fgkZList[i] < 0) continue ;
 
 	  // Rotate to a position where we have maps and prepare to sum
-	  phiPrime =  phi - (rod-18)*kPhiSlicesPerSector*gridSizePhi ;  
+	  phiPrime =  phi - (rod-18)*kPhiSlicesPerSector*gridSizePhi ;
 
-	  if ( phiPrime < 0 ) phiPrime += TMath::TwoPi() ;   // Stay in range from 0 to TwoPi    
+	  if ( phiPrime < 0 ) phiPrime += TMath::TwoPi() ;   // Stay in range from 0 to TwoPi
 
 	  if ( (phiPrime >= 0) && (phiPrime <= kPhiSlices*gridSizePhi) ) {
-	    
-	    erIntegral   = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices, 
+
+	    erIntegral   = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
 					      rlist, zedlist, philist, fLookUpBasic6ErOverEz  );
 	    ephiIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
 					      rlist, zedlist, philist, fLookUpBasic6EphiOverEz);
 	    ezIntegral   = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
 					      rlist, zedlist, philist, fLookUpBasic6DeltaEz   );
-	    
+
 	  }  else if ( (phiPrime <= TMath::TwoPi()) && (phiPrime >= (TMath::TwoPi()-kPhiSlices*gridSizePhi)) ){
-	    
+
 	    phiPrime     = TMath::TwoPi() - phiPrime ;
-	    
-	    erIntegral   = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices, 
+
+	    erIntegral   = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
 					      rlist, zedlist, philist, fLookUpBasic6ErOverEz  );
 	    ephiIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
 					      rlist, zedlist, philist, fLookUpBasic6EphiOverEz);
 	    ezIntegral   = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
 					      rlist, zedlist, philist, fLookUpBasic6DeltaEz   );
-	    
+
 	    // Flip symmetry of phi integral for symmetric boundary conditions
-	    if ( symmetry[5] ==  1 ) ephiIntegral *= -1  ;    
-	    // Flip symmetry of r integral if anti-symmetric boundary conditions 
-	    if ( symmetry[5] == -1 ) erIntegral   *= -1  ;    
+	    if ( symmetry[5] ==  1 ) ephiIntegral *= -1  ;
+	    // Flip symmetry of r integral if anti-symmetric boundary conditions
+	    if ( symmetry[5] == -1 ) erIntegral   *= -1  ;
 
 	  }
 
@@ -917,9 +891,9 @@ void AliTPCFCVoltError3D::InitFCVoltError3D() {
 	erOverEz(j,i)   =  erIntegralSum;
 	ephiOverEz(j,i) =  ephiIntegralSum;
 	deltaEz(j,i)    =  ezIntegralSum;
-	
+
 	//	if (j==1) printf("%lf %lf %lf: %lf %lf %lf\n",r, phi, z, erIntegralSum,ephiIntegralSum,ezIntegralSum);
- 
+
       } // endo r loop
     } // end of z loop
   } // end of phi loop
@@ -930,85 +904,83 @@ void AliTPCFCVoltError3D::InitFCVoltError3D() {
     delete arrayofArrayV[k];
     delete arrayofCharge[k];
   }
- 
+
   AliInfo(" done");
   fInitLookUp = kTRUE;
 
 }
 
 void AliTPCFCVoltError3D::Print(const Option_t* option) const {
-  //
-  // Print function to check the settings of the Rod shifts and the rotated clips
-  // option=="a" prints the C0 and C1 coefficents for calibration purposes
-  //
+  /// Print function to check the settings of the Rod shifts and the rotated clips
+  /// option=="a" prints the C0 and C1 coefficents for calibration purposes
 
   TString opt = option; opt.ToLower();
   printf("%s\n",GetTitle());
   printf(" - ROD shifts  (residual voltage settings): 40V correspond to 1mm of shift\n");
   Int_t count = 0;
-  printf("  : A-side - (Rod & Strips) \n     "); 
+  printf("  : A-side - (Rod & Strips) \n     ");
   for (Int_t i=0; i<36;i++) {
     if (fRodVoltShiftA[i]!=0) {
       printf("Rod%2d:%3.1fV ",i,fRodVoltShiftA[i]);
       count++;
     }
-    if (count==0&&i==35) 
+    if (count==0&&i==35)
       printf("-> all at 0 V\n");
     else if (i==35){
       printf("\n");
       count=0;
     }
-  } 
-  printf("  : C-side - (Rod & Strips) \n     "); 
+  }
+  printf("  : C-side - (Rod & Strips) \n     ");
   for (Int_t i=0; i<36;i++) {
     if (fRodVoltShiftC[i]!=0) {
       printf("Rod%2d:%3.1fV ",i,fRodVoltShiftC[i]);
       count++;
     }
-    if (count==0&&i==35) 
+    if (count==0&&i==35)
       printf("-> all at 0 V\n");
     else if (i==35){
       printf("\n");
       count=0;
     }
-  } 
- 
+  }
+
   printf(" - Rotated clips (residual voltage settings): 40V correspond to 1mm of 'offset'\n");
   if (fRotatedClipVoltA[0]!=0) {   printf("     A side (IFC): HV Rod: %3.1f V \n",fRotatedClipVoltA[0]); count++; }
   if (fRotatedClipVoltA[1]!=0) {   printf("     A side (OFC): HV Rod: %3.1f V \n",fRotatedClipVoltA[1]); count++; }
   if (fRotatedClipVoltC[0]!=0) {   printf("     C side (IFC): HV Rod: %3.1f V \n",fRotatedClipVoltC[0]); count++; }
   if (fRotatedClipVoltC[1]!=0) {   printf("     C side (OFC): HV Rod: %3.1f V \n",fRotatedClipVoltC[1]); count++; }
-  if (count==0) 
+  if (count==0)
     printf("     -> no rotated clips \n");
 
   count=0;
   printf(" - Copper ROD shifts (without strips):\n");
-  printf("  : A-side - (Copper Rod shift) \n     "); 
+  printf("  : A-side - (Copper Rod shift) \n     ");
   for (Int_t i=0; i<36;i++) {
     if (fCopperRodShiftA[i]!=0) {
       printf("Rod%2d:%3.1fV ",i,fCopperRodShiftA[i]);
       count++;
     }
-    if (count==0&&i==35) 
+    if (count==0&&i==35)
       printf("-> all at 0 V\n");
     else if (i==35){
       printf("\n");
       count=0;
     }
-  } 
-  printf("  : C-side - (Copper Rod shift) \n     "); 
+  }
+  printf("  : C-side - (Copper Rod shift) \n     ");
   for (Int_t i=0; i<36;i++) {
     if (fCopperRodShiftC[i]!=0) {
       printf("Rod%2d:%3.1fV ",i,fCopperRodShiftC[i]);
       count++;
     }
-    if (count==0&&i==35) 
+    if (count==0&&i==35)
       printf("-> all at 0 V\n");
     else if (i==35){
       printf("\n");
       count=0;
     }
-  } 
+  }
 
   if (opt.Contains("a")) { // Print all details
     printf(" - T1: %1.4f, T2: %1.4f \n",fT1,fT2);
diff --git a/TPC/TPCbase/AliTPCFCVoltError3D.h b/TPC/TPCbase/AliTPCFCVoltError3D.h
index 1ca4a0c19d2..4c68017f0cd 100644
--- a/TPC/TPCbase/AliTPCFCVoltError3D.h
+++ b/TPC/TPCbase/AliTPCFCVoltError3D.h
@@ -4,10 +4,10 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-////////////////////////////////////////////////////////////////////////////
-// AliTPCFCVoltError3D class                                              //
-// Authors: Jim Thomas, Stefan Rossegger                                  //
-////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCFCVoltError3D
+/// \brief AliTPCFCVoltError3D class
+///
+/// \author Jim Thomas, Stefan Rossegger
 
 #include "AliTPCCorrection.h"
 
@@ -31,7 +31,7 @@ public:
   Float_t GetC0() const {return fC0;}
   Float_t GetC1() const {return fC1;}
 
-  // setters and getters 
+  // setters and getters
 
   // Set rod shift in Voltage equivalents (40V ~ 1mm)
   // rod numbers: 0-17 (IFC), 18-35 (OFC)
@@ -72,62 +72,64 @@ private:
   AliTPCFCVoltError3D(const AliTPCFCVoltError3D &);               // not implemented
   AliTPCFCVoltError3D &operator=(const AliTPCFCVoltError3D &);    // not implemented
 
-  Float_t fC0; // coefficient C0           (compare Jim Thomas's notes for definitions)
-  Float_t fC1; // coefficient C1           (compare Jim Thomas's notes for definitions)
-  Float_t fRodVoltShiftA[36];      // Rod (&strips) shift in Volt (40V~1mm) 
-  Float_t fRodVoltShiftC[36];      // Rod (&strips) shift in Volt (40V~1mm) 
-  Float_t fRotatedClipVoltA[2];    // rotated clips at HV rod
-  Float_t fRotatedClipVoltC[2];    // rotated clips at HV rod
-  Float_t fCopperRodShiftA[36];    // only Rod shift 
-  Float_t fCopperRodShiftC[36];    // only Rod shift 
+  Float_t fC0; ///< coefficient C0           (compare Jim Thomas's notes for definitions)
+  Float_t fC1; ///< coefficient C1           (compare Jim Thomas's notes for definitions)
+  Float_t fRodVoltShiftA[36];      ///< Rod (&strips) shift in Volt (40V~1mm)
+  Float_t fRodVoltShiftC[36];      ///< Rod (&strips) shift in Volt (40V~1mm)
+  Float_t fRotatedClipVoltA[2];    ///< rotated clips at HV rod
+  Float_t fRotatedClipVoltC[2];    ///< rotated clips at HV rod
+  Float_t fCopperRodShiftA[36];    ///< only Rod shift
+  Float_t fCopperRodShiftC[36];    ///< only Rod shift
 
-  Bool_t fInitLookUp;           // flag to check if the Look Up table was created (SUM)
-  Bool_t fInitLookUpBasic[6];   // ! flag if the basic lookup was created (shifted Rod (IFC,OFC) or rotated clip (IFC,OFC))
+  Bool_t fInitLookUp;           ///< flag to check if the Look Up table was created (SUM)
+  Bool_t fInitLookUpBasic[6];   //!< flag if the basic lookup was created (shifted Rod (IFC,OFC) or rotated clip (IFC,OFC))
 
 
-  TMatrixF *fLookUpErOverEz[kNPhi];   // Array to store electric field integral (int Er/Ez)
-  TMatrixF *fLookUpEphiOverEz[kNPhi]; // Array to store electric field integral (int Er/Ez)
-  TMatrixF *fLookUpDeltaEz[kNPhi];    // Array to store electric field integral (int Er/Ez)
+  TMatrixF *fLookUpErOverEz[kNPhi];   ///< Array to store electric field integral (int Er/Ez)
+  TMatrixF *fLookUpEphiOverEz[kNPhi]; ///< Array to store electric field integral (int Er/Ez)
+  TMatrixF *fLookUpDeltaEz[kNPhi];    ///< Array to store electric field integral (int Er/Ez)
 
   // basic numbers for the poisson relaxation //can be set individually in each class
   enum {kRows   =257}; // grid size in r direction used in the poisson relaxation // ( 2**n + 1 ) eg. 65, 129, 257 etc.
   enum {kColumns=129}; // grid size in z direction used in the poisson relaxation // ( 2**m + 1 ) eg. 65, 129, 257 etc.
   enum {kPhiSlicesPerSector = 10 }; // number of points in phi slices
   enum {kPhiSlices = 1+kPhiSlicesPerSector*3 };      // number of points in phi for the basic lookup tables
-  enum {kIterations=100}; // Number of iterations within the poisson relaxation 
+  enum {kIterations=100}; // Number of iterations within the poisson relaxation
 
   // ugly way to store "partial" look up tables
   // needed for the faster calculation of the final distortion table
 
   // for Rod and Strip shift
-  TMatrixD *fLookUpBasic1ErOverEz[kPhiSlices];   // ! Array to store electric field integral (int Er/Ez)
-  TMatrixD *fLookUpBasic1EphiOverEz[kPhiSlices]; // ! Array to store electric field integral (int Ephi/Ez)
-  TMatrixD *fLookUpBasic1DeltaEz[kPhiSlices];    // ! Array to store electric field integral (int Ez)
+  TMatrixD *fLookUpBasic1ErOverEz[kPhiSlices];   //!< Array to store electric field integral (int Er/Ez)
+  TMatrixD *fLookUpBasic1EphiOverEz[kPhiSlices]; //!< Array to store electric field integral (int Ephi/Ez)
+  TMatrixD *fLookUpBasic1DeltaEz[kPhiSlices];    //!< Array to store electric field integral (int Ez)
 
-  TMatrixD *fLookUpBasic2ErOverEz[kPhiSlices];   // ! Array to store electric field integral 
-  TMatrixD *fLookUpBasic2EphiOverEz[kPhiSlices]; // ! Array to store electric field integral 
-  TMatrixD *fLookUpBasic2DeltaEz[kPhiSlices];    // ! Array to store electric field integral 
+  TMatrixD *fLookUpBasic2ErOverEz[kPhiSlices];   //!< Array to store electric field integral
+  TMatrixD *fLookUpBasic2EphiOverEz[kPhiSlices]; //!< Array to store electric field integral
+  TMatrixD *fLookUpBasic2DeltaEz[kPhiSlices];    //!< Array to store electric field integral
 
   // for rotated clips
-  TMatrixD *fLookUpBasic3ErOverEz[kPhiSlices];   // ! Array to store electric field integral 
-  TMatrixD *fLookUpBasic3EphiOverEz[kPhiSlices]; // ! Array to store electric field integral 
-  TMatrixD *fLookUpBasic3DeltaEz[kPhiSlices];    // ! Array to store electric field integral 
+  TMatrixD *fLookUpBasic3ErOverEz[kPhiSlices];   //!< Array to store electric field integral
+  TMatrixD *fLookUpBasic3EphiOverEz[kPhiSlices]; //!< Array to store electric field integral
+  TMatrixD *fLookUpBasic3DeltaEz[kPhiSlices];    //!< Array to store electric field integral
 
-  TMatrixD *fLookUpBasic4ErOverEz[kPhiSlices];   // ! Array to store electric field integral 
-  TMatrixD *fLookUpBasic4EphiOverEz[kPhiSlices]; // ! Array to store electric field integral 
-  TMatrixD *fLookUpBasic4DeltaEz[kPhiSlices];    // ! Array to store electric field integral 
+  TMatrixD *fLookUpBasic4ErOverEz[kPhiSlices];   //!< Array to store electric field integral
+  TMatrixD *fLookUpBasic4EphiOverEz[kPhiSlices]; //!< Array to store electric field integral
+  TMatrixD *fLookUpBasic4DeltaEz[kPhiSlices];    //!< Array to store electric field integral
 
   // for (only rod) shift (copper rods)
-  TMatrixD *fLookUpBasic5ErOverEz[kPhiSlices];   // ! Array to store electric field integral 
-  TMatrixD *fLookUpBasic5EphiOverEz[kPhiSlices]; // ! Array to store electric field integral 
-  TMatrixD *fLookUpBasic5DeltaEz[kPhiSlices];    // ! Array to store electric field integral 
+  TMatrixD *fLookUpBasic5ErOverEz[kPhiSlices];   //!< Array to store electric field integral
+  TMatrixD *fLookUpBasic5EphiOverEz[kPhiSlices]; //!< Array to store electric field integral
+  TMatrixD *fLookUpBasic5DeltaEz[kPhiSlices];    //!< Array to store electric field integral
 
-  TMatrixD *fLookUpBasic6ErOverEz[kPhiSlices];   // ! Array to store electric field integral 
-  TMatrixD *fLookUpBasic6EphiOverEz[kPhiSlices]; // ! Array to store electric field integral 
-  TMatrixD *fLookUpBasic6DeltaEz[kPhiSlices];    // ! Array to store electric field integral 
+  TMatrixD *fLookUpBasic6ErOverEz[kPhiSlices];   //!< Array to store electric field integral
+  TMatrixD *fLookUpBasic6EphiOverEz[kPhiSlices]; //!< Array to store electric field integral
+  TMatrixD *fLookUpBasic6DeltaEz[kPhiSlices];    //!< Array to store electric field integral
 
 
+  /// \cond CLASSIMP
   ClassDef(AliTPCFCVoltError3D,3); //
+  /// \endcond
 };
 
 #endif
diff --git a/TPC/TPCbase/AliTPCGGVoltError.cxx b/TPC/TPCbase/AliTPCGGVoltError.cxx
index 27b47a105a2..f137f3ae31c 100644
--- a/TPC/TPCbase/AliTPCGGVoltError.cxx
+++ b/TPC/TPCbase/AliTPCGGVoltError.cxx
@@ -13,9 +13,8 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-////////////////////////////////////////////////////////////////////////////
-// AliTPCGGVoltError class                                                //
-////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCGGVoltError
+/// \brief AliTPCGGVoltError class
 
 
 #include "AliMagF.h"
@@ -33,21 +32,18 @@ AliTPCGGVoltError::AliTPCGGVoltError()
     fDeltaVGGA(0.),fDeltaVGGC(0.),
     fInitLookUp(kFALSE)
 {
-  //
-  // default constructor
-  //
+  /// default constructor
+
 }
 
 AliTPCGGVoltError::~AliTPCGGVoltError() {
-  //
-  // default destructor
-  //
+  /// default destructor
+
 }
 
 void AliTPCGGVoltError::Init() {
-  //
-  // Init function
-  //
+  /// Init function
+
   AliMagF* magF= (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
   if (!magF) AliError("Magneticd field - not initialized");
   Double_t bzField = magF->SolenoidField()/10.; //field in T
@@ -55,7 +51,7 @@ void AliTPCGGVoltError::Init() {
   if (!param) AliError("Parameters - not initialized");
   Double_t vdrift = param->GetDriftV()/1000000.; // [cm/us]   // From dataBase: to be updated: per second (ideally)
   Double_t ezField = 400; // [V/cm]   // to be updated: never (hopefully)
-  Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ; 
+  Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ;
   //
   SetOmegaTauT1T2(wt,fT1,fT2);
   InitGGVoltErrorDistortion();
@@ -64,9 +60,8 @@ void AliTPCGGVoltError::Init() {
 }
 
 void AliTPCGGVoltError::Update(const TTimeStamp &/*timeStamp*/) {
-  //
-  // Update function
-  //
+  /// Update function
+
   AliMagF* magF= (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
   if (!magF) AliError("Magneticd field - not initialized");
   Double_t bzField = magF->SolenoidField()/10.; //field in T
@@ -74,7 +69,7 @@ void AliTPCGGVoltError::Update(const TTimeStamp &/*timeStamp*/) {
   if (!param) AliError("Parameters - not initialized");
   Double_t vdrift = param->GetDriftV()/1000000.; // [cm/us]   // From dataBase: to be updated: per second (ideally)
   Double_t ezField = 400; // [V/cm]   // to be updated: never (hopefully)
-  Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ; 
+  Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ;
 
   SetOmegaTauT1T2(wt,fT1,fT2);
   //  InitGGVoltErrorDistortion(); // not necessary in here since the Voltage should not change!
@@ -84,35 +79,33 @@ void AliTPCGGVoltError::Update(const TTimeStamp &/*timeStamp*/) {
 
 void AliTPCGGVoltError::GetCorrection(const Float_t x[],const Short_t roc,Float_t dx[]) {
 
-  //
-  // Gated Grid Voltage Error
-  //
-  // Calculates the effect of having an incorrect voltage on the A or C end plate Gated Grids.
-  //
-  // Electrostatic Equations from StarNote SN0253 by Howard Wieman.
-  //
-  
+  /// Gated Grid Voltage Error
+  ///
+  /// Calculates the effect of having an incorrect voltage on the A or C end plate Gated Grids.
+  ///
+  /// Electrostatic Equations from StarNote SN0253 by Howard Wieman.
+
   if (!fInitLookUp) AliError("Lookup table was not initialized! You should do InitGGVoltErrorDistortion() ...");
-  
-  Int_t   order     = 1 ;               // FIXME: hardcoded? Linear interpolation = 1, Quadratic = 2         
- 
+
+  Int_t   order     = 1 ;               // FIXME: hardcoded? Linear interpolation = 1, Quadratic = 2
+
   Double_t intEr, intEphi ;
   Double_t r, phi, z ;
   Int_t    sign ;
 
   Double_t deltaVGG;
-  
+
   r   = TMath::Sqrt( x[0]*x[0] + x[1]*x[1] );
   phi = TMath::ATan2(x[1],x[0]);
   if ( phi < 0 ) phi += TMath::TwoPi();                   // Table uses phi from 0 to 2*Pi
   z   = x[2] ;
 
   if ( (roc%36) < 18 ) {
-    sign =  1; 
+    sign =  1;
     deltaVGG = fDeltaVGGA;           // (TPC End A)
   } else {
     sign = -1;                       // (TPC End C)
-    deltaVGG = fDeltaVGGC; 
+    deltaVGG = fDeltaVGGC;
   }
 
   if ( sign==1  && z <  fgkZOffSet ) z =  fgkZOffSet;    // Protect against discontinuity at CE
@@ -123,13 +116,13 @@ void AliTPCGGVoltError::GetCorrection(const Float_t x[],const Short_t roc,Float_
 
   // Calculate distorted position
   if ( r > 0.0 ) {
-    phi =  phi + deltaVGG*( fC0*intEphi - fC1*intEr ) / r;      
-    r   =  r   + deltaVGG*( fC0*intEr   + fC1*intEphi );  
+    phi =  phi + deltaVGG*( fC0*intEphi - fC1*intEr ) / r;
+    r   =  r   + deltaVGG*( fC0*intEr   + fC1*intEphi );
   }
-  
+
   // Calculate correction in cartesian coordinates
   dx[0] = r * TMath::Cos(phi) - x[0];
-  dx[1] = r * TMath::Sin(phi) - x[1]; 
+  dx[1] = r * TMath::Sin(phi) - x[1];
   dx[2] = 0.; // z distortion not implemented (1st order distortions) - see e.g. AliTPCBoundaryVoltError-class
 
 
@@ -138,32 +131,30 @@ void AliTPCGGVoltError::GetCorrection(const Float_t x[],const Short_t roc,Float_
 
 
 Float_t AliTPCGGVoltError::GetIntErOverEz(const Float_t x[],const Short_t roc) {
-  //
-  // This function is purely for calibration purposes
-  // Calculates the integral (int Er/Ez dz) for the setted GG voltage offset 
-  // 
+  /// This function is purely for calibration purposes
+  /// Calculates the integral (int Er/Ez dz) for the setted GG voltage offset
 
   if (!fInitLookUp) AliError("Lookup table was not initialized! You should do InitGGVoltErrorDistortion() ...");
 
-  Int_t   order     = 1 ;     // FIXME: so far hardcoded? Linear interpolation = 1, Quadratic = 2         
-  
+  Int_t   order     = 1 ;     // FIXME: so far hardcoded? Linear interpolation = 1, Quadratic = 2
+
   Double_t intEr;
   Double_t r, phi, z ;
   Int_t    sign ;
-  
+
   Double_t deltaVGG;
-  
+
   r   = TMath::Sqrt( x[0]*x[0] + x[1]*x[1] );
   phi = TMath::ATan2(x[1],x[0]);
   if ( phi < 0 ) phi += TMath::TwoPi();        // Table uses phi from 0 to 2*Pi
   z   = x[2] ;
 
   if ( (roc%36) < 18 ) {
-    sign =  1; 
+    sign =  1;
     deltaVGG = fDeltaVGGA;           // (TPC End A)
   } else {
     sign = -1;                       // (TPC End C)
-    deltaVGG = fDeltaVGGC; 
+    deltaVGG = fDeltaVGGC;
   }
 
   if ( sign==1  && z <  fgkZOffSet ) z =  fgkZOffSet;    // Protect against discontinuity at CE
@@ -176,9 +167,7 @@ Float_t AliTPCGGVoltError::GetIntErOverEz(const Float_t x[],const Short_t roc) {
 }
 
 void AliTPCGGVoltError::InitGGVoltErrorDistortion() {
-  //
-  // Initialization of the Lookup table which contains the solutions of the GG Error problem
-  //
+  /// Initialization of the Lookup table which contains the solutions of the GG Error problem
 
   Double_t r,z;
   Int_t nterms = 100 ;
@@ -186,20 +175,20 @@ void AliTPCGGVoltError::InitGGVoltErrorDistortion() {
     z = fgkZList[i] ;
     for ( Int_t j = 0 ; j < kNR ; ++j ) {
       r = fgkRList[j] ;
-      fGGVoltErrorER[i][j] = 0.0 ; 	    
+      fGGVoltErrorER[i][j] = 0.0 ;
       Double_t intz = 0.0 ;
       for ( Int_t n = 1 ; n < nterms ; ++n ) {
 	Double_t k    =  n * TMath::Pi() / fgkTPCZ0 ;
 	Double_t ein  =  0 ;                    // Error potential on the IFC
 	Double_t eout =  0 ;                    // Error potential on the OFC
 	if ( z < 0 ) {
-	  ein   =  -2.0 / ( k * (fgkCathodeV - fgkGG) ) ;       
-	  eout  =  -2.0 / ( k * (fgkCathodeV - fgkGG) ) ;       
+	  ein   =  -2.0 / ( k * (fgkCathodeV - fgkGG) ) ;
+	  eout  =  -2.0 / ( k * (fgkCathodeV - fgkGG) ) ;
 	}
 	if ( z == 0 ) continue ;
 	if ( z > 0 ) {
-	  ein   =  -2.0 / ( k * (fgkCathodeV - fgkGG) ) ;       
-	  eout  =  -2.0 / ( k * (fgkCathodeV - fgkGG) ) ;       
+	  ein   =  -2.0 / ( k * (fgkCathodeV - fgkGG) ) ;
+	  eout  =  -2.0 / ( k * (fgkCathodeV - fgkGG) ) ;
 	}
 	Double_t an   =  ein  * TMath::BesselK0( k*fgkOFCRadius ) - eout * TMath::BesselK0( k*fgkIFCRadius ) ;
 	Double_t bn   =  eout * TMath::BesselI0( k*fgkIFCRadius ) - ein  * TMath::BesselI0( k*fgkOFCRadius ) ;
@@ -211,33 +200,31 @@ void AliTPCGGVoltError::InitGGVoltErrorDistortion() {
 	Double_t zterm = TMath::Cos( k*(fgkTPCZ0-TMath::Abs(z)) ) - 1 ;
 	intz += zterm * numerator / denominator ;
 	// Assume series converges, break if small terms
-	if ( n>10 && TMath::Abs(intz)*1.e-10 > TMath::Abs(numerator/denominator) ) break;   
+	if ( n>10 && TMath::Abs(intz)*1.e-10 > TMath::Abs(numerator/denominator) ) break;
       }
       fGGVoltErrorER[i][j] = (Double_t) intz ;
 
     }
   }
-  
+
   fInitLookUp = kTRUE;
 }
 
 
 
 void AliTPCGGVoltError::Print(const Option_t* option) const {
-  //
-  // Print function to check the settings (e.g. voltage offsets)
-  // option=="a" prints the C0 and C1 coefficents for calibration purposes
-  //
+  /// Print function to check the settings (e.g. voltage offsets)
+  /// option=="a" prints the C0 and C1 coefficents for calibration purposes
 
   TString opt = option; opt.ToLower();
   printf("%s\n",GetTitle());
-  printf(" - GG Voltage offset: A-side: %3.1f V, C-side: %3.1f V \n",fDeltaVGGA,fDeltaVGGC);  
+  printf(" - GG Voltage offset: A-side: %3.1f V, C-side: %3.1f V \n",fDeltaVGGA,fDeltaVGGC);
   if (opt.Contains("a")) { // Print all details
     printf(" - T1: %1.4f, T2: %1.4f \n",fT1,fT2);
     printf(" - C1: %1.4f, C0: %1.4f \n",fC1,fC0);
-  }    
+  }
 
   if (!fInitLookUp) AliError("Lookup table was not initialized! You should do InitGGVoltErrorDistortion() ...");
 
-  
+
 }
diff --git a/TPC/TPCbase/AliTPCGGVoltError.h b/TPC/TPCbase/AliTPCGGVoltError.h
index b43cc265a95..4efc78a45aa 100644
--- a/TPC/TPCbase/AliTPCGGVoltError.h
+++ b/TPC/TPCbase/AliTPCGGVoltError.h
@@ -4,44 +4,26 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-// _________________________________________________________________
-//
-// Begin_Html
-//   <h2> AliTPCGGVoltError class   </h2>         
-//   The class calculates the electric field and the resulting space point distortions 
-//   due a Gating Grid (GG) voltage error. It uses the analytical solution for such a problem. 
-//   <p>
-//   The input is the effective GG voltage residual in respect to the ideal setting. The effective 
-//   residual voltage can be set via the functions SetDeltaVGGx. Note that this effective 
-//   voltage-residuals are approx. a factor 0.9 lower than the actual difference in the setting 
-//   of the GG due to the fact that the voltage on the GG is partially screened by the wire 
-//   structure. The calculation has to be performed with the observable effective voltage difference.
-//   <p>
-//   Unfortunately, the class is not capable of calculation the $dz$ offset due to possible changes 
-//   of the drift velocity in dependence of the electric field. The special case of the numerical 
-//   approximation (AliTPCBoundaryVoltError), which is capable of calculating the same effect, should 
-//   be used for this purpose. 
-// End_Html
-//
-// Begin_Macro(source)
-//   {
-//   gROOT->SetStyle("Plain"); gStyle->SetPalette(1);
-//   TCanvas *c2 = new TCanvas("cAliTPCGGVoltError","cAliTPCGGVoltError",500,300); 
-//   AliTPCGGVoltError gg;
-//   gg.SetDeltaVGGA(-40); gg.SetDeltaVGGC(-40); // 40 Volt offset
-//   gg.InitGGVoltErrorDistortion();
-//   gg.SetOmegaTauT1T2(0,1,1); // B=0
-//   gg.CreateHistoDRinZR(0)->Draw("surf2"); 
-//   return c2;
-//   } 
-// End_Macro
-//
-// Begin_Html
-//   <p>
-//   Date: 27/04/2010  <br>
-//   Authors: Jim Thomas, Stefan Rossegger, Magnus Mager   
-// End_Html 
-// _________________________________________________________________
+/// \class AliTPCGGVoltError
+/// \brief AliTPCGGVoltError class
+///
+/// The class calculates the electric field and the resulting space point distortions
+/// due a Gating Grid (GG) voltage error. It uses the analytical solution for such a problem.
+///
+/// The input is the effective GG voltage residual in respect to the ideal setting. The effective
+/// residual voltage can be set via the functions SetDeltaVGGx. Note that this effective
+/// voltage-residuals are approx. a factor 0.9 lower than the actual difference in the setting
+/// of the GG due to the fact that the voltage on the GG is partially screened by the wire
+/// structure. The calculation has to be performed with the observable effective voltage difference.
+///
+/// Unfortunately, the class is not capable of calculation the $dz$ offset due to possible changes
+/// of the drift velocity in dependence of the electric field. The special case of the numerical
+/// approximation (AliTPCBoundaryVoltError), which is capable of calculating the same effect, should
+/// be used for this purpose.
+/// ![Picture from ROOT macro](AliTPCGGVoltError_h_359f7ec.png)
+///
+/// \author Jim Thomas, Stefan Rossegger, Magnus Mager
+/// \date 27/04/2010
 
 
 #include "AliTPCCorrection.h"
@@ -82,16 +64,18 @@ protected:
   virtual void GetCorrection(const Float_t x[],const Short_t roc, Float_t dx[]);
 private:
 
-  Float_t fC0; // coefficient C0                 (compare Jim Thomas's notes for definitions)
-  Float_t fC1; // coefficient C1                 (compare Jim Thomas's notes for definitions)
+  Float_t fC0; ///< coefficient C0                 (compare Jim Thomas's notes for definitions)
+  Float_t fC1; ///< coefficient C1                 (compare Jim Thomas's notes for definitions)
 
-  Double_t fDeltaVGGA;            // Missmatch of gating grid voltage on A-side [V]
-  Double_t fDeltaVGGC;            // Missmatch of gating grid voltage on C-side [V]
-  Double_t fGGVoltErrorER[kNZ][kNR]; // Array to store electric field for GGVoltError calculation
+  Double_t fDeltaVGGA;            ///< Missmatch of gating grid voltage on A-side [V]
+  Double_t fDeltaVGGC;            ///< Missmatch of gating grid voltage on C-side [V]
+  Double_t fGGVoltErrorER[kNZ][kNR]; ///< Array to store electric field for GGVoltError calculation
 
-  Bool_t fInitLookUp;             // flag to check it the Look Up table was created
+  Bool_t fInitLookUp;             ///< flag to check it the Look Up table was created
 
+  /// \cond CLASSIMP
   ClassDef(AliTPCGGVoltError,1);
+  /// \endcond
 };
 
 #endif
diff --git a/TPC/TPCbase/AliTPCInverseCorrection.cxx b/TPC/TPCbase/AliTPCInverseCorrection.cxx
index a73dcc0db8e..cc0a4c962b0 100644
--- a/TPC/TPCbase/AliTPCInverseCorrection.cxx
+++ b/TPC/TPCbase/AliTPCInverseCorrection.cxx
@@ -13,20 +13,18 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-////////////////////////////////////////////////////////////////////////////////
-//                                                                            //
-// AliTPCInverseCorrection class                                              //
-//                                                                            //
-// This is a wrapper that inverts an AliTPCCorrection. This is done by        //
-// swapping the CalculateCorrection and CalculateInverseCorrection functions. //
-// The wrapped correction is supplied as a pointer and the class relies       //
-// on the fact, that this pointer keeps pointing to the right object.         //
-// However, the ownership is not changed, i.e. the wrapped correction         //
-// will not be deleted when this correction is destructed.                    //
-//                                                                            //
-// date: 27/04/2010                                                           //
-// Authors: Magnus Mager, Stefan Rossegger, Jim Thomas                        //
-////////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCInverseCorrection
+/// \brief AliTPCInverseCorrection class
+///
+/// This is a wrapper that inverts an AliTPCCorrection. This is done by
+/// swapping the CalculateCorrection and CalculateInverseCorrection functions.
+/// The wrapped correction is supplied as a pointer and the class relies
+/// on the fact, that this pointer keeps pointing to the right object.
+/// However, the ownership is not changed, i.e. the wrapped correction
+/// will not be deleted when this correction is destructed.
+///
+/// \author Magnus Mager, Stefan Rossegger, Jim Thomas
+/// \date 27/04/2010
 
 #include <TString.h>
 #include "AliTPCInverseCorrection.h"
@@ -35,19 +33,17 @@
 
 AliTPCInverseCorrection::AliTPCInverseCorrection()
   : fCorrection(0) {
-  //
-  // default constructor
-  // (only meant for ROOT I/O)
-  //
+  /// default constructor
+  /// (only meant for ROOT I/O)
+
 }
 
-AliTPCInverseCorrection::AliTPCInverseCorrection(AliTPCCorrection *correction) 
+AliTPCInverseCorrection::AliTPCInverseCorrection(AliTPCCorrection *correction)
   : fCorrection(correction) {
-  //
-  // Constructor that is creating the inverse of the supplied correction.
-  // It automatically sets the name ("inv_[correction name]") and tile
-  // ("Inverse of [correction title]").
-  //
+  /// Constructor that is creating the inverse of the supplied correction.
+  /// It automatically sets the name ("inv_[correction name]") and tile
+  /// ("Inverse of [correction title]").
+
   TString name,title;
   name  ="inv_";
   name +=correction->GetName();
@@ -58,45 +54,39 @@ AliTPCInverseCorrection::AliTPCInverseCorrection(AliTPCCorrection *correction)
 }
 
 AliTPCInverseCorrection::~AliTPCInverseCorrection() {
-  //
-  // virtual destructor
-  //
+  /// virtual destructor
+
   if (fCorrection) delete fCorrection;
 }
 
 
 void AliTPCInverseCorrection::Init() {
-  //
-  // Initialization funtion (not used at the moment)
-  //
+  /// Initialization funtion (not used at the moment)
+
   if (fCorrection) fCorrection->Init();
 
 }
 
 void AliTPCInverseCorrection::Update(const TTimeStamp &timeStamp) {
-  //
-  // Update function 
-  //
+  /// Update function
+
   if (fCorrection) fCorrection->Update(timeStamp);
 
 }
 
 void AliTPCInverseCorrection::Print(Option_t* option) const {
-  //
-  // Print function to check which correction classes are used 
-  // option=="d" prints details regarding the setted magnitude 
-  // option=="a" prints the C0 and C1 coefficents for calibration purposes
-  //
+  /// Print function to check which correction classes are used
+  /// option=="d" prints details regarding the setted magnitude
+  /// option=="a" prints the C0 and C1 coefficents for calibration purposes
 
   printf("Inverse of ");
   if (fCorrection) fCorrection->Print(option);
 }
 
 void AliTPCInverseCorrection::GetCorrection(const Float_t x[],const Short_t roc,Float_t dx[]) {
-  //
-  // This is just calling the CalculateInverseCorrection of the wrapped
-  // correction -- or puts dr=0 if the latter is 0.
-  //
+  /// This is just calling the CalculateInverseCorrection of the wrapped
+  /// correction -- or puts dr=0 if the latter is 0.
+
   if (fCorrection)
     fCorrection->GetDistortion(x,roc,dx);
   else
@@ -104,23 +94,23 @@ void AliTPCInverseCorrection::GetCorrection(const Float_t x[],const Short_t roc,
 }
 
 void AliTPCInverseCorrection:: SetOmegaTauT1T2(Float_t omegaTau,Float_t t1,Float_t t2) {
-  //
-  // Virtual funtion to pass the wt values (might become event dependent) to the inherited classes
-  // t1 and t2 represent the "effective omegaTau" corrections and were measured in a dedicated
-  // calibration run
-  //
+  /// Virtual funtion to pass the wt values (might become event dependent) to the inherited classes
+  /// t1 and t2 represent the "effective omegaTau" corrections and were measured in a dedicated
+  /// calibration run
+
   if (fCorrection) fCorrection->SetOmegaTauT1T2(omegaTau, t1, t2);
 }
 
 void AliTPCInverseCorrection::GetDistortion(const Float_t x[],const Short_t roc,Float_t dx[]) {
-  //
-  // This is just calling the CalculateCorrection of the wrapped
-  // correction -- or puts dr=0 if the latter is 0.
-  //
+  /// This is just calling the CalculateCorrection of the wrapped
+  /// correction -- or puts dr=0 if the latter is 0.
+
   if (fCorrection)
     fCorrection->GetCorrection(x,roc,dx);
   else
     for (Int_t j=0;j<3;++j) dx[j]=0.;
 }
 
+/// \cond CLASSIMP
 ClassImp(AliTPCInverseCorrection)
+/// \endcond
diff --git a/TPC/TPCbase/AliTPCInverseCorrection.h b/TPC/TPCbase/AliTPCInverseCorrection.h
index b5075a6c7d7..3b00fc5f672 100644
--- a/TPC/TPCbase/AliTPCInverseCorrection.h
+++ b/TPC/TPCbase/AliTPCInverseCorrection.h
@@ -4,20 +4,18 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-////////////////////////////////////////////////////////////////////////////////
-//                                                                            //
-// AliTPCInverseCorrection class                                              //
-//                                                                            //
-// This is a wrapper that inverts an AliTPCCorrection. This is done by        //
-// swapping the CalculateCorrection and CalculateInverseCorrection functions. //
-// The wrapped correction is supplied as a pointer and the class relies       //
-// on the fact, that this pointer keeps pointing to the right object.         //
-// However, the ownership is not changed, i.e. the wrapped correction         //
-// will not be deleted when this correction is destructed.                    //
-//                                                                            //
-// date: 27/04/2010                                                           //
-// Authors: Magnus Mager, Stefan Rossegger, Jim Thomas                       //
-////////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCInverseCorrection
+/// \brief AliTPCInverseCorrection class
+///
+/// This is a wrapper that inverts an AliTPCCorrection. This is done by
+/// swapping the CalculateCorrection and CalculateInverseCorrection functions.
+/// The wrapped correction is supplied as a pointer and the class relies
+/// on the fact, that this pointer keeps pointing to the right object.
+/// However, the ownership is not changed, i.e. the wrapped correction
+/// will not be deleted when this correction is destructed.
+///
+/// \author Magnus Mager, Stefan Rossegger, Jim Thomas
+/// \date 27/04/2010
 
 #include "AliTPCCorrection.h"
 
@@ -38,17 +36,19 @@ public:
   virtual void Update(const TTimeStamp &timeStamp);
 
   virtual void SetOmegaTauT1T2(Float_t omegaTau,Float_t t1,Float_t t2);
- 
+
   // convenience functions
   virtual void Print(Option_t* option="") const;
- 
+
 private:
-  AliTPCCorrection *fCorrection; // The correction to be inverted.
+  AliTPCCorrection *fCorrection; ///< The correction to be inverted.
 
   AliTPCInverseCorrection & operator = (const AliTPCInverseCorrection &);  // dummy assignment operator
   AliTPCInverseCorrection(const AliTPCInverseCorrection&); //dummy copy contructor
 
+  /// \cond CLASSIMP
   ClassDef(AliTPCInverseCorrection,1);
+  /// \endcond
 };
 
 #endif
diff --git a/TPC/TPCbase/AliTPCLaserTrack.cxx b/TPC/TPCbase/AliTPCLaserTrack.cxx
index fd89e586512..98c1877ab68 100644
--- a/TPC/TPCbase/AliTPCLaserTrack.cxx
+++ b/TPC/TPCbase/AliTPCLaserTrack.cxx
@@ -13,32 +13,29 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-////////////////////////////////////////////////////////////////////////////
-//                                                                        //
-// Surveyed Laser Track positions                                         //
-// the position and direction information are stored in                   //
-// the AliExternalTrackParam base class                                   //
-// This class extends this information by identification parameters       //
-/*
-
-//Dump positions to a tree:
-AliTPCLaserTrack::LoadTracks();
-TObjArray *arr=AliTPCLaserTrack::GetTracks();
-TTreeSRedirector *s=new TTreeSRedirector("LaserTracks.root");
-TIter next(arr);
-TObject *o=0x0;
-while ( (o=next()) ) (*s) << "tracks" << "l.=" << o << "\n";
-delete s;
-
-//draw something
-TFile f("LaserTracks.root");
-TTree *tracks=(TTree*)f.Get("tracks");
-tracks->Draw("fVecGY.fElements:fVecGX.fElements");
-
- tracks->Draw("fVecGY.fElements:fVecGX.fElements>>h(500,-250,250,500,-250,250)","fId<7")
-*/
-//                                                                        //
-////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCLaserTrack
+/// \brief Surveyed Laser Track positions
+///
+/// the position and direction information are stored in
+/// the AliExternalTrackParam base class
+/// This class extends this information by identification parameters
+///
+/// Dump positions to a tree:
+/// ~~~
+/// AliTPCLaserTrack::LoadTracks();
+/// TObjArray *arr=AliTPCLaserTrack::GetTracks();
+/// TTreeSRedirector *s=new TTreeSRedirector("LaserTracks.root");
+/// TIter next(arr);
+/// TObject *o=0x0;
+/// while ( (o=next()) ) (*s) << "tracks" << "l.=" << o << "\n";
+/// delete s;
+/// ~~~
+/// draw something
+/// TFile f("LaserTracks.root");
+/// TTree *tracks=(TTree*)f.Get("tracks");
+/// tracks->Draw("fVecGY.fElements:fVecGX.fElements");
+///
+/// tracks->Draw("fVecGY.fElements:fVecGX.fElements>>h(500,-250,250,500,-250,250)","fId<7")
 
 
 #include <TObjArray.h>
@@ -53,7 +50,9 @@ tracks->Draw("fVecGY.fElements:fVecGX.fElements");
 #include "AliTPCLaserTrack.h"
 #include "AliTPCROC.h"
 
+/// \cond CLASSIMP
 ClassImp(AliTPCLaserTrack)
+/// \endcond
 
 TObjArray *AliTPCLaserTrack::fgArrLaserTracks=0x0;
 
@@ -75,10 +74,7 @@ AliTPCLaserTrack::AliTPCLaserTrack() :
   fVecLY(0),       // points vectors - localY
   fVecLZ(0)        // points vectors - localZ
 {
-  //
-//   // Default constructor
-  //
-
+  /// Default constructor
 }
 
 AliTPCLaserTrack::AliTPCLaserTrack(const AliTPCLaserTrack &ltr) :
@@ -99,9 +95,8 @@ AliTPCLaserTrack::AliTPCLaserTrack(const AliTPCLaserTrack &ltr) :
   fVecLY(0),       // points vectors - localY
   fVecLZ(0)        // points vectors - localZ
 {
-  //
-  // Default constructor
-  //
+  /// Default constructor
+
   fVecSec=new TVectorD(*ltr.fVecSec);       // points vectors - sector
   fVecP2 =new TVectorD(*ltr.fVecP2);       // points vectors - snp
   fVecPhi=new TVectorD(*ltr.fVecPhi);       // points vectors - global phi
@@ -137,30 +132,26 @@ AliTPCLaserTrack::AliTPCLaserTrack(const Int_t id, const Int_t side, const Int_t
   fVecLZ(new TVectorD(159))        // points vectors - localZ
 
 {
-  //
-  // create laser track from arguments
-  //
-  
+  /// create laser track from arguments
+
 }
 //_____________________________________________________________________
 AliTPCLaserTrack& AliTPCLaserTrack::operator = (const  AliTPCLaserTrack &source)
 {
-  //
-  // assignment operator
-  //
+  /// assignment operator
+
   if (&source == this) return *this;
   new (this) AliTPCLaserTrack(source);
-  
+
   return *this;
 }
 
 
 AliTPCLaserTrack::~AliTPCLaserTrack(){
-  //
-  // destructor
-  //
-  delete fVecSec;      //                - sector numbers  
-  delete fVecP2;       //                - P2  
+  /// destructor
+
+  delete fVecSec;      //                - sector numbers
+  delete fVecP2;       //                - P2
   delete fVecPhi;       // points vectors - global phi
   delete fVecGX;       // points vectors - globalX
   delete fVecGY;       // points vectors - globalY
@@ -172,13 +163,11 @@ AliTPCLaserTrack::~AliTPCLaserTrack(){
 
 void AliTPCLaserTrack::LoadTracks()
 {
-  //
-  // Load all design positions from file into the static array fgArrLaserTracks
-  //
-  
+  /// Load all design positions from file into the static array fgArrLaserTracks
+
   if ( fgArrLaserTracks ) return;
   TObjArray *arrLaserTracks = 0x0;
-  
+
   AliCDBManager *man=AliCDBManager::Instance();
   if (!man->GetDefaultStorage() && gSystem->Getenv("ALICE_ROOT")) man->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
   if (man->GetDefaultStorage()){
@@ -198,9 +187,9 @@ void AliTPCLaserTrack::LoadTracks()
 //	AliWarning(Form("Could not get laser position data from file: '%s'",fgkDataFileName));
     return;
   }
-  
+
   arrLaserTracks->SetOwner();
-  
+
   fgArrLaserTracks = new TObjArray(fgkNLaserTracks);
   fgArrLaserTracks->SetOwner();
   for (Int_t itrack=0; itrack<fgkNLaserTracks; itrack++){
@@ -219,16 +208,15 @@ void AliTPCLaserTrack::LoadTracks()
 
 
 void AliTPCLaserTrack::UpdatePoints(){
-  //
-  // update track points
-  //
+  /// update track points
+
   const Double_t kMaxSnp=0.97;
   AliTPCROC* roc = AliTPCROC::Instance();
   //
   //
   if (!fVecSec){
     fVecSec=new TVectorD(159);
-    fVecP2 =new TVectorD(159);       //                - P2  
+    fVecP2 =new TVectorD(159);       //                - P2
     fVecPhi=new TVectorD(159);       //                - Phi
     fVecGX=new TVectorD(159);       // points vectors - globalX
     fVecGY=new TVectorD(159);       // points vectors - globalY
@@ -257,7 +245,7 @@ void AliTPCLaserTrack::UpdatePoints(){
   for (Int_t irow=158; irow>=0; irow--){
     UInt_t srow = irow;
     Int_t sector=0;
-   
+
     if (srow >=roc->GetNRows(0)) {
       srow-=roc->GetNRows(0);
       sector=36    ;
@@ -270,7 +258,7 @@ void AliTPCLaserTrack::UpdatePoints(){
     if (alpha<0) alpha+=2*TMath::Pi();
     sector      +=TMath::Nint(-0.5+9*alpha/TMath::Pi());
     if (gxyz[2]<0) sector+=18;
-    Double_t salpha   = TMath::Pi()*(sector+0.5)/9.;    
+    Double_t salpha   = TMath::Pi()*(sector+0.5)/9.;
     if (!ltrp->Rotate(salpha)) break;
     if (!ltrp->PropagateTo(lxyz[0],5)) break;
     if (TMath::Abs(ltrp->GetSnp())>kMaxSnp) break;
@@ -293,11 +281,9 @@ void AliTPCLaserTrack::UpdatePoints(){
 
 Int_t AliTPCLaserTrack::IdentifyTrack(AliExternalTrackParam *track, Int_t side)
 {
-  //
-  // Find the laser track which is corresponding closest to 'track'
-  // return its id
-  //
-  // 
+  /// Find the laser track which is corresponding closest to 'track'
+  /// return its id
+
   const  Float_t   kMaxdphi=0.2;
   const  Float_t   kMaxdphiP=0.05;
   const  Float_t   kMaxdz=40;
@@ -313,7 +299,7 @@ Int_t AliTPCLaserTrack::IdentifyTrack(AliExternalTrackParam *track, Int_t side)
   //
   Float_t mindist=10; // maxima minimal distance
   Int_t id = -1;
-  for (Int_t itrack=0; itrack<fgkNLaserTracks; itrack++){    
+  for (Int_t itrack=0; itrack<fgkNLaserTracks; itrack++){
     AliTPCLaserTrack *ltr = (AliTPCLaserTrack*)arrTracks->UncheckedAt(itrack);
     if (side>=0) if (ltr->GetSide()!=side) continue;
     Double_t * kokot = (Double_t*)ltr->GetParameter();
@@ -337,10 +323,10 @@ Int_t AliTPCLaserTrack::IdentifyTrack(AliExternalTrackParam *track, Int_t side)
     dist+=TMath::Abs(lxyz1[1]-lxyz0[1]);
     //    dist+=TMath::Abs(lxyz1[2]-lxyz0[2]); //z is not used for distance calculation
     dist+=distdir;
-    //    
+    //
     if (id<0)  {
-      id =itrack; 
-      mindist=dist; 
+      id =itrack;
+      mindist=dist;
       continue;
     }
     if (dist>mindist) continue;
diff --git a/TPC/TPCbase/AliTPCLaserTrack.h b/TPC/TPCbase/AliTPCLaserTrack.h
index 50e404ba669..c96c0ca2f7d 100644
--- a/TPC/TPCbase/AliTPCLaserTrack.h
+++ b/TPC/TPCbase/AliTPCLaserTrack.h
@@ -2,11 +2,8 @@
 #define ALITPCLASERTRACK_H
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
-////////////////////////////////////////////////////////////////////////////
-//
-// Surveyed Laser Track positions
-//
-////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCLaserTrack
+/// \brief Surveyed Laser Track positions
 
 #include <TString.h>
 
@@ -27,14 +24,14 @@ public:
                    Double_t x, Double_t alpha,
                    const Double_t param[5],
                    const Double_t covar[15], const Float_t rayLength=0);
-  
+
   AliTPCLaserTrack& operator = (const  AliTPCLaserTrack &source);
   void UpdatePoints();   // update track points
   static void LoadTracks();
   static TObjArray* GetTracks() {return fgArrLaserTracks;}
-  
+
   static Int_t IdentifyTrack(AliExternalTrackParam *track, Int_t side=-1);
-  
+
   Int_t GetId()     const {return fId;     }
   Int_t GetSide()   const {return fSide;   }
   Int_t GetRod()    const {return fRod;    }
@@ -42,22 +39,22 @@ public:
   Int_t GetBeam()   const {return fBeam;   }
 
   Float_t GetRayLength() const {return fRayLength;}
-  
-  
-  
+
+
+
   static Int_t GetNLaserTracks() { return fgkNLaserTracks; }
   static Int_t GetNLaserRodsPerSide() { return fgkNRodsPerSide; }
   static Int_t GetNMirrorBundlesPerRod() { return fgkNBundlePerRod; }
   static Int_t GetNLaserRaysPerMirrorBundle() { return fgkNBeamsPerBundle; }
-  
-  
+
+
   void SetId    (Int_t id)    {fId     = id;    }
   void SetSide  (Int_t side)  {fSide   = side;  }
   void SetRod   (Int_t rod)   {fRod    = rod;   }
   void SetBundle(Int_t bundle){fBundle = bundle;}
   void SetBeam  (Int_t beam)  {fBeam   = beam;  }
   void SetRayLength (Float_t len) {fRayLength = len;}
-  
+
   const TVectorD* GetVecSec() const { return fVecSec; }
   const TVectorD* GetVecP2()  const { return fVecP2;  }
   const TVectorD* GetVecPhi() const { return fVecPhi; }
@@ -67,39 +64,41 @@ public:
   const TVectorD* GetVecLX()  const { return fVecLX;  }
   const TVectorD* GetVecLY()  const { return fVecLY;  }
   const TVectorD* GetVecLZ()  const { return fVecLZ;  }
-  
+
 private:
-  Int_t fId;              //Laser beam id            (0-335)
-  Int_t fSide;            //TPC side; 0:Shaft Side (A) -- 1:Muon Side (C)
-  Int_t fRod;             //Laser Rod                (0-5)
-  Int_t fBundle;          //Mirror bundle in the Rod (0-3)
-  Int_t fBeam;            //Laser Beam in the bundle (0-6)
-  
-  Float_t fRayLength;     //distance from the last common point of the laser Rays
+  Int_t fId;              ///< Laser beam id            (0-335)
+  Int_t fSide;            ///< TPC side; 0:Shaft Side (A) -- 1:Muon Side (C)
+  Int_t fRod;             ///< Laser Rod                (0-5)
+  Int_t fBundle;          ///< Mirror bundle in the Rod (0-3)
+  Int_t fBeam;            ///< Laser Beam in the bundle (0-6)
+
+  Float_t fRayLength;     ///< distance from the last common point of the laser Rays
                           //(Splitter box on the A-Side at the bottom of the TPC)
                           //to each mirror [cm](needed for an exact drift velocity estimation)
 public:
-  TVectorD *fVecSec;      //                - sector numbers
-  TVectorD *fVecP2;       //                - P2  
-  TVectorD *fVecPhi;       //               - global phi
-  TVectorD *fVecGX;       // points vectors - globalX
-  TVectorD *fVecGY;       // points vectors - globalY
-  TVectorD *fVecGZ;       // points vectors - globalZ
-  TVectorD *fVecLX;       // points vectors - localX
-  TVectorD *fVecLY;       // points vectors - localY
-  TVectorD *fVecLZ;       // points vectors - localZ
-private:  
-  static TObjArray* fgArrLaserTracks; //! Array of all Laser Tracks,
+  TVectorD *fVecSec;      ///< - sector numbers
+  TVectorD *fVecP2;       ///< - P2
+  TVectorD *fVecPhi;       ///< - global phi
+  TVectorD *fVecGX;       ///< points vectors - globalX
+  TVectorD *fVecGY;       ///< points vectors - globalY
+  TVectorD *fVecGZ;       ///< points vectors - globalZ
+  TVectorD *fVecLX;       ///< points vectors - localX
+  TVectorD *fVecLY;       ///< points vectors - localY
+  TVectorD *fVecLZ;       ///< points vectors - localZ
+private:
+  static TObjArray* fgArrLaserTracks; //!< Array of all Laser Tracks,
                                         //  keeps instances of this class;
-  
-  static const Int_t fgkNLaserTracks    = 336; //Number of laser tracks
-  static const Int_t fgkNRodsPerSide    = 6;   //Number of laser rods on each readout side
-  static const Int_t fgkNBundlePerRod   = 4;   //Number of mirror bundles per rod
-  static const Int_t fgkNBeamsPerBundle = 7;   //Number of laser rays per bundle
-  
+
+  static const Int_t fgkNLaserTracks    = 336; ///< Number of laser tracks
+  static const Int_t fgkNRodsPerSide    = 6;   ///< Number of laser rods on each readout side
+  static const Int_t fgkNBundlePerRod   = 4;   ///< Number of mirror bundles per rod
+  static const Int_t fgkNBeamsPerBundle = 7;   ///< Number of laser rays per bundle
+
 //    static const char* fgkDataFileName = "$ALIC_ROOT/TPC/Calib/LaserTracks.root";  //Path to the Data File
-  
+
+  /// \cond CLASSIMP
   ClassDef(AliTPCLaserTrack,3)        // Laser Track positions and track identification
+  /// \endcond
 };
 
 #endif
diff --git a/TPC/TPCbase/AliTPCLoader.cxx b/TPC/TPCbase/AliTPCLoader.cxx
index 11ee0b953bf..f66bdd9c3bc 100644
--- a/TPC/TPCbase/AliTPCLoader.cxx
+++ b/TPC/TPCbase/AliTPCLoader.cxx
@@ -1,3 +1,5 @@
+/// \class AliTPCLoader
+
 /**************************************************************************
  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  *                                                                        *
@@ -13,7 +15,6 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/* $Id$ */
 
 #include "AliTPCLoader.h"
 #include "AliLog.h"
@@ -25,17 +26,19 @@ const TString AliTPCLoader::fgkDefaultRecPointsFileName = "TPC.RecPoints.root";
 const TString AliTPCLoader::fgkDefaultTracksFileName    = "TPC.Tracks.root";
 
 
+/// \cond CLASSIMP
 ClassImp(AliTPCLoader)
+/// \endcond
 AliTPCLoader::AliTPCLoader()
  {
  }
-/*****************************************************************************/ 
+/*****************************************************************************/
 AliTPCLoader::AliTPCLoader(const Char_t *name,const Char_t *topfoldername)
  :AliLoader(name,topfoldername)
 {
   AliDebug(1,Form("Name = %s; topfolder = %s",name,topfoldername));
 }
-/*****************************************************************************/ 
+/*****************************************************************************/
 
 AliTPCLoader::AliTPCLoader(const Char_t *name,TFolder *topfolder)
  :AliLoader(name,topfolder)
diff --git a/TPC/TPCbase/AliTPCLoader.h b/TPC/TPCbase/AliTPCLoader.h
index 7a550a2b12e..19fd05e92fa 100644
--- a/TPC/TPCbase/AliTPCLoader.h
+++ b/TPC/TPCbase/AliTPCLoader.h
@@ -1,10 +1,12 @@
 #ifndef ALITPCGETTER_H
 #define ALITPCGETTER_H
 
-//base class for loaders 
-//loader is common for reading data for all detectors
-//Each detector has a loader data member
-//loader is accessible via folder structure as well
+/// \class AliTPCLoader
+/// \brief base class for loaders
+///
+/// loader is common for reading data for all detectors
+/// Each detector has a loader data member
+/// loader is accessible via folder structure as well
 
 #include <AliLoader.h>
 
@@ -16,7 +18,7 @@ class AliTPCLoader: public AliLoader
     AliTPCLoader();
     AliTPCLoader(const Char_t *name,const Char_t *topfoldername);
     AliTPCLoader(const Char_t *name,TFolder *topfolder);
-    
+
     virtual ~AliTPCLoader(){};//-----------------
 
    protected:
@@ -28,10 +30,12 @@ class AliTPCLoader: public AliLoader
     static const TString fgkDefaultDigitsFileName;
     static const TString fgkDefaultRecPointsFileName;
     static const TString fgkDefaultTracksFileName;
-    
+
 
    public:
+     /// \cond CLASSIMP
      ClassDef(AliTPCLoader,1)
+     /// \endcond
  };
- 
+
 #endif
diff --git a/TPC/TPCbase/AliTPCPRF2D.cxx b/TPC/TPCbase/AliTPCPRF2D.cxx
index f762ab4da7e..4054b25e55b 100644
--- a/TPC/TPCbase/AliTPCPRF2D.cxx
+++ b/TPC/TPCbase/AliTPCPRF2D.cxx
@@ -13,27 +13,24 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/* $Id$ */
-
-///////////////////////////////////////////////////////////////////////////////
-//  AliTPCPRF2D -                                                            //
-//  Pad response function object in two dimesions                            //
-//  This class contains the basic functions for the                          //
-//  calculation of PRF according generic charge distribution                 //
-//  In Update function object calculate table of response function           //
-//  in discrete x and y position                                             //
-// This table is used for interpolation od response function in any position //
-// (function GetPRF)                                                          //
-//                                                                           // 
-//  Origin: Marian Ivanov, Uni. of Bratislava, ivanov@fmph.uniba.sk          //
-//                                                                           //
-///////////////////////////////////////////////////////////////////////////////
+
+/// \class AliTPCPRF2D
+/// \brief Pad response function object in two dimesions
+///
+/// This class contains the basic functions for the
+/// calculation of PRF according generic charge distribution
+/// In Update function object calculate table of response function
+/// in discrete x and y position
+/// This table is used for interpolation od response function in any position
+/// (function GetPRF)
+///
+/// \author Marian Ivanov, Uni. of Bratislava, ivanov@fmph.uniba.sk
 
 #include <Riostream.h>
 #include <TCanvas.h>
 #include <TClass.h>
 #include <TF2.h>
-#include <TH1.h> 
+#include <TH1.h>
 #include <TMath.h>
 #include <TPad.h>
 #include <TPaveText.h>
@@ -53,8 +50,9 @@ const Int_t   AliTPCPRF2D::fgkNPRF = 100;
 
 
 static Double_t FunGauss2D(const Double_t *const x, const Double_t *const par)
-{ 
-//Gauss function  -needde by the generic function object 
+{
+/// Gauss function  -needde by the generic function object
+
   return ( TMath::Exp(-(x[0]*x[0])/(2*par[0]*par[0]))*
 	   TMath::Exp(-(x[1]*x[1])/(2*par[1]*par[1])));
 
@@ -62,14 +60,16 @@ static Double_t FunGauss2D(const Double_t *const x, const Double_t *const par)
 
 static Double_t FunCosh2D(const Double_t *const x, const Double_t *const par)
 {
- //Cosh function  -needde by the generic function object 
+ /// Cosh function  -needde by the generic function object
+
   return ( 1/(TMath::CosH(3.14159*x[0]/(2*par[0]))*
 	   TMath::CosH(3.14159*x[1]/(2*par[1]))));
-}    
+}
 
 static Double_t FunGati2D(const Double_t *const x, const Double_t *const par)
 {
-  //Gati function  -needde by the generic function object 
+  /// Gati function  -needde by the generic function object
+
   Float_t k3=par[1];
   Float_t k3R=TMath::Sqrt(k3);
   Float_t k2=(TMath::Pi()/2)*(1-k3R/2.);
@@ -84,16 +84,18 @@ static Double_t FunGati2D(const Double_t *const x, const Double_t *const par)
   k2=(TMath::Pi()/2)*(1-k3R/2.);
   k1=k2*k3R/(4*TMath::ATan(k3R));
   l=x[1]/par[0];
-  tan2=TMath::TanH(k2*l); 
+  tan2=TMath::TanH(k2*l);
   tan2*=tan2;
-  res = res*k1*(1-tan2)/(1+k3*tan2);   
-  return res;  
-}   
+  res = res*k1*(1-tan2)/(1+k3*tan2);
+  return res;
+}
 
 ///////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////
 
+/// \cond CLASSIMP
 ClassImp(AliTPCPRF2D)
+/// \endcond
 
 AliTPCPRF2D::AliTPCPRF2D()
             :TObject(),
@@ -129,7 +131,7 @@ AliTPCPRF2D::AliTPCPRF2D()
              fInterY(0),
              fCurrentY(0.),
              fDYtoWire(0.),
-             fDStepM1(0.)             
+             fDStepM1(0.)
 {
   //default constructor for response function object
 
@@ -138,9 +140,9 @@ AliTPCPRF2D::AliTPCPRF2D()
         funParam[i]=0.;
         fType[i]=0;
   }
-  
 
-  //chewron default values   
+
+  //chewron default values
   SetPad(0.8,0.8);
   SetChevron(0.2,0.0,1.0);
   SetY(-0.2,0.2,2);
@@ -150,14 +152,14 @@ AliTPCPRF2D::AliTPCPRF2D()
 AliTPCPRF2D::~AliTPCPRF2D()
 {
   if (fChargeArray!=0) delete [] fChargeArray;
-  if (fGRF !=0 ) fGRF->Delete(); 
+  if (fGRF !=0 ) fGRF->Delete();
 }
 
 void AliTPCPRF2D::SetY(Float_t y1, Float_t y2, Int_t nYdiv)
 {
-  //
-  //set virtual line position
-  //first and last line and number of lines
+  /// set virtual line position
+  /// first and last line and number of lines
+
   fNYdiv = nYdiv;
   fY1=y1;
   fY2=y2;
@@ -165,15 +167,17 @@ void AliTPCPRF2D::SetY(Float_t y1, Float_t y2, Int_t nYdiv)
 
 void AliTPCPRF2D::SetPad(Float_t width, Float_t height)
 {
-  //set base chevron parameters
+  /// set base chevron parameters
+
  fHeightFull=height;
  fWidth=width;
 }
-void AliTPCPRF2D::SetChevron(Float_t hstep, 
-			Float_t shifty, 
+void AliTPCPRF2D::SetChevron(Float_t hstep,
+			Float_t shifty,
 			Float_t fac)
 {
-  //set shaping of chewron parameters
+  /// set shaping of chewron parameters
+
   fHeightS=hstep;
   fShiftY=shifty;
   fK=fac;
@@ -189,15 +193,16 @@ void AliTPCPRF2D::SetChParam(Float_t width, Float_t height,
 
 Float_t AliTPCPRF2D::GetPRF(Float_t xin, Float_t yin)
 {
-  //function which return pad response
-  //for the charge in distance xin 
-  //return  cubic aproximation of PRF or PRF at nearest virtual wire
+  /// function which return pad response
+  /// for the charge in distance xin
+  /// return  cubic aproximation of PRF or PRF at nearest virtual wire
+
    if (fChargeArray==0) return 0;
   //transform position to "wire position"
   Float_t y=fDYtoWire*(yin-fY1);
   if (fNYdiv == 1) y=fY1;
   //normaly it find nearest line charge
-  if (fInterY ==0){   
+  if (fInterY ==0){
     Int_t i=Int_t(0.5+y);
     if (y<0) i=Int_t(-0.5+y);
     if ((i<0) || (i>=fNYdiv) ) return 0;
@@ -234,29 +239,30 @@ Float_t AliTPCPRF2D::GetPRF(Float_t xin, Float_t yin)
   d=l-2*k;
   c=k-d;
   Float_t dy=y-Float_t(i);
-  
-  res = a+b*dy+c*dy*dy+d*dy*dy*dy;  
-  return res;            
-} 
+
+  res = a+b*dy+c*dy*dy+d*dy*dy*dy;
+  return res;
+}
 
 
 Float_t AliTPCPRF2D::GetPRFActiv(Float_t xin)
 {
-  //GEt response function on given charege line 
-  //return spline aproximaton 
+  /// GEt response function on given charege line
+  /// return spline aproximaton
+
   Float_t x = (xin*fDStepM1)+fNPRF/2;
   Int_t i = Int_t(x);
-  
+
   if  ( (i>1) && ((i+2)<fNPRF)) {
     Float_t a,b,c,d,k,l;
     a = fcharge[i];
-    b = (fcharge[i+1]-fcharge[i-1])*0.5; 
+    b = (fcharge[i+1]-fcharge[i-1])*0.5;
     k = fcharge[i+1]-a-b;
     l = (fcharge[i+2]-fcharge[i])*0.5-b;
     d=l-2.*k;
     c=k-d;
     Float_t dx=x-Float_t(i);
-    Float_t res = a+b*dx+c*dx*dx+d*dx*dx*dx;  
+    Float_t res = a+b*dx+c*dx*dx+d*dx*dx*dx;
     return res;
   }
   else return 0;
@@ -264,21 +270,23 @@ Float_t AliTPCPRF2D::GetPRFActiv(Float_t xin)
 
 
 Float_t  AliTPCPRF2D::GetGRF(Float_t xin, Float_t yin)
-{  
-  //function which returnoriginal charge distribution
-  //this function is just normalised for fKnorm
-  if (GetGRF() != 0 ) 
+{
+  /// function which returnoriginal charge distribution
+  /// this function is just normalised for fKnorm
+
+  if (GetGRF() != 0 )
     return fKNorm*GetGRF()->Eval(xin,yin)/fInteg;
       else
     return 0.;
 }
 
-   
-void AliTPCPRF2D::SetParam( TF2 *const GRF,  Float_t kNorm, 
+
+void AliTPCPRF2D::SetParam( TF2 *const GRF,  Float_t kNorm,
 		       Float_t sigmaX, Float_t sigmaY)
 {
-  //adjust parameters of the original charge distribution
-  //and pad size parameters
+  /// adjust parameters of the original charge distribution
+  /// and pad size parameters
+
    if (fGRF !=0 ) fGRF->Delete();
    fGRF = GRF;
    fKNorm = kNorm;
@@ -286,30 +294,29 @@ void AliTPCPRF2D::SetParam( TF2 *const GRF,  Float_t kNorm,
    snprintf(fType,5,"User");
    if (sigmaX ==0) sigmaX=(fWidth*(1+TMath::Abs(fK)))/fgkSQRT12;
    if (sigmaY ==0) sigmaY=(fWidth*(1+TMath::Abs(fK)))/fgkSQRT12;
-   fOrigSigmaX=sigmaX; 
-   fOrigSigmaY=sigmaY; 
-   Double_t estimsigma = 
+   fOrigSigmaX=sigmaX;
+   fOrigSigmaY=sigmaY;
+   Double_t estimsigma =
      TMath::Sqrt(sigmaX*sigmaX+(fWidth*fWidth*(1+TMath::Abs(fK))/12)+
-		 TMath::Tan(fPadAngle*fgkDegtoRad)*TMath::Tan(fPadAngle*fgkDegtoRad)*fHeightFull*fHeightFull/12);   
+		 TMath::Tan(fPadAngle*fgkDegtoRad)*TMath::Tan(fPadAngle*fgkDegtoRad)*fHeightFull*fHeightFull/12);
    if (estimsigma < 5*sigmaX) {
      fDStep = estimsigma/10.;
-     fNPRF  = Int_t(estimsigma*8./fDStep); 
+     fNPRF  = Int_t(estimsigma*8./fDStep);
    }
    else{
-     fDStep = sigmaX; 
+     fDStep = sigmaX;
      Double_t width = fWidth*(1+TMath::Abs(fK))+TMath::Abs(TMath::Tan(fPadAngle*fgkDegtoRad))*fHeightFull;
      fNPRF = Int_t((width+8.*sigmaX)/fDStep);
    };
 
 }
-  
+
 
 void AliTPCPRF2D::SetGauss(Float_t sigmaX, Float_t sigmaY,
 		      Float_t kNorm)
 {
-  // 
-  // set parameters for Gauss generic charge distribution
-  //
+  /// set parameters for Gauss generic charge distribution
+
   fKNorm = kNorm;
   fOrigSigmaX=sigmaX;
   fOrigSigmaY=sigmaY;
@@ -317,89 +324,89 @@ void AliTPCPRF2D::SetGauss(Float_t sigmaX, Float_t sigmaY,
   snprintf(fType,5,"Gauss");
   if (fGRF !=0 ) fGRF->Delete();
   fGRF = new TF2("FunGauss2D",FunGauss2D,-5.,5.,-5.,5.,4);
-  
+
   funParam[0]=sigmaX;
-  funParam[1]=sigmaY;  
+  funParam[1]=sigmaY;
   funParam[2]=fK;
-  funParam[3]=fHeightS;    
- 
-  fGRF->SetParameters(funParam); 
-  Double_t estimsigma = 
+  funParam[3]=fHeightS;
+
+  fGRF->SetParameters(funParam);
+  Double_t estimsigma =
      TMath::Sqrt(sigmaX*sigmaX+(fWidth*fWidth*(1+TMath::Abs(fK))/12)+
-		 TMath::Tan(fPadAngle)*TMath::Tan(fPadAngle*fgkDegtoRad)*fHeightFull*fHeightFull/12);   
+		 TMath::Tan(fPadAngle)*TMath::Tan(fPadAngle*fgkDegtoRad)*fHeightFull*fHeightFull/12);
    if (estimsigma < 5*sigmaX) {
      fDStep = estimsigma/10.;
-     fNPRF  = Int_t(estimsigma*8./fDStep); 
+     fNPRF  = Int_t(estimsigma*8./fDStep);
    }
    else{
-     fDStep = sigmaX; 
+     fDStep = sigmaX;
      Double_t width = fWidth*(1+TMath::Abs(fK))+TMath::Abs(TMath::Tan(fPadAngle*fgkDegtoRad))*fHeightFull;
      fNPRF = Int_t((width+8.*sigmaX)/fDStep);
    };
- 
-  
+
+
 }
 void AliTPCPRF2D::SetCosh(Float_t sigmaX, Float_t sigmaY,
 		     Float_t kNorm)
-{ 
-  // set parameters for Cosh generic charge distribution
-  //
+{
+  /// set parameters for Cosh generic charge distribution
+
   fKNorm = kNorm;
   fOrigSigmaX=sigmaX;
-  fOrigSigmaY=sigmaY; 
+  fOrigSigmaY=sigmaY;
   //  sprintf(fType,"Cosh");
   snprintf(fType,5,"Cosh");
   if (fGRF !=0 ) fGRF->Delete();
-  fGRF = new TF2("FunCosh2D",	FunCosh2D,-5.,5.,-5.,5.,4);   
+  fGRF = new TF2("FunCosh2D",	FunCosh2D,-5.,5.,-5.,5.,4);
   funParam[0]=sigmaX;
   funParam[1]=sigmaY;
-  funParam[2]=fK;  
+  funParam[2]=fK;
   funParam[3]=fHeightS;
   fGRF->SetParameters(funParam);
 
-  Double_t estimsigma = TMath::Sqrt(sigmaX*sigmaX+fWidth*fWidth*(1+TMath::Abs(fK))/12);   
+  Double_t estimsigma = TMath::Sqrt(sigmaX*sigmaX+fWidth*fWidth*(1+TMath::Abs(fK))/12);
   if (estimsigma < 5*sigmaX) {
     fDStep = estimsigma/10.;
-    fNPRF  = Int_t(estimsigma*8./fDStep); 
+    fNPRF  = Int_t(estimsigma*8./fDStep);
   }
   else{
-    fDStep = sigmaX; 
+    fDStep = sigmaX;
     fNPRF = Int_t((1.2*fWidth*(1+TMath::Abs(fK))+8.*sigmaX)/fDStep);
-  };  
- 
+  };
+
 }
 
 void AliTPCPRF2D::SetGati(Float_t K3X, Float_t K3Y,
 		     Float_t padDistance,
 		     Float_t kNorm)
 {
-  // set parameters for Gati generic charge distribution
-  //
+  /// set parameters for Gati generic charge distribution
+
   fKNorm = kNorm;
   fK3X=K3X;
   fK3Y=K3Y;
-  fPadDistance=padDistance;  
+  fPadDistance=padDistance;
   //sprintf(fType,"Gati");
   snprintf(fType,5,"Gati");
   if (fGRF !=0 ) fGRF->Delete();
-  fGRF = new TF2("FunGati2D",	FunGati2D,-5.,5.,-5.,5.,5);  
- 
+  fGRF = new TF2("FunGati2D",	FunGati2D,-5.,5.,-5.,5.,5);
+
   funParam[0]=padDistance;
   funParam[1]=K3X;
-  funParam[2]=fK;  
+  funParam[2]=fK;
   funParam[3]=fHeightS;
   funParam[4]=K3Y;
   fGRF->SetParameters(funParam);
   fOrigSigmaX=padDistance;
   fOrigSigmaY=padDistance;
   Float_t sigmaX = fOrigSigmaX;
-  Double_t estimsigma = TMath::Sqrt(sigmaX*sigmaX+fWidth*fWidth*(1+TMath::Abs(fK))/12);   
+  Double_t estimsigma = TMath::Sqrt(sigmaX*sigmaX+fWidth*fWidth*(1+TMath::Abs(fK))/12);
   if (estimsigma < 5*sigmaX) {
     fDStep = estimsigma/10.;
-    fNPRF  = Int_t(estimsigma*8./fDStep); 
+    fNPRF  = Int_t(estimsigma*8./fDStep);
   }
   else{
-    fDStep = sigmaX; 
+    fDStep = sigmaX;
     fNPRF = Int_t((1.2*fWidth*(1+TMath::Abs(fK))+8.*sigmaX)/fDStep);
   };
 }
@@ -408,11 +415,10 @@ void AliTPCPRF2D::SetGati(Float_t K3X, Float_t K3Y,
 
 void AliTPCPRF2D::Update()
 {
-  //
-  //update fields  with interpolated values for
-  //PRF calculation
+  /// update fields  with interpolated values for
+  /// PRF calculation
 
-  if ( fGRF == 0 ) return;  
+  if ( fGRF == 0 ) return;
   //initialize interpolated values to 0
   Int_t i;
   if (fChargeArray!=0) delete [] fChargeArray;
@@ -427,18 +433,18 @@ void AliTPCPRF2D::Update()
   Float_t x2=  4*fOrigSigmaX;
   Float_t y2=  4*fOrigSigmaY;
   Float_t dx = fOrigSigmaX/Float_t(fNdiv*6);
-  Float_t dy = fOrigSigmaY/Float_t(fNdiv*6);  
+  Float_t dy = fOrigSigmaY/Float_t(fNdiv*6);
   Int_t nx  = Int_t(0.5+x2/dx);
   Int_t ny  = Int_t(0.5+y2/dy);
   Int_t ix,iy;
   fInteg  = 0;
   Double_t dInteg =0;
   for (ix=-nx;ix<=nx;ix++)
-    for ( iy=-ny;iy<=ny;iy++) 
-      dInteg+=fGRF->Eval(Float_t(ix)*dx,Float_t(iy)*dy)*dx*dy;  
+    for ( iy=-ny;iy<=ny;iy++)
+      dInteg+=fGRF->Eval(Float_t(ix)*dx,Float_t(iy)*dy)*dx*dy;
   /////////////////////////////////////////////////////
   fInteg =dInteg;
-  if ( fInteg == 0 ) fInteg = 1; 
+  if ( fInteg == 0 ) fInteg = 1;
 
   for (i=0; i<fNYdiv; i++){
     if (fNYdiv == 1) fCurrentY = fY1;
@@ -455,23 +461,23 @@ void AliTPCPRF2D::Update()
 
 void AliTPCPRF2D::Update1()
 {
-  //
-  //update fields  with interpolated values for
-  //PRF calculation for given charge line
+  /// update fields  with interpolated values for
+  /// PRF calculation for given charge line
+
   Int_t i;
   Double_t cos = TMath::Cos(fChargeAngle);
   Double_t sin = TMath::Sin(fChargeAngle);
   const Double_t kprec =0.00000001;
   //integrate charge over pad for different distance of pad
-  for (i =0; i<fNPRF;i++){      
+  for (i =0; i<fNPRF;i++){
     //x in cm fWidth in cm
-    //calculate integral 
+    //calculate integral
     Double_t xch = fDStep * (Double_t)(i-fNPRF/2);
     fcharge[i]=0;
-    Double_t k=1;  
-    
-    
-    for (Double_t ym=-fHeightFull/2.-fShiftY;  ym<fHeightFull/2.-kprec;ym+=fHeightS){	
+    Double_t k=1;
+
+
+    for (Double_t ym=-fHeightFull/2.-fShiftY;  ym<fHeightFull/2.-kprec;ym+=fHeightS){
       Double_t y2chev=TMath::Min((ym+fHeightS),Double_t(fHeightFull/2.)); // end of chevron step
       Double_t y1chev= ym;  //beginning of chevron step
       Double_t y2 = TMath::Min(y2chev,fCurrentY+3.5*fOrigSigmaY);
@@ -479,34 +485,34 @@ void AliTPCPRF2D::Update1()
       y1 = TMath::Max(y1chev,fCurrentY-3.5*fOrigSigmaY);
 
       Double_t x0 = fWidth*(-1.-(Double_t(k)*fK))*0.5+ym*TMath::Tan(fPadAngle*fgkDegtoRad);
-      Double_t kx  = Double_t(k)*(fK*fWidth)/fHeightS;     
-      kx = TMath::Tan(TMath::ATan(kx))+TMath::Tan(fPadAngle*fgkDegtoRad);     
+      Double_t kx  = Double_t(k)*(fK*fWidth)/fHeightS;
+      kx = TMath::Tan(TMath::ATan(kx))+TMath::Tan(fPadAngle*fgkDegtoRad);
 
       Int_t ny = TMath::Max(Int_t(fNdiv*TMath::Exp(-(y1-fCurrentY)*(y1-fCurrentY)/(2*fOrigSigmaY*fOrigSigmaY))),4);
       Double_t dy = TMath::Min(fOrigSigmaY/Double_t(ny),y2-y1);
       Double_t ndy = dy;
-      
+
       //loop over different y strips with variable step size  dy
-      if (y2>(y1+kprec)) for (Double_t y = y1; y<y2+kprec;){      
-	//new step SIZE 
-	
+      if (y2>(y1+kprec)) for (Double_t y = y1; y<y2+kprec;){
+	//new step SIZE
+
 	ny = TMath::Max(Int_t(fNdiv*TMath::Exp(-(y-fCurrentY)*(y-fCurrentY)/(2*fOrigSigmaY*fOrigSigmaY))),5);
-	ndy = fOrigSigmaY/Double_t(ny); 
+	ndy = fOrigSigmaY/Double_t(ny);
 	if (ndy>(y2-y-dy)) {
 	  ndy =y2-y-dy;
 	  if (ndy<kprec) ndy=2*kprec; //calculate new delta y
 	}
-	//		
+	//
 	Double_t sumch=0;
 	//calculation of x borders and initial step
-	Double_t deltay = (y-y1chev);	 	
+	Double_t deltay = (y-y1chev);
 
 	Double_t xp1  = x0+deltay*kx;
                 //x begining of pad at position y
 	Double_t xp2 =xp1+fWidth;        //x end of pad at position y
 	Double_t xp3 =xp1+kx*dy; //...at position y+dy
-	Double_t xp4 =xp2+kx*dy; //..  
-	
+	Double_t xp4 =xp2+kx*dy; //..
+
 	Double_t x1 = TMath::Min(xp1,xp3);
 	x1 = TMath::Max(xp1,xch-3.5*fOrigSigmaX); //beging of integration
 	Double_t x2 = TMath::Max(xp2,xp4);
@@ -516,18 +522,18 @@ void AliTPCPRF2D::Update1()
 				    TMath::Exp(-(y1-fCurrentY)*(y1-fCurrentY)/(2*fOrigSigmaY*fOrigSigmaY))),2);
 	Double_t dx = TMath::Min(fOrigSigmaX/Double_t(nx),x2-x1)/5.; //on the border more iteration
 	Double_t ndx=dx;
-	
+
 	if (x2>(x1+kprec)) {
 	  for (Double_t x = x1; x<x2+kprec ;){
-	  //new step SIZE 	  
-	  nx = TMath::Max(Int_t(fNdiv*TMath::Exp(-(x-xch)*(x-xch)/(2*fOrigSigmaX*fOrigSigmaX))),3);	  
+	  //new step SIZE
+	  nx = TMath::Max(Int_t(fNdiv*TMath::Exp(-(x-xch)*(x-xch)/(2*fOrigSigmaX*fOrigSigmaX))),3);
 	  ndx = fOrigSigmaX/Double_t(nx);
 	  if (ndx>(x2-x-dx)) {
-	    ndx =x2-x-dx;	 	   
+	    ndx =x2-x-dx;
 	  }
           if ( ( (x+dx+ndx)<TMath::Max(xp3,xp1)) || ( (x+dx+ndx)>TMath::Min(xp4,xp2))) {
 	    ndx/=5.;
-	  }	  
+	  }
 	  if (ndx<kprec) ndx=2*kprec;
 	  //INTEGRAL APROXIMATION
 	  Double_t ddx,ddy,dddx,dddy;
@@ -536,114 +542,114 @@ void AliTPCPRF2D::Update1()
 	  dddx = cos*ddx-sin*ddy;
 	  dddy = sin*ddx+cos*ddy;
 	  Double_t z0=fGRF->Eval(dddx,dddy);  //middle point
-	  
+
 	  ddx = xch-(x+dx/2.);
 	  ddy = fCurrentY-(y);
 	  dddx = cos*ddx-sin*ddy;
 	  dddy = sin*ddx+cos*ddy;
 	  Double_t z1=fGRF->Eval(dddx,dddy);  //point down
-	  
+
 	  ddx = xch-(x+dx/2.);
 	  ddy = fCurrentY-(y+dy);
 	  dddx = cos*ddx-sin*ddy;
 	  dddy = sin*ddx+cos*ddy;
 	  Double_t z3=fGRF->Eval(dddx,dddy);  //point up
-	  
+
 	  ddx = xch-(x);
 	  ddy = fCurrentY-(y+dy/2.);
 	  dddx = cos*ddx-sin*ddy;
 	  dddy = sin*ddx+cos*ddy;
-	  Double_t z2=fGRF->Eval(dddx,dddy);  //point left  
-	  
+	  Double_t z2=fGRF->Eval(dddx,dddy);  //point left
+
 	  ddx = xch-(x+dx);
 	  ddy = fCurrentY-(y+dy/2.);
 	  dddx = cos*ddx-sin*ddy;
 	  dddy = sin*ddx+cos*ddy;
 	  Double_t z4=fGRF->Eval(dddx,dddy);  //point right
-	  
-	  
+
+
 	  if (z0<0) {z0=0;z1=0;z2=0;z3=0;z4=0;}
-	  
+
 	  Double_t f2x= (z3+z1-2*z0)*4.;//second derivation in y
 	  Double_t f2y= (z2+z4-2*z0)*4.;//second derivation in x
 	  Double_t f1y= (z3-z1);
-	  Double_t z ;	  
-	  z = (z0+f2x/6.+f2y/6.);//second order aproxiation of integral	    
+	  Double_t z ;
+	  z = (z0+f2x/6.+f2y/6.);//second order aproxiation of integral
 	  if (kx>kprec){  //positive derivation
-	    if (x<(xp1+dy*kx)){                //calculate volume at left border 
+	    if (x<(xp1+dy*kx)){                //calculate volume at left border
 	      Double_t xx1  = x;
 	      Double_t xx2  = TMath::Min(x+dx,xp1+dy*kx);
 	      Double_t yy1  = y+(xx1-xp1)/kx;
-	      Double_t yy2  = TMath::Min(y+(xx2-xp1)/kx,y+dy);	      
+	      Double_t yy2  = TMath::Min(y+(xx2-xp1)/kx,y+dy);
 	      z=z0;
-	      if (yy2<y+dy) {		
+	      if (yy2<y+dy) {
 		z-= z0*(y+dy-yy2)/dy; //constant part rectangle
 		z-= f1y*(xx2-xx1)*(y+dy-yy2)*(y+dy-yy2)/(2.*dx*dy);
 	      }
 	      z-=z0*(xx2-xx1)*(yy2-yy1)/(2*dx*dy); //constant part rectangle
-	      
+
 	    }
-	    if (x>xp2){          //calculate volume at right  border 
+	    if (x>xp2){          //calculate volume at right  border
 	      Double_t xx1  = x;
 	      Double_t xx2  = x+dx;
 	      Double_t yy1  = y+(xx1-xp2)/kx;
-	      Double_t yy2  = y+(xx2-xp2)/kx;		     
+	      Double_t yy2  = y+(xx2-xp2)/kx;
 	      z=z0;
 	      //rectangle part
 	      z-=z0*(yy1-y)/dy; //constant part
 	      z-=f1y*(xx2-xx1)*(yy1-y)*(yy1-y)/(2*dx*dy);
-	      //triangle part         
-	      z-=z0*(xx2-xx1)*(yy2-yy1)/(2*dx*dy); //constant part	      
+	      //triangle part
+	      z-=z0*(xx2-xx1)*(yy2-yy1)/(2*dx*dy); //constant part
 	    }
-	  }	  
-	  if (kx<-kprec){ //negative  derivation	    
-	    if (x<(xp1+dy*kx)){       //calculate volume at left border          
+	  }
+	  if (kx<-kprec){ //negative  derivation
+	    if (x<(xp1+dy*kx)){       //calculate volume at left border
 	      Double_t xx1  = x;
 	      Double_t xx2  = TMath::Min(x+dx,xp3-dy/kx);
 	      Double_t yy1  = y+(xx1-xp1)/kx;
-	      Double_t yy2  = TMath::Max(y,yy1+(xx2-xx1)/kx); //yy2<yy1 
+	      Double_t yy2  = TMath::Max(y,yy1+(xx2-xx1)/kx); //yy2<yy1
 	      z = z0;
-	      z-= z0*(yy2-y)/dy; // constant part rectangle 
-	      z-= f1y*(xx2-xx1)*(yy2-y)*(yy2-y)/(2.*dx*dy); 
+	      z-= z0*(yy2-y)/dy; // constant part rectangle
+	      z-= f1y*(xx2-xx1)*(yy2-y)*(yy2-y)/(2.*dx*dy);
 	      z-=z0*(xx2-xx1)*(yy1-yy2)/(2*dx*dy); //constant part triangle
 	    }
-	    if (x>xp2){       //calculate volume at right  border 
+	    if (x>xp2){       //calculate volume at right  border
 	      Double_t xx1  = TMath::Max(x,xp2+dy*kx);
 	      Double_t xx2  = x+dx;
 	      Double_t yy1  = TMath::Min(y+dy,y-(xp2-xx1)/kx);
 	      Double_t yy2  = y-(xp2-xx2)/kx;
 	      z=z0;
 	      z-=z0*(yy2-y)/dy;  //constant part rextangle
-	      z-= f1y*(xx2-xx1)*(yy2-y)*(yy2-y)/(2.*dx*dy); 
+	      z-= f1y*(xx2-xx1)*(yy2-y)*(yy2-y)/(2.*dx*dy);
 	      z-=z0*(xx2-xx1)*(yy1-yy2)/(2*dx*dy); //constant part triangle
-	    }     	    
-	  }	
-	       
+	    }
+	  }
+
 	  if (z>0.)	      sumch+=fKNorm*z*dx*dy/fInteg;
-	  
+
 	  x+=dx;
 	  dx = ndx;
-	}; //loop over x  	  
+	}; //loop over x
 	fcharge[i]+=sumch;
 	}//if x2>x1
 	y+=dy;
 	dy =ndy;
       }//step over different y
       k*=-1.;
-    }//step over chevron 
-    
+    }//step over chevron
+
    }//step over different points on line NPRF
 }
 
 void AliTPCPRF2D::UpdateSigma()
 {
-  //
-  //calulate effective sigma X and sigma y of PRF
+  /// calulate effective sigma X and sigma y of PRF
+
   fMeanX = 0;
   fMeanY = 0;
   fSigmaX = 0;
   fSigmaY = 0;
- 
+
   Float_t sum =0;
   Int_t i;
   Float_t x,y;
@@ -653,29 +659,29 @@ void AliTPCPRF2D::UpdateSigma()
     else
       y = fY1+Float_t(i)*(fY2-fY1)/Float_t(fNYdiv-1);
     for (x =-fNPRF*fDStep; x<fNPRF*fDStep;x+=fDStep)
-      {      
+      {
 	//x in cm fWidth in cm
 	Float_t weight = GetPRF(x,y);
-	fSigmaX+=x*x*weight; 
+	fSigmaX+=x*x*weight;
 	fSigmaY+=y*y*weight;
 	fMeanX+=x*weight;
 	fMeanY+=y*weight;
 	sum+=weight;
-    };  
+    };
   }
   if (sum>0){
     fMeanX/=sum;
-    fMeanY/=sum;    
+    fMeanY/=sum;
     fSigmaX = TMath::Sqrt(fSigmaX/sum-fMeanX*fMeanX);
-    fSigmaY = TMath::Sqrt(fSigmaY/sum-fMeanY*fMeanY);   
+    fSigmaY = TMath::Sqrt(fSigmaY/sum-fMeanY*fMeanY);
   }
-  else fSigmaX=0; 
+  else fSigmaX=0;
 }
 
 
 void AliTPCPRF2D::Streamer(TBuffer &xRuub)
 {
-   // Stream an object of class AliTPCPRF2D
+   /// Stream an object of class AliTPCPRF2D
 
    if (xRuub.IsReading()) {
       UInt_t xRuus, xRuuc;
@@ -683,13 +689,13 @@ void AliTPCPRF2D::Streamer(TBuffer &xRuub)
       AliTPCPRF2D::Class()->ReadBuffer(xRuub, this, xRuuv, xRuus, xRuuc);
       //read functions
       if (strncmp(fType,"User",3)!=0){
-	delete fGRF;  
-        if (strncmp(fType,"Gauss",3)==0) 
+	delete fGRF;
+        if (strncmp(fType,"Gauss",3)==0)
 	  fGRF = new TF2("FunGauss2D",FunGauss2D,-5.,5.,-5.,5.,4);
-        if (strncmp(fType,"Cosh",3)==0) 
+        if (strncmp(fType,"Cosh",3)==0)
 	  fGRF = new TF2("FunCosh2D",FunCosh2D,-5.,5.,-5.,5.,4);
-        if (strncmp(fType,"Gati",3)==0) 
-	  fGRF = new TF2("FunGati2D",FunGati2D,-5.,5.,-5.,5.,5);      
+        if (strncmp(fType,"Gati",3)==0)
+	  fGRF = new TF2("FunGati2D",FunGati2D,-5.,5.,-5.,5.,5);
         if (fGRF!=0) fGRF->SetParameters(funParam);
       }
       //calculate conversion coefitient to convert position to virtual wire
@@ -703,12 +709,13 @@ void AliTPCPRF2D::Streamer(TBuffer &xRuub)
 
 TH1F *  AliTPCPRF2D::GenerDrawXHisto(Float_t x1, Float_t x2,Float_t y)
 {
-  //gener one dimensional hist of pad response function
-  //  at position y 
-  char s[100]; 
+  /// gener one dimensional hist of pad response function
+  ///  at position y
+
+  char s[100];
   const Int_t kn=200;
-  //sprintf(s,"Pad Response Function"); 
-  snprintf(s,100,"Pad Response Function");  
+  //sprintf(s,"Pad Response Function");
+  snprintf(s,100,"Pad Response Function");
   TH1F * hPRFc = new TH1F("hPRFc",s,kn+1,x1,x2);
   Float_t x=x1;
   Float_t y1;
@@ -721,20 +728,19 @@ TH1F *  AliTPCPRF2D::GenerDrawXHisto(Float_t x1, Float_t x2,Float_t y)
     };
   hPRFc->SetXTitle("pad  (cm)");
   return hPRFc;
-}  
+}
 
 AliH2F * AliTPCPRF2D::GenerDrawHisto(Float_t x1, Float_t x2, Float_t y1, Float_t y2, Int_t Nx, Int_t Ny)
 {
-  //
-  //gener two dimensional histogram with PRF
-  //
+  /// gener two dimensional histogram with PRF
+
   char s[100];
-  //sprintf(s,"Pad Response Function"); 
-  snprintf(s,100,"Pad Response Function");  
+  //sprintf(s,"Pad Response Function");
+  snprintf(s,100,"Pad Response Function");
   AliH2F * hPRFc = new AliH2F("hPRFc",s,Nx,x1,x2,Ny,y1,y2);
   Float_t dx=(x2-x1)/Float_t(Nx);
   Float_t dy=(y2-y1)/Float_t(Ny) ;
-  Float_t x,y,z; 
+  Float_t x,y,z;
   x = x1;
   y = y1;
   for ( Int_t i  = 0;i<=Nx;i++,x+=dx){
@@ -743,7 +749,7 @@ AliH2F * AliTPCPRF2D::GenerDrawHisto(Float_t x1, Float_t x2, Float_t y1, Float_t
       z = GetPRF(x,y);
       hPRFc->SetBinContent(hPRFc->GetBin(i,j),z);
     };
-  }; 
+  };
   hPRFc->SetXTitle("pad direction (cm)");
   hPRFc->SetYTitle("pad row  direction (cm)");
   hPRFc->SetTitleOffset(1.5,"X");
@@ -754,12 +760,13 @@ AliH2F * AliTPCPRF2D::GenerDrawHisto(Float_t x1, Float_t x2, Float_t y1, Float_t
 
 AliH2F * AliTPCPRF2D::GenerDrawDistHisto(Float_t x1, Float_t x2, Float_t y1, Float_t y2, Int_t Nx, Int_t Ny, Float_t  thr)
 {
-  //return histogram with distortion
+  /// return histogram with distortion
+
   const Float_t kminth=0.00001;
   if (thr<kminth) thr=kminth;
-  char s[100]; 
-  //sprintf(s,"COG distortion of PRF (threshold=%2.2f)",thr); 
-  snprintf(s,100,"COG distortion of PRF (threshold=%2.2f)",thr); 
+  char s[100];
+  //sprintf(s,"COG distortion of PRF (threshold=%2.2f)",thr);
+  snprintf(s,100,"COG distortion of PRF (threshold=%2.2f)",thr);
   AliH2F * hPRFDist = new AliH2F("hDistortion",s,Nx,x1,x2,Ny,y1,y2);
   Float_t dx=(x2-x1)/Float_t(Nx);
   Float_t dy=(y2-y1)/Float_t(Ny) ;
@@ -767,20 +774,20 @@ AliH2F * AliTPCPRF2D::GenerDrawDistHisto(Float_t x1, Float_t x2, Float_t y1, Flo
   x=x1;
   for ( Int_t i  = 0;i<=Nx;i++,x+=dx){
     y=y1;
-    for(Int_t j  = 0;j<=Ny;j++,y+=dy)      
+    for(Int_t j  = 0;j<=Ny;j++,y+=dy)
       {
 	Float_t sumx=0;
 	Float_t sum=0;
 	for (Int_t k=-3;k<=3;k++)
-	  {	    
+	  {
 	    Float_t padx=Float_t(k)*fWidth;
-	    z = GetPRF(x-padx,y); 
+	    z = GetPRF(x-padx,y);
 	    if (z>thr){
 	      sum+=z;
 	      sumx+=z*padx;
-	    }	
-	  };	
-	if (sum>kminth)  
+	    }
+	  };
+	if (sum>kminth)
 	  {
 	    ddx = (x-(sumx/sum));
 	  }
@@ -794,33 +801,32 @@ AliH2F * AliTPCPRF2D::GenerDrawDistHisto(Float_t x1, Float_t x2, Float_t y1, Flo
   hPRFDist->SetTitleOffset(1.5,"X");
   hPRFDist->SetTitleOffset(1.5,"Y");
   return hPRFDist;
-}  
-  
+}
+
 
 
 
 
 void AliTPCPRF2D::DrawX(Float_t x1 ,Float_t x2,Float_t y1,Float_t y2, Int_t N)
-{ 
-  //
-  //draw pad response function at interval <x1,x2> at  given y position
-  //
+{
+  /// draw pad response function at interval <x1,x2> at  given y position
+
   if (N<0) return;
   TCanvas  * c1 = new TCanvas("PRFX","Pad response function",700,900);
-  c1->cd();  
-  
+  c1->cd();
+
   TPaveText * comment = new TPaveText(0.05,0.02,0.95,0.20,"NDC");
   comment->SetTextAlign(12);
   comment->SetFillColor(42);
-  DrawComment(comment);  
+  DrawComment(comment);
   comment->Draw();
-  c1->cd(); 
+  c1->cd();
 
   TPad * pad2 = new TPad("pPRF","",0.05,0.22,0.95,0.95);
   pad2->Divide(2,(N+1)/2);
   pad2->Draw();
   gStyle->SetOptFit(1);
-  gStyle->SetOptStat(1); 
+  gStyle->SetOptStat(1);
   for (Int_t i=0;i<N;i++){
     char ch[200];
     Float_t y;
@@ -830,42 +836,42 @@ void AliTPCPRF2D::DrawX(Float_t x1 ,Float_t x2,Float_t y1,Float_t y2, Int_t N)
     TH1F * hPRFc =GenerDrawXHisto(x1, x2,y);
     //sprintf(ch,"PRF at wire position: %2.3f",y);
     snprintf(ch,40,"PRF at wire position: %2.3f",y);
-    hPRFc->SetTitle(ch);  
+    hPRFc->SetTitle(ch);
     //sprintf(ch,"PRF %d",i);
     snprintf(ch,15,"PRF %d",i);
-    hPRFc->SetName(ch);  
+    hPRFc->SetName(ch);
      hPRFc->Fit("gaus");
   }
- 
+
 }
 
 
 
 void AliTPCPRF2D::DrawPRF(Float_t x1 ,Float_t x2,Float_t y1, Float_t y2, Int_t Nx, Int_t Ny)
-{ 
-  //
-  //
+{
+  ///
+
   TCanvas  * c1 = new TCanvas("canPRF","Pad response function",700,900);
   c1->cd();
   TPad * pad2 = new TPad("pad2PRF","",0.05,0.22,0.95,0.95);
-  pad2->Draw(); 
+  pad2->Draw();
   gStyle->SetOptFit(1);
-  gStyle->SetOptStat(1); 
-  TH2F * hPRFc = GenerDrawHisto(x1, x2, y1, y2, Nx,Ny);   
+  gStyle->SetOptStat(1);
+  TH2F * hPRFc = GenerDrawHisto(x1, x2, y1, y2, Nx,Ny);
   pad2->cd();
   hPRFc->Draw("surf");
-  c1->cd(); 
+  c1->cd();
   TPaveText * comment = new TPaveText(0.05,0.02,0.95,0.20,"NDC");
   comment->SetTextAlign(12);
   comment->SetFillColor(42);
-  DrawComment(comment);  
+  DrawComment(comment);
   comment->Draw();
 }
 
 void AliTPCPRF2D::DrawDist(Float_t x1 ,Float_t x2,Float_t y1, Float_t y2, Int_t Nx, Int_t Ny, Float_t thr)
-{ 
-  //
-  //draw distortion of the COG method - for different threshold parameter
+{
+  /// draw distortion of the COG method - for different threshold parameter
+
   TCanvas  * c1 = new TCanvas("padDistortion","COG distortion",700,900);
   c1->cd();
   TPad * pad1 = new TPad("dist","",0.05,0.55,0.95,0.95,21);
@@ -873,32 +879,31 @@ void AliTPCPRF2D::DrawDist(Float_t x1 ,Float_t x2,Float_t y1, Float_t y2, Int_t
   TPad * pad2 = new TPad("dist","",0.05,0.22,0.95,0.53,21);
   pad2->Draw();
   gStyle->SetOptFit(1);
-  gStyle->SetOptStat(0); 
-  
-  AliH2F * hPRFDist = GenerDrawDistHisto(x1, x2, y1, y2, Nx,Ny,thr); 
-  
+  gStyle->SetOptStat(0);
+
+  AliH2F * hPRFDist = GenerDrawDistHisto(x1, x2, y1, y2, Nx,Ny,thr);
+
   pad1->cd();
   hPRFDist->Draw("surf");
   Float_t distmax =hPRFDist->GetMaximum();
   Float_t distmin =hPRFDist->GetMinimum();
-  gStyle->SetOptStat(1); 
-  
+  gStyle->SetOptStat(1);
+
   TH1F * dist = hPRFDist->GetAmplitudes(distmin,distmax,distmin-1);
   pad2->cd();
   dist->Draw();
-  c1->cd(); 
+  c1->cd();
   TPaveText * comment = new TPaveText(0.05,0.02,0.95,0.20,"NDC");
   comment->SetTextAlign(12);
   comment->SetFillColor(42);
-  DrawComment(comment);  
+  DrawComment(comment);
   comment->Draw();
 }
 
 void AliTPCPRF2D::DrawComment(TPaveText *comment)
 {
-  //
-  //function to write comment to picture 
-  
+  /// function to write comment to picture
+
   char s[100];
   //draw comments to picture
   TText * title = comment->AddText("Pad Response Function  parameters:");
@@ -912,65 +917,65 @@ void AliTPCPRF2D::DrawComment(TPaveText *comment)
   //sprintf(s,"Pad Angle:  %2.2f ",fPadAngle);
   snprintf(s,100,"Pad Angle:  %2.2f ",fPadAngle);
   comment->AddText(s);
-  
+
   if (TMath::Abs(fK)>0.0001){
     //sprintf(s,"Height of one chevron unit h:  %2.2f cm",2*fHeightS);
     snprintf(s,100,"Height of one chevron unit h:  %2.2f cm",2*fHeightS);
     comment->AddText(s);
     //sprintf(s,"Overlap factor:  %2.2f",fK);
     snprintf(s,100,"Overlap factor:  %2.2f",fK);
-    comment->AddText(s); 
+    comment->AddText(s);
   }
 
   if (strncmp(fType,"User",3)==0){
     //sprintf(s,"Charge distribution - user defined function  %s ",fGRF->GetTitle());
     snprintf(s,100,"Charge distribution - user defined function  %s ",fGRF->GetTitle());
-    comment->AddText(s);  
+    comment->AddText(s);
     //sprintf(s,"Sigma x of charge distribution: %2.2f ",fOrigSigmaX);
-    snprintf(s,100,"Sigma x of charge distribution: %2.2f ",fOrigSigmaX);  
-    comment->AddText(s);  
+    snprintf(s,100,"Sigma x of charge distribution: %2.2f ",fOrigSigmaX);
+    comment->AddText(s);
     //sprintf(s,"Sigma y of charge distribution: %2.2f ",fOrigSigmaY);
     snprintf(s,100,"Sigma y of charge distribution: %2.2f ",fOrigSigmaY);
-    comment->AddText(s); 
+    comment->AddText(s);
   }
   if (strncmp(fType,"Gauss",3)==0){
     //sprintf(s,"Gauss charge distribution");
     snprintf(s,100,"Gauss charge distribution");
-    comment->AddText(s);  
+    comment->AddText(s);
     //sprintf(s,"Sigma x of charge distribution: %2.2f ",fOrigSigmaX);
     snprintf(s,100,"Sigma x of charge distribution: %2.2f ",fOrigSigmaX);
-    comment->AddText(s);  
+    comment->AddText(s);
     //sprintf(s,"Sigma y of charge distribution: %2.2f ",fOrigSigmaY);
     snprintf(s,100,"Sigma y of charge distribution: %2.2f ",fOrigSigmaY);
-    comment->AddText(s); 
+    comment->AddText(s);
   }
   if (strncmp(fType,"Gati",3)==0){
     //sprintf(s,"Gati charge distribution");
     snprintf(s,100,"Gati charge distribution");
-    comment->AddText(s);  
+    comment->AddText(s);
     //sprintf(s,"K3X of Gati : %2.2f ",fK3X);
     snprintf(s,100,"K3X of Gati : %2.2f ",fK3X);
-    comment->AddText(s);  
+    comment->AddText(s);
     //sprintf(s,"K3Y of Gati: %2.2f ",fK3Y);
     snprintf(s,100,"K3Y of Gati: %2.2f ",fK3Y);
-    comment->AddText(s); 
+    comment->AddText(s);
     //sprintf(s,"Wire to Pad Distance: %2.2f ",fPadDistance);
     snprintf(s,100,"Wire to Pad Distance: %2.2f ",fPadDistance);
-    comment->AddText(s); 
+    comment->AddText(s);
   }
   if (strncmp(fType,"Cosh",3)==0){
     //sprintf(s,"Cosh charge distribution");
     snprintf(s,100,"Cosh charge distribution");
-    comment->AddText(s);  
+    comment->AddText(s);
     //sprintf(s,"Sigma x of charge distribution: %2.2f ",fOrigSigmaX);
     snprintf(s,100,"Sigma x of charge distribution: %2.2f ",fOrigSigmaX);
-    comment->AddText(s);  
+    comment->AddText(s);
     //sprintf(s,"Sigma y of charge distribution: %2.2f ",fOrigSigmaY);
     snprintf(s,100,"Sigma y of charge distribution: %2.2f ",fOrigSigmaY);
-    comment->AddText(s); 
+    comment->AddText(s);
   }
   //sprintf(s,"Normalisation: %2.2f ",fKNorm);
   snprintf(s,100,"Normalisation: %2.2f ",fKNorm);
-  comment->AddText(s);    
+  comment->AddText(s);
 }
 
diff --git a/TPC/TPCbase/AliTPCPRF2D.h b/TPC/TPCbase/AliTPCPRF2D.h
index 74396ab10a7..742e836e1df 100644
--- a/TPC/TPCbase/AliTPCPRF2D.h
+++ b/TPC/TPCbase/AliTPCPRF2D.h
@@ -3,11 +3,11 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-/* $Id$ */
-//////////////////////////////////////////////////////////////////
-//  Manager class for AliTPCPRF2D                               //
-//  This is to generate the 2-dimensional pad-response function //
-//////////////////////////////////////////////////////////////////
+/// \class AliTPCPRF2D
+/// \brief Manager class for AliTPCPRF2D
+///
+/// This is to generate the 2-dimensional pad-response function
+
 #include "TObject.h"
 
 class TF2;
@@ -17,36 +17,36 @@ class AliH2F;
 class TPaveText;
 
 class AliTPCPRF2D : public TObject {
-public : 
+public :
   AliTPCPRF2D();
-  virtual ~AliTPCPRF2D(); 
+  virtual ~AliTPCPRF2D();
   virtual void Update();  //recalculate tables for charge calculation
-  Float_t GetGRF(Float_t xin, Float_t yin); 
+  Float_t GetGRF(Float_t xin, Float_t yin);
   //return generic response function  in xin
   virtual TF2 * GetGRF(){return fGRF;}
-  virtual Float_t GetPRF(Float_t xin, Float_t yin); 
+  virtual Float_t GetPRF(Float_t xin, Float_t yin);
   //return PRF in point xin,yin
 
   virtual void DrawX(Float_t x1 ,Float_t x2,Float_t y1,Float_t y2=0, Int_t N=1);
   virtual void DrawPRF(Float_t x1, Float_t x2, Float_t y1, Float_t y2, Int_t Nx=20, Int_t Ny=20);
   //draw two dimensional PRF
 
-  virtual void DrawDist(Float_t x1, Float_t x2, Float_t y1, Float_t y2, Int_t Nx=20, Int_t Ny=20, 
+  virtual void DrawDist(Float_t x1, Float_t x2, Float_t y1, Float_t y2, Int_t Nx=20, Int_t Ny=20,
 		Float_t  thr=0);
   //draw distortion of COG method
   //we suppose threshold equal to thr
-  TH1F *  GenerDrawXHisto(Float_t x1, Float_t x2,Float_t y);  
+  TH1F *  GenerDrawXHisto(Float_t x1, Float_t x2,Float_t y);
   AliH2F * GenerDrawHisto(Float_t x1, Float_t x2, Float_t y1, Float_t y2, Int_t Nx=20, Int_t Ny=20);
-  AliH2F * GenerDrawDistHisto(Float_t x1, Float_t x2, Float_t y1, Float_t y2, Int_t Nx=20, Int_t Ny=20, 
-		Float_t  thr=0);  
-  
+  AliH2F * GenerDrawDistHisto(Float_t x1, Float_t x2, Float_t y1, Float_t y2, Int_t Nx=20, Int_t Ny=20,
+		Float_t  thr=0);
+
   virtual void SetPad(Float_t width, Float_t height);
   //set base chevron parameters
   virtual void SetChevron(Float_t hstep, Float_t shifty, Float_t fac);
-  //set chevron parameters   
+  //set chevron parameters
   virtual void SetChParam(Float_t width, Float_t height,
 		  Float_t hstep, Float_t shifty, Float_t fac);
-  //set all geometrical parameters     
+  //set all geometrical parameters
   virtual void SetY(Float_t y1, Float_t y2, Int_t nYdiv) ;
   virtual void SetChargeAngle(Float_t angle){fChargeAngle = angle;} //set angle of pad and charge distribution
                                                             //axes
@@ -54,79 +54,82 @@ public :
   virtual void SetPadAngle(Float_t angle){fPadAngle = angle;} //set pad angle
   void SetInterpolationType(Int_t interx, Int_t intery) {fInterX=interx; fInterY =intery;}
   virtual void SetGauss(Float_t sigmaX,Float_t sigmaY , Float_t kNorm=1);
-  //adjust PRF with GAUSIAN as generic GRF 
+  //adjust PRF with GAUSIAN as generic GRF
   //if  direct = kTRUE then it does't convolute distribution
   virtual void SetCosh(Float_t sigmaX,Float_t sigmaY , Float_t kNorm=1);
   //adjust PRF with 1/Cosh  as generic GRF
   virtual void  SetGati(Float_t K3X, Float_t K3Y,
 		     Float_t padDistance,
 		     Float_t kNorm=1);
-  void SetParam(TF2 *const GRF,Float_t kNorm, 
+  void SetParam(TF2 *const GRF,Float_t kNorm,
 		Float_t sigmaX=0, Float_t sigmaY=0);
   void SetNdiv(Int_t Ndiv){fNdiv=Ndiv;}
   virtual Float_t GetSigmaX() const {return fSigmaX;}
   virtual Float_t GetSigmaY() const {return fSigmaY;}
-  
-  
+
+
 protected:
-  void Update1(); 
+  void Update1();
   virtual void UpdateSigma();  //recalculate sigma of PRF
   Float_t GetPRFActiv(Float_t xin); //return PRF in point xin and actual y
-  Float_t  * fcharge; //!field with PRF 
-  Float_t fY1;        //position of first "virtual" vire 
-  Float_t fY2;        //position of last virtual vire
-  Int_t fNYdiv;       //number of wires
-  Int_t fNChargeArray;  //number of charge interpolation points
-  Float_t * fChargeArray;  //[fNChargeArray]pointer to array of arrays
- 
+  Float_t  * fcharge; //!< field with PRF
+  Float_t fY1;        ///< position of first "virtual" vire
+  Float_t fY2;        ///< position of last virtual vire
+  Int_t fNYdiv;       ///< number of wires
+  Int_t fNChargeArray;  ///< number of charge interpolation points
+  /// pointer to array of arrays
+  Float_t * fChargeArray;  //[fNChargeArray]
+
   void DrawComment(TPaveText * comment);  //draw comments to picture
   //chevron parameters
-  Float_t fHeightFull;  //height of the full pad
-  Float_t fHeightS;     //height of the one step
-  Float_t fShiftY;      //shift of the step
-  Float_t fWidth;       //width of the pad
-  Float_t fK;           //k factor of the chewron
-
-  Double_t funParam[5];//parameters of used charge function
-  Int_t  fNPRF;      //number of interpolations point
-  Int_t  fNdiv;      //number of division to calculate integral
-  Float_t fDStep;    //element step for point 
-  Float_t fKNorm;     //normalisation factor of the charge integral
-  Float_t fInteg;     //integral of GRF on +- infinity
-  TF2 *  fGRF;        //charge distribution function
-
-  Float_t fK3X;       //KX parameter (only for Gati parametrization)
-  Float_t fK3Y;       //KY parameter (only for Gati parametrisation)
-  Float_t fPadDistance; //pad anode distnce (only for Gati parametrisation)
-
-  Float_t  fOrigSigmaX; //sigma of original distribution;  
-  Float_t  fOrigSigmaY; //sigma of original distribution;  
-
-  Float_t  fChargeAngle;//'angle' of charge distribution refernce system to pad reference system
-  Float_t  fPadAngle;   //'angle' of the pad assymetry
-
-  Float_t  fSigmaX;    //sigma X of PAD response function
-  Float_t  fSigmaY;    //sigma Y of PAD response function
-  Float_t  fMeanX;     //mean X value
-  Float_t  fMeanY;     //mean Y value
-  Int_t    fInterX;    //interpolation in X
-  Int_t    fInterY;    //interpolation in Y
+  Float_t fHeightFull;  ///< height of the full pad
+  Float_t fHeightS;     ///< height of the one step
+  Float_t fShiftY;      ///< shift of the step
+  Float_t fWidth;       ///< width of the pad
+  Float_t fK;           ///< k factor of the chewron
+
+  Double_t funParam[5];///< parameters of used charge function
+  Int_t  fNPRF;      ///< number of interpolations point
+  Int_t  fNdiv;      ///< number of division to calculate integral
+  Float_t fDStep;    ///< element step for point
+  Float_t fKNorm;     ///< normalisation factor of the charge integral
+  Float_t fInteg;     ///< integral of GRF on +- infinity
+  TF2 *  fGRF;        ///< charge distribution function
+
+  Float_t fK3X;       ///< KX parameter (only for Gati parametrization)
+  Float_t fK3Y;       ///< KY parameter (only for Gati parametrisation)
+  Float_t fPadDistance; ///< pad anode distnce (only for Gati parametrisation)
+
+  Float_t  fOrigSigmaX; ///< sigma of original distribution;
+  Float_t  fOrigSigmaY; ///< sigma of original distribution;
+
+  Float_t  fChargeAngle;///< 'angle' of charge distribution refernce system to pad reference system
+  Float_t  fPadAngle;   ///< 'angle' of the pad assymetry
+
+  Float_t  fSigmaX;    ///< sigma X of PAD response function
+  Float_t  fSigmaY;    ///< sigma Y of PAD response function
+  Float_t  fMeanX;     ///< mean X value
+  Float_t  fMeanY;     ///< mean Y value
+  Int_t    fInterX;    ///< interpolation in X
+  Int_t    fInterY;    ///< interpolation in Y
   //calculated during update
 
-  char  fType[5];       //charge type
-  Float_t fCurrentY;    //in reality we calculate PRF only for one fixed y 
-  Float_t fDYtoWire;    //! used to make PRF calculation faster in GetPRF
-  Float_t fDStepM1;     //! used in GetPRFActiv to make calculation faster  
+  char  fType[5];       ///< charge type
+  Float_t fCurrentY;    ///< in reality we calculate PRF only for one fixed y
+  Float_t fDYtoWire;    //!< used to make PRF calculation faster in GetPRF
+  Float_t fDStepM1;     //!< used in GetPRFActiv to make calculation faster
   //
-  static const Double_t fgkDegtoRad; //numeric constant
-  static const Double_t fgkSQRT12; //numeric constant
-  static const Int_t   fgkNPRF;   //default number of division
+  static const Double_t fgkDegtoRad; ///< numeric constant
+  static const Double_t fgkSQRT12; ///< numeric constant
+  static const Int_t   fgkNPRF;   ///< default number of division
 
-private: 
+private:
   AliTPCPRF2D(const AliTPCPRF2D &prf);
   AliTPCPRF2D &operator = (const AliTPCPRF2D &/*prf*/) {return *this;}
-  
-  ClassDef(AliTPCPRF2D,1) 
-};   
+
+  /// \cond CLASSIMP
+  ClassDef(AliTPCPRF2D,1)
+  /// \endcond
+};
 
 #endif /* ALITPCPRF2D_H */
diff --git a/TPC/TPCbase/AliTPCParam.cxx b/TPC/TPCbase/AliTPCParam.cxx
index 9df128949be..fb012f225e7 100644
--- a/TPC/TPCbase/AliTPCParam.cxx
+++ b/TPC/TPCbase/AliTPCParam.cxx
@@ -13,18 +13,16 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/* $Id$ */
-
-///////////////////////////////////////////////////////////////////////
-//  Manager and of geomety  classes for set: TPC                     //
-//                                                                   //
-//  !sectors are numbered from  0                                     //
-//  !pad rows are numbered from 0                                     //
-//  
-//  12.6.   changed z relative 
-//  Origin:  Marian Ivanov, Uni. of Bratislava, ivanov@fmph.uniba.sk // 
-//                                                                   //  
-///////////////////////////////////////////////////////////////////////
+
+/// \class AliTPCParam
+/// \brief Manager and of geomety  classes for set: TPC
+///
+/// !sectors are numbered from  0
+/// !pad rows are numbered from 0
+///
+/// 12.6.   changed z relative
+///
+/// \author Marian Ivanov, Uni. of Bratislava, ivanov@fmph.uniba.sk
 
 //
 
@@ -43,7 +41,9 @@
 
 TObjArray *AliTPCParam::fBBParam = 0;
 
+/// \cond CLASSIMP
 ClassImp(AliTPCParam)
+/// \endcond
 
 
 //___________________________________________
@@ -69,7 +69,7 @@ AliTPCParam::AliTPCParam()
 	     fRotAngle(),
 	     fGeometryType(0),
 	     fTrackingMatrix(0),
-	     fClusterMatrix(0), 
+	     fClusterMatrix(0),
 	     fGlobalMatrix(0),
 	     fNInnerWiresPerPad(0),
 	     fInnerWWPitch(0),
@@ -145,22 +145,20 @@ AliTPCParam::AliTPCParam()
 	     fGateDelay(0.),
 	     fL1Delay(0.),
 	     fNTBinsBeforeL1(0),
-	     fNTBinsL1(0.)   
-{   
+	     fNTBinsL1(0.)
+{
   //
   //constructor sets the default parameters
   //
 
   SetTitle("75x40_100x60_150x60");
-  SetDefault();  
+  SetDefault();
   if (!fBBParam) fBBParam= new TObjArray(1000);
 }
 
 AliTPCParam::~AliTPCParam()
 {
-  //
-  //destructor deletes some dynamicaly alocated variables
-  //
+  /// destructor deletes some dynamicaly alocated variables
 
   if (fResponseBin!=0)    delete [] fResponseBin;
   if (fResponseWeight!=0) delete [] fResponseWeight;
@@ -172,10 +170,8 @@ AliTPCParam::~AliTPCParam()
 
 Int_t  AliTPCParam::Transform0to1(Float_t *xyz, Int_t * index)  const
 {
-  //
-  // calculates sector number (index[1], undefined on input)
-  // xyz intact
-  //
+  /// calculates sector number (index[1], undefined on input)
+  /// xyz intact
 
   Float_t angle,x1;
   Int_t sector;
@@ -188,19 +184,19 @@ Int_t  AliTPCParam::Transform0to1(Float_t *xyz, Int_t * index)  const
       if ( (xyz[0]>0) && (xyz[1]<0) ) angle=2*TMath::Pi()+angle;
     }
 
-  sector=Int_t(TMath::Nint((angle-fInnerAngleShift)/fInnerAngle));      
- 
+  sector=Int_t(TMath::Nint((angle-fInnerAngleShift)/fInnerAngle));
+
   Float_t cos,sin;
   AdjustCosSin(sector,cos,sin);
   x1=xyz[0]*cos + xyz[1]*sin;
 
   if (x1>fOuterRadiusLow)
     {
-      sector=Int_t(TMath::Nint((angle-fOuterAngleShift)/fOuterAngle))+fNInnerSector;      
-      if (xyz[2]<0) 	sector+=(fNOuterSector>>1);            
+      sector=Int_t(TMath::Nint((angle-fOuterAngleShift)/fOuterAngle))+fNInnerSector;
+      if (xyz[2]<0) 	sector+=(fNOuterSector>>1);
     }
-    else   
-      if (xyz[2]<0) sector+=(fNInnerSector>>1);  
+    else
+      if (xyz[2]<0) sector+=(fNInnerSector>>1);
   if (sector<0 || sector>=fNSector) AliError(Form("Wrong sector %d",sector));
   index[1]=sector; // calculated sector number
   index[0]=1; // indicates system after transformation
@@ -209,7 +205,8 @@ Int_t  AliTPCParam::Transform0to1(Float_t *xyz, Int_t * index)  const
 
 Bool_t  AliTPCParam::Transform(Float_t */*xyz*/, Int_t *index, Int_t* /*oindex*/)
 {
-  //transformation from input coodination system to output coordination system
+  /// transformation from input coodination system to output coordination system
+
   switch (index[0]){
   case 0:
     break;
@@ -219,72 +216,71 @@ Bool_t  AliTPCParam::Transform(Float_t */*xyz*/, Int_t *index, Int_t* /*oindex*/
 
 }
 
-Int_t AliTPCParam::GetPadRow(Float_t *xyz, Int_t *index) const 
+Int_t AliTPCParam::GetPadRow(Float_t *xyz, Int_t *index) const
 {
-  //
-  //calculates pad row of point xyz - transformation to system 8 (digit system)
-  //
+  /// calculates pad row of point xyz - transformation to system 8 (digit system)
+
   Int_t system = index[0];
   if (0==system) {
-    Transform0to1(xyz,index); 
+    Transform0to1(xyz,index);
     system=1;
   }
   if (1==system) {
-    Transform1to2(xyz,index); 
+    Transform1to2(xyz,index);
     system=2;
   }
-    
-  if (fGeometryType==0){ //straight row    
+
+  if (fGeometryType==0){ //straight row
     if (2==system) {
-      Transform2to3(xyz,index);       
+      Transform2to3(xyz,index);
       system=3;
-    } 
+    }
     if (3==system) {
       Transform3to4(xyz,index);
-      system=4; 
+      system=4;
     }
     if (4==system) {
       Transform4to8(xyz,index);
-      system=8;     
+      system=8;
     }
     if (8==system) {
       index[0]=8;
       return index[2];
-    } 
+    }
   }
 
-  if (fGeometryType==1){ //cylindrical geometry    
+  if (fGeometryType==1){ //cylindrical geometry
     if (2==system) {
-      Transform2to5(xyz,index);       
+      Transform2to5(xyz,index);
       system=5;
-    } 
+    }
     if (5==system) {
       Transform2to3(xyz,index);
       system=6;
     }
     if (6==system) {
-      Transform3to4(xyz,index); 
+      Transform3to4(xyz,index);
       system=7;
     }
     if (8==system) {
       index[0]=8;
       return index[2];
     }
-  } 
+  }
   index[0]=system;
-  return -1; //if no reasonable system     
+  return -1; //if no reasonable system
 }
 
 void  AliTPCParam::SetSectorAngles(Float_t innerangle, Float_t innershift, Float_t outerangle,
 			Float_t outershift)
 {
-  //
-  // set opening angles  
+  /// set opening angles
+
   static const  Float_t  kDegtoRad = 0.01745329251994;
   fInnerAngle = innerangle;       //opening angle of Inner sector
   fInnerAngleShift = innershift;  //shift of first inner sector center to the 0
   fOuterAngle = outerangle;       //opening angle of outer sector
-  fOuterAngleShift = outershift;  //shift of first sector center to the 0  
+  fOuterAngleShift = outershift;  //shift of first sector center to the 0
   fInnerAngle *=kDegtoRad;
   fInnerAngleShift *=kDegtoRad;
   fOuterAngle *=kDegtoRad;
@@ -293,45 +289,46 @@ void  AliTPCParam::SetSectorAngles(Float_t innerangle, Float_t innershift, Float
 
 Float_t  AliTPCParam::GetInnerAngle() const
 {
-  //return angle 
+  /// return angle
+
   return fInnerAngle;
 
 }
 
 Float_t  AliTPCParam::GetInnerAngleShift() const
-{  
-  //return angle   
-  return fInnerAngleShift;  
+{
+  /// return angle
+
+  return fInnerAngleShift;
 }
 Float_t  AliTPCParam::GetOuterAngle() const
-{ 
-  //return angle 
+{
+  /// return angle
+
   return fOuterAngle;
-} 
+}
 Float_t  AliTPCParam::GetOuterAngleShift() const
-{ 
-  //return angle 
+{
+  /// return angle
 
      return fOuterAngleShift;
-} 
+}
 
 
 Int_t AliTPCParam::GetIndex(Int_t sector, Int_t row) const
 {
-  //
-  //give index of the given sector and pad row 
-  //no control if the sectors and rows  are reasonable !!!
-  //
+  /// give index of the given sector and pad row
+  /// no control if the sectors and rows  are reasonable !!!
+
   if (sector<fNInnerSector) return sector*fNRowLow+row;
-  return (fNInnerSector*fNRowLow)+(sector-fNInnerSector)*fNRowUp+row;  
+  return (fNInnerSector*fNRowLow)+(sector-fNInnerSector)*fNRowUp+row;
 }
 
 Bool_t   AliTPCParam::AdjustSectorRow(Int_t index, Int_t & sector, Int_t &row) const
 {
-  //
-  //return sector and padrow for given index
-  //if index is reasonable returns true else return false
-  //
+  /// return sector and padrow for given index
+  /// if index is reasonable returns true else return false
+
   if ( (index<0) || (index>fNtRows))  return kFALSE;
   Int_t outindex = fNInnerSector*fNRowLow;
   if (index<outindex) {
@@ -343,18 +340,17 @@ Bool_t   AliTPCParam::AdjustSectorRow(Int_t index, Int_t & sector, Int_t &row) c
   sector = index/fNRowUp;
   row    = index - sector*fNRowUp;
   sector += fNInnerSector;
-  return kTRUE;         
-} 
+  return kTRUE;
+}
 
 void AliTPCParam::SetDefault()
 {
-  //
-  //set default parameters
-  //
-  //const static  Int_t kMaxRows=600; 
-  //
-  //sector default parameters
-  //
+  /// set default parameters
+  ///
+  /// const static  Int_t kMaxRows=600;
+  ///
+  /// sector default parameters
+
   static const  Float_t kInnerRadiusLow = 83.65;
   static const  Float_t kInnerRadiusUp  = 133.3;
   static const  Float_t kOuterRadiusLow = 133.5;
@@ -368,7 +364,7 @@ void AliTPCParam::SetDefault()
   static const  Float_t kInnerWireMount = 1.2;
   static const  Float_t kOuterWireMount = 1.4;
   static const  Float_t kZLength =250.;
-  static const  Int_t   kGeometryType = 0; //straight rows 
+  static const  Int_t   kGeometryType = 0; //straight rows
   static const Int_t kNRowLow = 63;
   static const Int_t kNRowUp1 = 64;
   static const Int_t kNRowUp2 = 32;
@@ -384,14 +380,14 @@ void AliTPCParam::SetDefault()
   static const Float_t  kInnerOffWire = 0.5;
   static const Int_t    kNOuter1WiresPerPad = 4;
   static const Int_t    kNOuter2WiresPerPad = 6;
-  static const Float_t  kOuterWWPitch = 0.25;  
+  static const Float_t  kOuterWWPitch = 0.25;
   static const Float_t  kROuterFirstWire = 134.225;
   static const Float_t  kROuterLastWire = 246.975;
   static const Int_t    kOuterDummyWire = 2;
   static const Float_t  kOuterOffWire = 0.5;
   //
   //pad default parameters
-  // 
+  //
   static const Float_t  kInnerPadPitchLength = 0.75;
   static const Float_t  kInnerPadPitchWidth = 0.40;
   static const Float_t  kInnerPadLength = 0.75;
@@ -403,13 +399,13 @@ void AliTPCParam::SetDefault()
   static const Float_t  kOuter2PadPitchLength = 1.5;
   static const Float_t  kOuter2PadLength = 1.5;
 
-  static const Bool_t   kBMWPCReadout = kTRUE; //MWPC readout - another possibility GEM 
+  static const Bool_t   kBMWPCReadout = kTRUE; //MWPC readout - another possibility GEM
   static const Int_t    kNCrossRows = 1; //number of rows to cross-talk
-  
+
   //
   //gas default parameters
   //
-  static const  Float_t  kDiffT = 2.2e-2; 
+  static const  Float_t  kDiffT = 2.2e-2;
   static const  Float_t  kDiffL = 2.2e-2;
   static const  Float_t  kGasGain = 2.e4;
   static const  Float_t  kDriftV  =2.83e6;
@@ -421,25 +417,25 @@ void AliTPCParam::SetDefault()
   static const  Float_t  kNtot=42.66;
   static const  Float_t  kWmean = 35.97e-9;
   static const  Float_t  kExp = 2.2;
-  static const  Float_t  kEend = 10.e-6; 
+  static const  Float_t  kEend = 10.e-6;
   //
   //electronic default parameters
   //
   static const  Float_t  kPadCoupling=0.5;
   static const  Int_t    kZeroSup=2;
-  static const  Float_t  kNoise = 1000;                            
+  static const  Float_t  kNoise = 1000;
   static const  Float_t  kChipGain = 12;
   static const  Float_t  kChipNorm = 0.4;
-  static const  Float_t  kTSample = 2.e-7; 
+  static const  Float_t  kTSample = 2.e-7;
   static const  Float_t  kTFWHM   = 1.9e-7;  //fwhm of charge distribution
-  static const  Int_t    kMaxTBin =445;  
-  static const  Int_t    kADCSat  =1024;  
-  static const  Float_t  kADCDynRange =2000.;  
-  // 
+  static const  Int_t    kMaxTBin =445;
+  static const  Int_t    kADCSat  =1024;
+  static const  Float_t  kADCDynRange =2000.;
+  //
   //response constants
   //
   static const Int_t     kNResponseMax=100;
-  static const Float_t   kResponseThreshold=0.01;     
+  static const Float_t   kResponseThreshold=0.01;
   //L1 constants
   //  static const Float_t   kGateDelay=6.1e-6; //In s
   static const Float_t   kGateDelay=0.; //For the moment no gating
@@ -481,7 +477,7 @@ void AliTPCParam::SetDefault()
   SetRInnerLastWire(kRInnerLastWire);
   SetOuterWWPitch(kOuterWWPitch);
   SetROuterFirstWire(kROuterFirstWire);
-  SetROuterLastWire(kROuterLastWire);  
+  SetROuterLastWire(kROuterLastWire);
   //
   //set pad parameter
   //
@@ -489,12 +485,12 @@ void AliTPCParam::SetDefault()
   SetInnerPadPitchWidth(kInnerPadPitchWidth);
   SetInnerPadLength(kInnerPadLength);
   SetInnerPadWidth(kInnerPadWidth);
-  SetOuter1PadPitchLength(kOuter1PadPitchLength); 
+  SetOuter1PadPitchLength(kOuter1PadPitchLength);
   SetOuter2PadPitchLength(kOuter2PadPitchLength);
   SetOuterPadPitchWidth(kOuterPadPitchWidth);
   SetOuter1PadLength(kOuter1PadLength);
   SetOuter2PadLength(kOuter2PadLength);
-  SetOuterPadWidth(kOuterPadWidth); 
+  SetOuterPadWidth(kOuterPadWidth);
   SetMWPCReadout(kBMWPCReadout);
   SetNCrossRows(kNCrossRows);
   //
@@ -519,13 +515,13 @@ void AliTPCParam::SetDefault()
   SetBetheBloch(GetBetheBlochParamAlice());
   SetBetheBlochMC(GetBetheBlochParamAliceMC());
   //
-  //set electronivc parameters  
+  //set electronivc parameters
   //
   SetPadCoupling(kPadCoupling);
   SetZeroSup(kZeroSup);
   SetNoise(kNoise);
   SetChipGain(kChipGain);
-  SetChipNorm(kChipNorm);   
+  SetChipNorm(kChipNorm);
   SetTSample(kTSample);
   SetTFWHM(kTFWHM);
   SetMaxTBin(kMaxTBin);
@@ -544,9 +540,9 @@ void AliTPCParam::SetDefault()
 //   SetNPrimLoss(kNPrimLoss);
 //   SetNTotalLoss(kNTotalLoss);
   //
-  //set response  parameters  
+  //set response  parameters
   //
-  SetNResponseMax(kNResponseMax); 
+  SetNResponseMax(kNResponseMax);
   SetResponseThreshold(static_cast<int>(kResponseThreshold));
   //L1 data
   SetGateDelay(kGateDelay);
@@ -555,35 +551,34 @@ void AliTPCParam::SetDefault()
   SetNominalGainSlopes();
 }
 
-          
+
 Bool_t AliTPCParam::Update()
 {
-  //
-  // update some calculated parameter which must be updated after changing "base"
-  // parameters 
-  // for example we can change size of pads and according this recalculate number
-  // of pad rows, number of of pads in given row ....
-  //
+  /// update some calculated parameter which must be updated after changing "base"
+  /// parameters
+  /// for example we can change size of pads and according this recalculate number
+  /// of pad rows, number of of pads in given row ....
+
   const Float_t kQel = 1.602e-19; // elementary charge
   fbStatus = kFALSE;
 
-  Int_t i,j;  //loop variables because HP 
+  Int_t i,j;  //loop variables because HP
   //-----------------Sector section------------------------------------------
   //calclulate number of sectors
-  fNInnerSector = Int_t(4*TMath::Pi()/fInnerAngle+0.2); 
+  fNInnerSector = Int_t(4*TMath::Pi()/fInnerAngle+0.2);
        // number of inner sectors - factor 0.2 to don't be influnced by inprecision
   if (fNInnerSector%2) return kFALSE;
-  fNOuterSector = Int_t(4*TMath::Pi()/fOuterAngle+0.2); 
+  fNOuterSector = Int_t(4*TMath::Pi()/fOuterAngle+0.2);
   if (fNOuterSector%2) return kFALSE;
   fNSector  = fNInnerSector+fNOuterSector;
 
   if (fRotAngle!=0) delete [] fRotAngle;
   fRotAngle = new Float_t[4*fNSector];
-  //calculate sin and cosine of rotations angle     
+  //calculate sin and cosine of rotations angle
   //sectors angles numbering from 0
 
   j=fNInnerSector*2;
-  Float_t angle = fInnerAngleShift; 
+  Float_t angle = fInnerAngleShift;
   for (i=0; j<fNInnerSector*4; i+=4, j+=4 , angle +=fInnerAngle){
     fRotAngle[i]=TMath::Cos(angle);
     fRotAngle[i+1]=TMath::Sin(angle);
@@ -594,7 +589,7 @@ Bool_t AliTPCParam::Update()
     fRotAngle[i+3] =angle;
     fRotAngle[j+3] =angle;    
   }
-  angle = fOuterAngleShift; 
+  angle = fOuterAngleShift;
   j=(fNInnerSector+fNOuterSector/2)*4;
   for (i=fNInnerSector*4; j<fNSector*4; i+=4,j+=4, angle +=fOuterAngle){
     fRotAngle[i]=TMath::Cos(angle);
@@ -607,26 +602,26 @@ Bool_t AliTPCParam::Update()
     fRotAngle[j+3] =angle;    
   }
 
-  fZWidth = fTSample*fDriftV;  
+  fZWidth = fTSample*fDriftV;
   fTotalNormFac = fPadCoupling*fChipNorm*kQel*1.e15*fChipGain*fADCSat/fADCDynRange;
   fNoiseNormFac = kQel*1.e15*fChipGain*fADCSat/fADCDynRange;
-  //wire section 
+  //wire section
   /*  Int_t nwire;
   Float_t wspace; //available space for wire
   Float_t dummyspace; //dummyspace for wire
- 
+
   wspace =fInnerRadiusUp-fInnerRadiusLow-2*fInnerOffWire;
   nwire = Int_t(wspace/fInnerWWPitch);
   wspace = Float_t(nwire)*fInnerWWPitch;
-  dummyspace =(fInnerRadiusUp-fInnerRadiusLow-wspace)/2.;  
+  dummyspace =(fInnerRadiusUp-fInnerRadiusLow-wspace)/2.;
   wspace =fOuterRadiusUp-fOuterRadiusLow-2*fOuterOffWire;
   nwire = Int_t(wspace/fOuterWWPitch);
   wspace = Float_t(nwire)*fOuterWWPitch;
-  dummyspace =(fOuterRadiusUp-fOuterRadiusLow-wspace)/2.; 
+  dummyspace =(fOuterRadiusUp-fOuterRadiusLow-wspace)/2.;
   fROuterFirstWire = fOuterRadiusLow+dummyspace;
   fROuterLastWire = fROuterFirstWire+fOuterWWPitch*(Float_t)(nwire);
   */
-  
+
   //
   //response data
   //
@@ -642,35 +637,32 @@ Bool_t AliTPCParam::Update()
 }
 
 void AliTPCParam::CleanGeoMatrices(){
-  //
-  // clean geo matrices
-  //
+  /// clean geo matrices
 
   if (fTrackingMatrix) {
     for(Int_t i = 0; i < fNSector; i++)
       delete fTrackingMatrix[i];
     delete [] fTrackingMatrix;
   }
-  
+
   if (fClusterMatrix) {
     for(Int_t i = 0; i < fNSector; i++)
       delete fClusterMatrix[i];
     delete [] fClusterMatrix;
   }
-  
+
   if (fGlobalMatrix) {
     for(Int_t i = 0; i < fNSector; i++)
       delete fGlobalMatrix[i];
     delete [] fGlobalMatrix;
   }
-  
+
   return;
 }
 
 Bool_t AliTPCParam::ReadGeoMatrices(){
-  //
-  // read geo matrixes
-  //
+  /// read geo matrixes
+
   if (!gGeoManager){
     AliFatal("Geo manager not initialized\n");
   }
@@ -688,12 +680,12 @@ Bool_t AliTPCParam::ReadGeoMatrices(){
     fGlobalMatrix[isec] = 0;
     fClusterMatrix[isec]= 0;
     fTrackingMatrix[isec]=0;
-  }   
+  }
   //
   for (Int_t isec=0; isec<fNSector; isec++) {
     fGlobalMatrix[isec] = 0;
     fClusterMatrix[isec]= 0;
-    fTrackingMatrix[isec]=0;   
+    fTrackingMatrix[isec]=0;
     AliGeomManager::ELayerID iLayer;
     Int_t iModule;
 
@@ -718,12 +710,12 @@ Bool_t AliTPCParam::ReadGeoMatrices(){
     TGeoHMatrix *m = gGeoManager->GetCurrentMatrix();
     // Since GEANT4 does not allow reflections, in this case the reflection
     // component if the matrix is embedded by TGeo inside TGeoScaledShape
-    if (gGeoManager->GetCurrentVolume()->GetShape()->IsReflected()) 
+    if (gGeoManager->GetCurrentVolume()->GetShape()->IsReflected())
        m->ReflectZ(kFALSE, kTRUE);
     //
-    TGeoRotation mchange; 
+    TGeoRotation mchange;
     mchange.RotateY(90); mchange.RotateX(90);
-    Float_t ROCcenter[3]; 
+    Float_t ROCcenter[3];
     GetChamberCenter(isec,ROCcenter);
     //
     // Convert to global coordinate system
@@ -741,7 +733,7 @@ Bool_t AliTPCParam::ReadGeoMatrices(){
     rotMatrix.RotateZ(sectorAngle);
     if (GetGlobalMatrix(isec)->GetTranslation()[2]>0){
       //
-      // mirrored system 
+      // mirrored system
       //
       TGeoRotation mirrorZ;
       mirrorZ.SetAngles(90,0,90,90,180,0);
@@ -749,16 +741,15 @@ Bool_t AliTPCParam::ReadGeoMatrices(){
     }
     TGeoTranslation trans(0,0,GetZLength(isec));
     fClusterMatrix[isec]->MultiplyLeft(&trans);
-    fClusterMatrix[isec]->MultiplyLeft((GetGlobalMatrix(isec)));	
+    fClusterMatrix[isec]->MultiplyLeft((GetGlobalMatrix(isec)));
     fClusterMatrix[isec]->MultiplyLeft(&(rotMatrix.Inverse()));
   }
   return kTRUE;
 }
 
 TGeoHMatrix *  AliTPCParam::Tracking2LocalMatrix(const TGeoHMatrix * geoMatrix, Int_t sector) const{
-  //
-  // make local to tracking matrix
-  //
+  /// make local to tracking matrix
+
   Double_t sectorAngle = 20.*(sector%18)+10;
   TGeoHMatrix *newMatrix = new TGeoHMatrix();
   newMatrix->RotateZ(sectorAngle);
@@ -771,34 +762,40 @@ TGeoHMatrix *  AliTPCParam::Tracking2LocalMatrix(const TGeoHMatrix * geoMatrix,
 
 Bool_t AliTPCParam::GetStatus() const
 {
-  //get information about object consistency
+  /// get information about object consistency
+
   return fbStatus;
 }
 
 Int_t AliTPCParam::GetNRowLow() const
 {
-  //get the number of pad rows in low sector
+  /// get the number of pad rows in low sector
+
   return fNRowLow;
 }
 Int_t AliTPCParam::GetNRowUp() const
 {
-  //get the number of pad rows in up sector
+  /// get the number of pad rows in up sector
+
   return fNRowUp;
 }
 Int_t AliTPCParam::GetNRowUp1() const
 {
-  //get the number of pad rows in up1 sector
+  /// get the number of pad rows in up1 sector
+
   return fNRowUp1;
 }
 Int_t AliTPCParam::GetNRowUp2() const
 {
-  //get the number of pad rows in up2 sector
+  /// get the number of pad rows in up2 sector
+
   return fNRowUp2;
 }
 Float_t AliTPCParam::GetPadRowRadiiLow(Int_t irow) const
 {
-  //get the pad row (irow) radii
-  if ( !(irow<0) && (irow<fNRowLow) ) 
+  /// get the pad row (irow) radii
+
+  if ( !(irow<0) && (irow<fNRowLow) )
     return  fPadRowLow[irow];
   else
     return 0;
@@ -806,8 +803,9 @@ Float_t AliTPCParam::GetPadRowRadiiLow(Int_t irow) const
 
 Float_t AliTPCParam::GetPadRowRadiiUp(Int_t irow) const
 {
-  //get the pad row (irow) radii
- if ( !(irow<0) && (irow<fNRowUp) ) 
+  /// get the pad row (irow) radii
+
+ if ( !(irow<0) && (irow<fNRowUp) )
     return  fPadRowUp[irow];
   else
     return 0;
@@ -815,8 +813,9 @@ Float_t AliTPCParam::GetPadRowRadiiUp(Int_t irow) const
 
 Int_t AliTPCParam::GetNPadsLow(Int_t irow) const
 {
-  //get the number of pads in row irow
-  if ( !(irow<0) && (irow<fNRowLow) ) 
+  /// get the number of pads in row irow
+
+  if ( !(irow<0) && (irow<fNRowLow) )
     return  fNPadsLow[irow];
   else
     return 0;
@@ -825,8 +824,9 @@ Int_t AliTPCParam::GetNPadsLow(Int_t irow) const
 
 Int_t AliTPCParam::GetNPadsUp(Int_t irow) const
 {
-  //get the number of pads in row irow
-  if ( !(irow<0) && (irow<fNRowUp) ) 
+  /// get the number of pads in row irow
+
+  if ( !(irow<0) && (irow<fNRowUp) )
     return  fNPadsUp[irow];
   else
     return 0;
@@ -834,24 +834,23 @@ Int_t AliTPCParam::GetNPadsUp(Int_t irow) const
 
 Int_t AliTPCParam::GetWireSegment(Int_t sector, Int_t row) const
 {
-  //
-  // Get Anode wire segment index IROC --> 4 segments in [0,3], 7 segments OROC[4,10]
-  // 
-  // To  be speed-up using caching lookup table
-  //
-  Int_t wireIndex = -1;  
+  /// Get Anode wire segment index IROC --> 4 segments in [0,3], 7 segments OROC[4,10]
+  ///
+  /// To  be speed-up using caching lookup table
+
+  Int_t wireIndex = -1;
   // check if the given set of sector and row is OK
   if ( (sector<0 || sector>=72) || (row<0 || row>95) || (sector<36 && row>64) ){
     AliError("No matching anode wire segment for this set of sector-row \n");
     return wireIndex;
-  }  
+  }
   // find the wire index for given sector-row
-  if ( sector<36 ){                               // IROC anode wire segments 
+  if ( sector<36 ){                               // IROC anode wire segments
     if (row<16) wireIndex=0;
     else if (row>=16 && row<32) wireIndex=1;
     else if (row>=32 && row<48) wireIndex=2;
-    else wireIndex=3;    
-  } else {                                        // OROC anode wire segments    
+    else wireIndex=3;
+  } else {                                        // OROC anode wire segments
     if (row<16) wireIndex=4;
     else if ( row>=16 && row<32) wireIndex=5;
     else if ( row>=32 && row<48) wireIndex=6;
@@ -859,28 +858,27 @@ Int_t AliTPCParam::GetWireSegment(Int_t sector, Int_t row) const
     else if ( row>=64 && row<75) wireIndex=8;
     else if ( row>=75 && row<85) wireIndex=9;
     else wireIndex=10;
-  }    
-  return wireIndex;  
+  }
+  return wireIndex;
 }
 
 Int_t AliTPCParam::GetNPadsPerSegment(Int_t wireSegmentID) const
 {
-  //
-  // Get the number of pads in a given anode wire segment
-  //
-  // check if the given segment index is OK 
-  // To be done (if needed) - cache the lookup table
-  //
+  /// Get the number of pads in a given anode wire segment
+  ///
+  /// check if the given segment index is OK
+  /// To be done (if needed) - cache the lookup table
+
   if ( wireSegmentID<0 || wireSegmentID>10 ){
     AliError("Wrong anode wire segment index. it should be [0,10] \n");
     return -1;
   }
   // get sector type from wireSegmentID
-  Int_t sector = (wireSegmentID<4) ? 0 : 36; // ROC [0,35] --> IROC, ROC [36,71] --> OROC  
+  Int_t sector = (wireSegmentID<4) ? 0 : 36; // ROC [0,35] --> IROC, ROC [36,71] --> OROC
   // get the upper and lower row number for the given wireSegmentID
   Int_t segRowDown = 0;
   Int_t segRowUp   = 0;
-  
+
   if ( wireSegmentID == 0 || wireSegmentID == 4 ) {
     segRowDown = 0;
     segRowUp   = 16;
@@ -902,7 +900,7 @@ Int_t AliTPCParam::GetNPadsPerSegment(Int_t wireSegmentID) const
   } else {
     segRowDown = 85;
     segRowUp   = 95;
-  }  
+  }
   // count the number of pads on the given segment
   AliTPCROC *r=AliTPCROC::Instance();
   Int_t nPads=0;
@@ -925,30 +923,31 @@ Float_t AliTPCParam::GetYOuter(Int_t irow) const
 
 Int_t AliTPCParam::GetSectorIndex(Float_t angle, Int_t row, Float_t z) const
 {
-  // returns the sector index
-  // takes as input the angle, index of the pad row and z position
+  /// returns the sector index
+  /// takes as input the angle, index of the pad row and z position
+
   if(row<0) return -1;
 
   if (angle > 2.*TMath::Pi()) angle -= 2.*TMath::Pi();
   if (angle < 0.            ) angle += 2.*TMath::Pi();
- 
+
   Int_t sector;
   if(row<fNRowLow) {
     sector=Int_t(TMath::Nint((angle-fInnerAngleShift)/fInnerAngle));
     if (z<0) sector += (fNInnerSector>>1);
   }
   else {
-    sector=Int_t(TMath::Nint((angle-fOuterAngleShift)/fOuterAngle))+fNInnerSector;      
+    sector=Int_t(TMath::Nint((angle-fOuterAngleShift)/fOuterAngle))+fNInnerSector;
     if (z<0) sector += (fNOuterSector>>1);
-  }    
-  
+  }
+
   return sector;
 }
 
 Float_t AliTPCParam::GetChamberCenter(Int_t isec, Float_t * center) const
 {
-  // returns the default radial position
-  // of the readout chambers
+  /// returns the default radial position
+  /// of the readout chambers
 
   const Float_t kROCcenterIn = 110.2;
   const Float_t kROCcenterOut = 188.45;
@@ -956,27 +955,26 @@ Float_t AliTPCParam::GetChamberCenter(Int_t isec, Float_t * center) const
   if (isec<fNInnerSector){
     if (center){
       center[0] = kROCcenterIn;
-      center[1] = 0; 
-      center[2] = -5.51-0.08; 
+      center[1] = 0;
+      center[2] = -5.51-0.08;
     }
     return kROCcenterIn;
   }
   else{
     if (center){
       center[0] = kROCcenterOut;
-      center[1] = 0; 
-      center[2] = -5.61-0.08; 
+      center[1] = 0;
+      center[2] = -5.61-0.08;
     }
     return kROCcenterOut;
   }
 }
 
 void AliTPCParam::SetNominalGainSlopes(){
-  //
-  // Setting the nominal TPC gain slopes 
-  // Nominal values were obtained as a mena values foe 2010,2011, and 2012 data
-  // Differntial values can be provided per year
-  //
+  /// Setting the nominal TPC gain slopes
+  /// Nominal values were obtained as a mena values foe 2010,2011, and 2012 data
+  /// Differntial values can be provided per year
+
   Float_t sector[72]={0};
   Float_t gainHV[72]={0};
   Float_t gainPT[72]={0};
@@ -994,10 +992,10 @@ void AliTPCParam::SetNominalGainSlopes(){
 
 
 TVectorD * AliTPCParam::GetBetheBlochParamNa49(){
-  //
-  //  Parameters of the BB for the Aleph parametrization AliMathBase::BetheBlochAleph
-  //  Na49 parameters were used as first set of parameters for ALICE simulation
-  //  (see TPC TDR for details)
+  /// Parameters of the BB for the Aleph parametrization AliMathBase::BetheBlochAleph
+  /// Na49 parameters were used as first set of parameters for ALICE simulation
+  /// (see TPC TDR for details)
+
   TVectorD v(5);
   v(0)=0.76176e-1;
   v(1)=10.632;
@@ -1008,13 +1006,11 @@ TVectorD * AliTPCParam::GetBetheBlochParamNa49(){
 }
 
 TVectorD * AliTPCParam::GetBetheBlochParamAlice(){
-  //
-  //
-  //  Parameters of the BB for the Aleph parametrization AliMathBase::BetheBlochAleph
-  //  Na49 parameters were used as first set of parameters for ALICE simulation
-  //  Second set was obtained from ALICE 2009-2013 data taking 
-  //  (see TPC TDR for details)
-  //  
+  /// Parameters of the BB for the Aleph parametrization AliMathBase::BetheBlochAleph
+  /// Na49 parameters were used as first set of parameters for ALICE simulation
+  /// Second set was obtained from ALICE 2009-2013 data taking
+  /// (see TPC TDR for details)
+
   TVectorD v(5);
   v[0] = 0.0851148;
   v[1] = 9.25771;
@@ -1025,14 +1021,13 @@ TVectorD * AliTPCParam::GetBetheBlochParamAlice(){
 }
 
 TVectorD * AliTPCParam::GetBetheBlochParamAliceMC(){
-  //
-  //
-  //  Parameters of the BB for the Aleph parametrization AliMathBase::BetheBlochAleph
-  //  dNdx parameterization
+  /// Parameters of the BB for the Aleph parametrization AliMathBase::BetheBlochAleph
+  /// dNdx parameterization
+
   TVectorD v(5);
   v[0] =0.0820172 ;
   v[1] =9.94795 ;
-  v[2] =8.97292e-05; 
+  v[2] =8.97292e-05;
   v[3] =2.05873 ;
   v[4] =1.65272 ;
 
@@ -1041,26 +1036,25 @@ TVectorD * AliTPCParam::GetBetheBlochParamAliceMC(){
 
 
 Double_t  AliTPCParam::BetheBlochAleph(Double_t bg, Int_t type){
-  //
-  //  GetBetheBloch retur values for the parametrs regieter at poition type 
-  //  Used for visualization and comparison purposes
+  /// GetBetheBloch retur values for the parametrs regieter at poition type
+  /// Used for visualization and comparison purposes
+
   TVectorD * paramBB =0;
   if (type==0) {
     AliTPCParam* param = AliTPCcalibDB::Instance()->GetParameters();
     if (param) paramBB=param->GetBetheBlochParameters();
-  } 
+  }
   if (type==1){
     paramBB = (TVectorD*)fBBParam->At(type);
   }
   if (!paramBB) return 0;
   //
-  return AliMathBase::BetheBlochAleph(bg,(*paramBB)(0),(*paramBB)(1),(*paramBB)(2),(*paramBB)(3),(*paramBB)(4)); 
+  return AliMathBase::BetheBlochAleph(bg,(*paramBB)(0),(*paramBB)(1),(*paramBB)(2),(*paramBB)(3),(*paramBB)(4));
 }
 
 
 void AliTPCParam::RegisterBBParam(TVectorD* param, Int_t position){
-  //
-  // 
-  //
+  ///
+
   fBBParam->AddAt(param,position);
 }
diff --git a/TPC/TPCbase/AliTPCParam.h b/TPC/TPCbase/AliTPCParam.h
index d4872c4e7b7..7bbc6d9b6a3 100644
--- a/TPC/TPCbase/AliTPCParam.h
+++ b/TPC/TPCbase/AliTPCParam.h
@@ -3,11 +3,9 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-/* $Id$ */
 
-////////////////////////////////////////////////
-//  Manager class for TPC parameters          //
-////////////////////////////////////////////////
+/// \class AliTPCParam
+/// \brief Manager class for TPC parameters
 
 #include "AliDetectorParam.h"
 #include "TMath.h"
@@ -20,23 +18,23 @@ class TGraphErrors;
 class AliTPCParam : public AliDetectorParam {
   //////////////////////////////////////////////////////
   //////////////////////////////////////////////////////
-  //ALITPCParam object to be possible change 
-  //geometry and some other parameters of TPC   
-  //used by AliTPC and AliTPCSector 
- 
+  //ALITPCParam object to be possible change
+  //geometry and some other parameters of TPC
+  //used by AliTPC and AliTPCSector
+
 public:
-  AliTPCParam(); 
+  AliTPCParam();
   virtual ~AliTPCParam();
-  TGeoHMatrix *  Tracking2LocalMatrix(const TGeoHMatrix * geoMatrix, Int_t sector) const;  
+  TGeoHMatrix *  Tracking2LocalMatrix(const TGeoHMatrix * geoMatrix, Int_t sector) const;
   virtual Bool_t  Transform(Float_t *xyz, Int_t *index, Int_t* oindex);
-  //transformation from input coodination system to output coordination system  
+  //transformation from input coodination system to output coordination system
   Int_t  Transform0to1(Float_t *xyz, Int_t *index) const;
-  //trasforamtion from global to global - adjust index[0] sector 
+  //trasforamtion from global to global - adjust index[0] sector
   //return value is equal to sector corresponding to global position
   void Transform1to2Ideal(Float_t *xyz, Int_t *index) const;
-  //transformation to rotated coordinata - ideal frame 
+  //transformation to rotated coordinata - ideal frame
   void Transform1to2(Float_t *xyz, Int_t *index) const;
-  //transformation to rotated coordinata   
+  //transformation to rotated coordinata
   void Transform2to1(Float_t *xyz, Int_t *index) const;
   //transformation from rotated coordinata to global coordinata
   void Transform2to2(Float_t *xyz, Int_t *index, Int_t *oindex) const;
@@ -46,27 +44,27 @@ public:
   //round x position to nearest wire
   Int_t   Transform2to3(Float_t *xyz, Int_t *index) const;
   //calulate coresponding index[2] -pad row for straight rows
-  //does not change xyz[] 
-  //return pad - row 
+  //does not change xyz[]
+  //return pad - row
   void   Transform3to4(Float_t *xyz, Int_t *index) const;
   //valid only for straight rows straight rows
   //calculate xyz[0] position relative to given index
-  //return pad - row 
+  //return pad - row
   void   Transform4to3(Float_t *xyz, Int_t *index) const;
   //valid only for straight rows straight rows
   //transform  xyz[0] position relative to given index
   void   Transform2to5( Float_t *xyz, Int_t *index) const;
   //transform [x,y,z] to [r,rphi,z]
   void   Transform5to2(Float_t *xyz, Int_t *index) const;
-  //transform [r,rphi,z] coordinata to [x,y,z] 
+  //transform [r,rphi,z] coordinata to [x,y,z]
   void  Transform4to8(Float_t *xyz, Int_t *index) const;
   //transform xyz coordinata to 'digit' coordinata
   void  Transform8to4(Float_t *xyz, Int_t *index) const;
-  //transform  'digit' coordinata to xyz coordinata   
+  //transform  'digit' coordinata to xyz coordinata
   void  Transform6to8(Float_t *xyz, Int_t *index) const;
   //transform dr,f coordinata to 'digit' coordinata
   void  Transform8to6(Float_t *xyz, Int_t *index) const;
-  //transform 'digit' coordinata to dr,f coordinata 
+  //transform 'digit' coordinata to dr,f coordinata
 
   virtual Int_t  Transform2toPadRow(Float_t */*xyz*/, Int_t */*index*/) const{return 0;}
   //transform rotated to
@@ -74,7 +72,7 @@ public:
   virtual  Int_t GetPadRow(Float_t *xyz, Int_t *index) const ;
   //return pad row of point xyz - xyz is given in coordinate system -(given by index)
   //output system is 3 for straight row and 7 for cylindrical row
-  virtual void XYZtoCRXYZ(Float_t */*xyz*/, 
+  virtual void XYZtoCRXYZ(Float_t */*xyz*/,
 			  Int_t &/*sector*/, Int_t &/*padrow*/, Int_t /*option*/) const {;}
   //transform global position to the position relative to the sector padrow
   //if option=0  X calculate absolute            calculate sector
@@ -83,38 +81,38 @@ public:
   //if option=3  X           relative            use input sector
 
   virtual void CRXYZtoXYZ(Float_t */*xyz*/,
-			  const Int_t &/*sector*/, const Int_t & /*padrow*/, Int_t /*option*/) const {;}  
+			  const Int_t &/*sector*/, const Int_t & /*padrow*/, Int_t /*option*/) const {;}
   //transform relative position  to the gloabal position
 
-  virtual void CRTimePadtoYZ(Float_t &/*y*/, Float_t &/*z*/, 
+  virtual void CRTimePadtoYZ(Float_t &/*y*/, Float_t &/*z*/,
 			     const Float_t &/*time*/, const Float_t &/*pad*/,
 			     Int_t /*sector*/, Int_t /*padrow*/ ){;}
-  //transform position in digit  units (time slices and pads)  to "normal" 
-  //units (cm)   
-  virtual void CRYZtoTimePad(const Float_t &/*y*/, const Float_t &/*z*/, 
+  //transform position in digit  units (time slices and pads)  to "normal"
+  //units (cm)
+  virtual void CRYZtoTimePad(const Float_t &/*y*/, const Float_t &/*z*/,
 			     Float_t &/*time*/, Float_t &/*pad*/,
 			     Int_t /*sector*/, Int_t /*padrow*/){;}
-  //transform position in cm to position in digit unit 
+  //transform position in cm to position in digit unit
   virtual Int_t   CalcResponse(Float_t* /*x*/, Int_t * /*index*/, Int_t /*row*/){return 0;}
-  //calculate bin response as function of the input position -x and the weight 
-  //if row -pad row is equal -1 calculate response for each pad row 
+  //calculate bin response as function of the input position -x and the weight
+  //if row -pad row is equal -1 calculate response for each pad row
   //otherwise it calculate only in given pad row
   //return number of valid response bin
-  virtual void SetDefault();          //set defaut TPCparam 
-  virtual Bool_t Update();            //recalculate and check geometric parameters 
-  virtual Bool_t ReadGeoMatrices();   //read geo matrixes        
-  Bool_t GetStatus() const;         //get information about object consistency  
-  Int_t GetIndex(Int_t sector, Int_t row) const;  //give index of the given sector and pad row 
-  Int_t GetNSegmentsTotal() const {return fNtRows;} 
+  virtual void SetDefault();          //set defaut TPCparam
+  virtual Bool_t Update();            //recalculate and check geometric parameters
+  virtual Bool_t ReadGeoMatrices();   //read geo matrixes
+  Bool_t GetStatus() const;         //get information about object consistency
+  Int_t GetIndex(Int_t sector, Int_t row) const;  //give index of the given sector and pad row
+  Int_t GetNSegmentsTotal() const {return fNtRows;}
   Double_t GetLowMaxY(Int_t irow) const {return irow*0.;}
   Double_t GetUpMaxY(Int_t irow) const {return irow*0;}
   //additional geometrical function - for Belikov
- 
+
   Bool_t   AdjustSectorRow(Int_t index, Int_t & sector, Int_t &row) const; //return sector and padrow
   //for given index
 
   void  AdjustCosSin(Int_t isec, Float_t &cos, Float_t &sin) const;
-  //set cosinus and sinus of rotation angles for sector isec 
+  //set cosinus and sinus of rotation angles for sector isec
   Float_t GetAngle(Int_t isec) const;
   //  void GetChamberPos(Int_t isec, Float_t* xyz) const;
   //  void GetChamberRot(Int_t isec, Float_t* angles) const;
@@ -122,48 +120,48 @@ public:
   //set sector parameters
   //
   void  SetInnerRadiusLow(Float_t InnerRadiusLow )  { fInnerRadiusLow=InnerRadiusLow;}
-  void  SetOuterRadiusLow(Float_t OuterRadiusLow )  { fOuterRadiusLow=OuterRadiusLow;} 
-  void  SetInnerRadiusUp(Float_t InnerRadiusUp)  {  fInnerRadiusUp= InnerRadiusUp;} 
-  void  SetOuterRadiusUp(Float_t OuterRadiusUp) {  fOuterRadiusUp= OuterRadiusUp;}   
+  void  SetOuterRadiusLow(Float_t OuterRadiusLow )  { fOuterRadiusLow=OuterRadiusLow;}
+  void  SetInnerRadiusUp(Float_t InnerRadiusUp)  {  fInnerRadiusUp= InnerRadiusUp;}
+  void  SetOuterRadiusUp(Float_t OuterRadiusUp) {  fOuterRadiusUp= OuterRadiusUp;}
   void  SetSectorAngles(Float_t innerangle, Float_t innershift, Float_t outerangle,
 			Float_t outershift);
   void  SetInnerFrameSpace(Float_t frspace) {fInnerFrameSpace = frspace;}
   void  SetOuterFrameSpace(Float_t frspace) {fOuterFrameSpace = frspace;}
   void  SetInnerWireMount(Float_t fmount) {fInnerWireMount = fmount;}
   void  SetOuterWireMount(Float_t fmount) {fOuterWireMount = fmount;}
-  void  SetZLength(Float_t zlength) {fZLength = zlength;} 
+  void  SetZLength(Float_t zlength) {fZLength = zlength;}
   void  SetGeometryType(Int_t type) {fGeometryType = type;}
   //
   // pad rows geometry
   //
   void SetRowNLow( Int_t NRowLow){fNRowLow = NRowLow;}
-  void SetRowNUp1 (Int_t NRowUp1){fNRowUp1 = NRowUp1 ;} //upper sec short pads 
+  void SetRowNUp1 (Int_t NRowUp1){fNRowUp1 = NRowUp1 ;} //upper sec short pads
   void SetRowNUp2 (Int_t NRowUp2){fNRowUp2 = NRowUp2 ;} //upper sec long pads
-  void SetRowNUp (Int_t NRowUp){fNRowUp = NRowUp ;}  
+  void SetRowNUp (Int_t NRowUp){fNRowUp = NRowUp ;}
   //
   //set wire parameters
   //
   void  SetInnerNWires(Int_t nWires){  fNInnerWiresPerPad=nWires;}
   void  SetInnerDummyWire(Int_t dummy) {fInnerDummyWire  = dummy;}
-  void  SetInnerOffWire(Float_t offset) {fInnerOffWire =offset;}    
+  void  SetInnerOffWire(Float_t offset) {fInnerOffWire =offset;}
   void  SetOuter1NWires(Int_t nWires){  fNOuter1WiresPerPad=nWires;}
   void  SetOuter2NWire(Int_t nWires){  fNOuter2WiresPerPad=nWires;}
   void  SetOuterDummyWire(Int_t dummy) {fOuterDummyWire  = dummy;}
-  void  SetOuterOffWire(Float_t offset) {fOuterOffWire =offset;} 
+  void  SetOuterOffWire(Float_t offset) {fOuterOffWire =offset;}
   void  SetInnerWWPitch( Float_t wwPitch) {fInnerWWPitch = wwPitch;}
   void  SetRInnerFirstWire(Float_t firstWire){fRInnerFirstWire = firstWire;}
   void  SetRInnerLastWire(Float_t lastWire){fRInnerLastWire = lastWire;}
   void  SetOuterWWPitch(Float_t wwPitch){fOuterWWPitch = wwPitch;}
-  void  SetLastWireUp1(Float_t wireUp1){fLastWireUp1 = wireUp1;} 
+  void  SetLastWireUp1(Float_t wireUp1){fLastWireUp1 = wireUp1;}
   void  SetROuterFirstWire(Float_t firstWire){fROuterFirstWire = firstWire;}
-  void  SetROuterLastWire(Float_t lastWire){fROuterLastWire = lastWire;}   
+  void  SetROuterLastWire(Float_t lastWire){fROuterLastWire = lastWire;}
   //
   //set pad parameter
   //
   void  SetInnerPadPitchLength(Float_t PadPitchLength){  fInnerPadPitchLength=PadPitchLength;}
   void  SetInnerPadPitchWidth(Float_t PadPitchWidth){  fInnerPadPitchWidth = PadPitchWidth;}
   void  SetInnerPadLength(Float_t PadLength){  fInnerPadLength=PadLength;}
-  void  SetInnerPadWidth(Float_t PadWidth) {  fInnerPadWidth=PadWidth;} 
+  void  SetInnerPadWidth(Float_t PadWidth) {  fInnerPadWidth=PadWidth;}
   void  SetOuter1PadPitchLength(Float_t PadPitchLength){  fOuter1PadPitchLength=PadPitchLength;}
   void  SetOuter2PadPitchLength(Float_t PadPitchLength){  fOuter2PadPitchLength=PadPitchLength;}
   void  SetOuterPadPitchWidth(Float_t PadPitchWidth){  fOuterPadPitchWidth = PadPitchWidth;}
@@ -212,7 +210,7 @@ public:
   static TVectorD * GetBetheBlochParamAliceMC();
   static void RegisterBBParam(TVectorD* param, Int_t position);
   //
-  //set electronivc parameters  
+  //set electronivc parameters
   //
   void  SetPadCoupling(Float_t PadCoupling){  fPadCoupling=PadCoupling;}
   void  SetZeroSup(Int_t ZeroSup)    {  fZeroSup=ZeroSup;}
@@ -233,9 +231,9 @@ public:
   void  SetMaxFractionHVbad(Float_t frac )      { fMaxHVfractionBad=frac;       }
   void  SetVoltageDipScanPeriod(Float_t period) { fVoltageDipScanPeriod=period; }
   //
-  //set response  parameters  
+  //set response  parameters
   //
-  void  SetNResponseMax(Int_t max) { fNResponseMax = max;} 
+  void  SetNResponseMax(Int_t max) { fNResponseMax = max;}
   void  SetResponseThreshold(Int_t threshold) {fResponseThreshold = threshold;}
   //set L1 parameters
   void  SetGateDelay(Float_t delay) {fGateDelay = delay;}
@@ -245,9 +243,9 @@ public:
   //get sector parameters
   //
   Float_t  GetInnerRadiusLow() const {return fInnerRadiusLow;}
-  Float_t  GetInnerRadiusUp() const {return fInnerRadiusUp;} 
-  Float_t  GetOuterRadiusLow() const {return fOuterRadiusLow;} 
-  Float_t  GetOuterRadiusUp() const {return fOuterRadiusUp;} 
+  Float_t  GetInnerRadiusUp() const {return fInnerRadiusUp;}
+  Float_t  GetOuterRadiusLow() const {return fOuterRadiusLow;}
+  Float_t  GetOuterRadiusUp() const {return fOuterRadiusUp;}
   Float_t  GetInnerFrameSpace() const {return fInnerFrameSpace;}
   Float_t  GetOuterFrameSpace() const {return fOuterFrameSpace;}
   Float_t  GetInnerWireMount() const {return fInnerWireMount;}
@@ -255,7 +253,7 @@ public:
   Float_t  GetInnerAngle() const ;
   Float_t  GetInnerAngleShift() const ;
   Float_t  GetOuterAngle() const ;
-  Float_t  GetOuterAngleShift() const ; 
+  Float_t  GetOuterAngleShift() const ;
   Int_t    GetNInnerSector() const {return fNInnerSector;}
   Int_t    GetNOuterSector() const {return fNOuterSector;}
   Int_t    GetNSector() const {return fNSector;}
@@ -266,21 +264,21 @@ public:
   //get wires parameter
   //
   Int_t    GetInnerNWires() const {return fNInnerWiresPerPad;}
-  Float_t  GetInnerWWPitch() const {return fInnerWWPitch;}  
+  Float_t  GetInnerWWPitch() const {return fInnerWWPitch;}
   Int_t    GetInnerDummyWire() const {return fInnerDummyWire;}
   Float_t  GetInnerOffWire() const {return fInnerOffWire;}
   Float_t  GetRInnerFirstWire() const {return fRInnerFirstWire;}
   Float_t  GetRInnerLastWire() const {return fRInnerLastWire;}
   Int_t    GetOuter1NWires() const {return fNOuter1WiresPerPad;}
   Int_t    GetOuter2NWires() const {return fNOuter2WiresPerPad;}
-  Float_t  GetOuterWWPitch() const {return fOuterWWPitch;}  
+  Float_t  GetOuterWWPitch() const {return fOuterWWPitch;}
   Int_t    GetOuterDummyWire() const {return fOuterDummyWire;}
   Float_t  GetOuterOffWire() const {return fOuterOffWire;}
   Float_t  GetLastWireUp1()  const {return fLastWireUp1;}
   Float_t  GetROuterFirstWire() const {return fROuterFirstWire;}
-  Float_t  GetROuterLastWire() const {return fROuterLastWire;}  
+  Float_t  GetROuterLastWire() const {return fROuterLastWire;}
   Float_t  GetWWPitch(Int_t isector = 0) const  {
-    return ( (isector < fNInnerSector) ? fInnerWWPitch :fOuterWWPitch);} 
+    return ( (isector < fNInnerSector) ? fInnerWWPitch :fOuterWWPitch);}
   //
   //get pad  parameters
   //
@@ -289,21 +287,21 @@ public:
   Float_t  GetInnerPadLength() const {return fInnerPadLength;}
   Float_t  GetInnerPadWidth() const  {return fInnerPadWidth;}
   Float_t  GetOuter1PadPitchLength() const {return fOuter1PadPitchLength;}
-  Float_t  GetOuter2PadPitchLength() const {return fOuter2PadPitchLength;}  
+  Float_t  GetOuter2PadPitchLength() const {return fOuter2PadPitchLength;}
   Float_t  GetOuterPadPitchWidth() const {return fOuterPadPitchWidth;}
   Float_t  GetOuter1PadLength() const {return fOuter1PadLength;}
   Float_t  GetOuter2PadLength() const {return fOuter2PadLength;}
-  Float_t  GetOuterPadWidth()  const {return fOuterPadWidth;}  
+  Float_t  GetOuterPadWidth()  const {return fOuterPadWidth;}
   Bool_t   GetMWPCReadout() const {return fBMWPCReadout;}
   Int_t    GetNCrossRows() const {return fNCrossRows;}
   Float_t  GetPadPitchWidth(Int_t isector = 0) const  {
     return ( (isector < fNInnerSector) ? fInnerPadPitchWidth :fOuterPadPitchWidth);}
   Float_t  GetPadPitchLength(Int_t isector = 0, Int_t padrow=0)  const
-  { if (isector < fNInnerSector) return fInnerPadPitchLength; 
+  { if (isector < fNInnerSector) return fInnerPadPitchLength;
     else return ((padrow<fNRowUp1) ? fOuter1PadPitchLength:fOuter2PadPitchLength);}
   Int_t GetNRowLow() const;   //get the number of pad rows in low sector
   Int_t GetNRowUp() const;    //get the number of pad rows in up sector
-  Int_t GetNRowUp1() const;  // number of short rows in up sector  
+  Int_t GetNRowUp1() const;  // number of short rows in up sector
   Int_t GetNRowUp2() const;  // number of long rows in up sector
   Int_t GetNRow(Int_t isec) const {return  ((isec<fNInnerSector) ?  fNRowLow:fNRowUp);}
   Int_t GetNRowsTotal() const {return fNtRows;}  //get total nuber of rows
@@ -312,15 +310,15 @@ public:
   Float_t GetPadRowRadii(Int_t isec,Int_t irow) const {
     return ( (isec < fNInnerSector) ?GetPadRowRadiiLow(irow):GetPadRowRadiiUp(irow));}
     //retrun radii of the pad row irow in sector i
-  Int_t GetNPadsLow(Int_t irow) const;    //get the number of pads in row irow 
+  Int_t GetNPadsLow(Int_t irow) const;    //get the number of pads in row irow
   Int_t GetNPadsUp(Int_t irow) const;     //get the number of pads in row irow
   Int_t GetNPads(Int_t isector,Int_t irow) const{
-     return ( (isector < fNInnerSector) ?GetNPadsLow(irow) : GetNPadsUp(irow));} 
+     return ( (isector < fNInnerSector) ?GetNPadsLow(irow) : GetNPadsUp(irow));}
   Int_t GetWireSegment(Int_t sector, Int_t row) const ;    // get Anode wire segment index IROC --> [0,4], OROC[0,7]
   Int_t GetNPadsPerSegment(Int_t segmentID) const;         // get number of pads for a given Anode wire segment
 
   Float_t GetYInner(Int_t irow) const; // wire length in low sec row
-  Float_t GetYOuter(Int_t irow) const; // wire length in up sec row  
+  Float_t GetYOuter(Int_t irow) const; // wire length in up sec row
   Int_t GetSectorIndex(Float_t angle, Int_t row, Float_t z) const; // get sector index
   Float_t GetChamberCenter(Int_t isec, Float_t * center = 0) const; // get readout chamber positions
   TGeoHMatrix *GetTrackingMatrix(Int_t isec) const {
@@ -331,7 +329,7 @@ public:
     return fGlobalMatrix[isec];}
   Bool_t   IsGeoRead(){ return fGlobalMatrix!=0;}
   //
-  //get GAS parameters 
+  //get GAS parameters
   //
   Float_t  GetDiffT() const {return fDiffT;}
   Float_t  GetDiffL() const {return fDiffL;}
@@ -339,7 +337,7 @@ public:
   Float_t  GetDriftV() const {return fDriftV;}
   Float_t  GetOmegaTau() const {return fOmegaTau;}
   Float_t  GetAttCoef() const {return fAttCoef;}
-  Float_t  GetOxyCont() const {return fOxyCont;} 
+  Float_t  GetOxyCont() const {return fOxyCont;}
   TGraphErrors * GetGainSlopesHV() const { return fGainSlopesHV;}
   TGraphErrors * GetGainSlopesPT() const { return fGainSlopesPT;}
   Float_t* GetComposition() {return fComposition;}
@@ -349,8 +347,8 @@ public:
   Float_t  GetWmean()const {return fWmean;}
   Float_t  GetExp()const {return fExp;}
   Float_t  GetEend()const {return fEend;}
-  TVectorD* GetBetheBlochParameters(){return fBetheBloch;} 
-  TVectorD* GetBetheBlochParametersMC(){return fBetheBlochMC;} 
+  TVectorD* GetBetheBlochParameters(){return fBetheBloch;}
+  TVectorD* GetBetheBlochParametersMC(){return fBetheBlochMC;}
   static Double_t BetheBlochAleph(Double_t bb, Int_t type=0);
   //
   //get Electronic parameters
@@ -363,7 +361,7 @@ public:
   Float_t  GetTSample() const {return fTSample;}
   Float_t  GetZWidth() const {return fZWidth;}
   Float_t  GetTFWHM() const {return fTSigma*2.35;}
-  Float_t  GetZSigma() const {return fTSigma*fDriftV;}  
+  Float_t  GetZSigma() const {return fTSigma*fDriftV;}
   virtual  Float_t  GetZOffset() const {return 3*fTSigma*fDriftV;}
   Int_t    GetMaxTBin() const {return fMaxTBin;}
   Int_t    GetADCSat() const {return fADCSat;}
@@ -378,12 +376,12 @@ public:
   Float_t  GetMaxDipVoltage()          const { return fMaxDipVoltage;            }
   Float_t  GetMaxFractionHVbad()       const { return fMaxHVfractionBad;         }
   Float_t  GetVoltageDipScanPeriod()   const { return fVoltageDipScanPeriod;     }
-  
+
   //
   // get response data
-  //  
-  Int_t * GetResBin(Int_t i);  
-  //return response bin i  - bin given by  padrow [0] pad[1] timebin[2] 
+  //
+  Int_t * GetResBin(Int_t i);
+  //return response bin i  - bin given by  padrow [0] pad[1] timebin[2]
   Float_t & GetResWeight(Int_t i);
   //return  weight of response bin i
 
@@ -394,172 +392,177 @@ public:
   Float_t  GetNTBinsL1() const {return fNTBinsL1;}
 protected :
 
-  Bool_t fbStatus;  //indicates consistency of the data
+  Bool_t fbStatus;  ///< indicates consistency of the data
   //---------------------------------------------------------------------
   //   ALICE TPC sector geometry
-  //--------------------------------------------------------------------  
-  Float_t fInnerRadiusLow;    // lower radius of inner sector-IP
-  Float_t fInnerRadiusUp;     // upper radius of inner  sector-IP
-  Float_t fOuterRadiusUp;     // upper radius of outer  sector-IP
-  Float_t fOuterRadiusLow;    // lower radius of outer sector-IP
-  Float_t fInnerAngle;        //opening angle of Inner sector
-  Float_t fInnerAngleShift;   //shift of first inner sector center to the 0
-  Float_t fOuterAngle;        //opening angle of outer sector
-  Float_t fOuterAngleShift;   //shift of first sector center to the 0  
-  Float_t fInnerFrameSpace;   //space for inner frame in the phi direction 
-  Float_t fOuterFrameSpace;   //space for outer frame in the phi direction 
-  Float_t fInnerWireMount;    //space for wire mount, inner sector
-  Float_t fOuterWireMount;    //space for wire mount, outer sector
-  Int_t   fNInnerSector;      //number of inner sectors             -calculated
-  Int_t   fNOuterSector;      //number of outer sectors             -calculated
-  Int_t   fNSector;           // total number of sectors            -calculated
-  Float_t fZLength;           //length of the drift region of the TPC
-  Float_t *fRotAngle;         //[fNSector]  sin and cos of rotation angles for 
-                              //  diferent sectors -calculated
-  Int_t   fGeometryType;      //type of geometry -0 straight rows
-  //  Float_t *fChamberPos;       //[fNSector] displacements of the readout chambers 
+  //--------------------------------------------------------------------
+  Float_t fInnerRadiusLow;    ///< lower radius of inner sector-IP
+  Float_t fInnerRadiusUp;     ///< upper radius of inner  sector-IP
+  Float_t fOuterRadiusUp;     ///< upper radius of outer  sector-IP
+  Float_t fOuterRadiusLow;    ///< lower radius of outer sector-IP
+  Float_t fInnerAngle;        ///< opening angle of Inner sector
+  Float_t fInnerAngleShift;   ///< shift of first inner sector center to the 0
+  Float_t fOuterAngle;        ///< opening angle of outer sector
+  Float_t fOuterAngleShift;   ///< shift of first sector center to the 0
+  Float_t fInnerFrameSpace;   ///< space for inner frame in the phi direction
+  Float_t fOuterFrameSpace;   ///< space for outer frame in the phi direction
+  Float_t fInnerWireMount;    ///< space for wire mount, inner sector
+  Float_t fOuterWireMount;    ///< space for wire mount, outer sector
+  Int_t   fNInnerSector;      ///< number of inner sectors             -calculated
+  Int_t   fNOuterSector;      ///< number of outer sectors             -calculated
+  Int_t   fNSector;           ///< total number of sectors            -calculated
+  Float_t fZLength;           ///< length of the drift region of the TPC
+  /// sin and cos of rotation angles for different sectors - calculated
+  Float_t *fRotAngle;         //[fNSector]
+  Int_t   fGeometryType;      ///< type of geometry -0 straight rows
+  //  Float_t *fChamberPos;       //[fNSector] displacements of the readout chambers
                               //with respect to the 'idead' geometry
                               //in local corrdinate system
-  //  Float_t *fChamberRot;       //[fNSector] rotation angles of the readout chambers 
+  //  Float_t *fChamberRot;       //[fNSector] rotation angles of the readout chambers
                               //with respect to the 'idead' geometry
                               //in local corrdinate system
-  TGeoHMatrix **fTrackingMatrix;   //![fNSector] transformation matrices of the tracking
-                              //coordinate system
-  TGeoHMatrix **fClusterMatrix;    //![fNSector] transformation matrices of the cluster
-                              //coordinate system
-  TGeoHMatrix **fGlobalMatrix;    //![fNSector] fTrackingMatrix * fClusterMatrix
+  /// transformation matrices of the tracking coordinate system
+  TGeoHMatrix **fTrackingMatrix;   //![fNSector]
+  /// transformation matrices of the cluster coordinate system
+  TGeoHMatrix **fClusterMatrix;    //![fNSector]
+  /// fTrackingMatrix * fClusterMatrix
+  TGeoHMatrix **fGlobalMatrix;    //![fNSector]
 
   //1-cylindrical
   //---------------------------------------------------------------------
-  //   ALICE TPC wires  geometry - for GEM we can consider that it is gating  
+  //   ALICE TPC wires  geometry - for GEM we can consider that it is gating
   //--------------------------------------------------------------------
-  Int_t   fNInnerWiresPerPad; //Number of wires per pad
-  Float_t fInnerWWPitch;      //pitch between wires  in inner sector     - calculated
-  Int_t   fInnerDummyWire;    //number of wires without pad readout
-  Float_t fInnerOffWire;      //oofset of first wire to the begining of the sector
-  Float_t fRInnerFirstWire;   //position of the first wire                -calculated
-  Float_t fRInnerLastWire;    //position of the last wire                 -calculated
-  Float_t fLastWireUp1;     //position of the last wire in outer1 sector
-  Int_t   fNOuter1WiresPerPad; //Number of wires per pad
-  Int_t   fNOuter2WiresPerPad; // Number of wires per pad
-  Float_t fOuterWWPitch;      //pitch between wires in outer sector      -calculated
-  Int_t   fOuterDummyWire;    //number of wires without pad readout
-  Float_t fOuterOffWire;      //oofset of first wire to the begining of the sector
-  Float_t fROuterFirstWire;   //position of the first wire                -calulated
-  Float_t fROuterLastWire;    //position of the last wire                 -calculated 
+  Int_t   fNInnerWiresPerPad; ///< Number of wires per pad
+  Float_t fInnerWWPitch;      ///< pitch between wires  in inner sector     - calculated
+  Int_t   fInnerDummyWire;    ///< number of wires without pad readout
+  Float_t fInnerOffWire;      ///< oofset of first wire to the begining of the sector
+  Float_t fRInnerFirstWire;   ///< position of the first wire                -calculated
+  Float_t fRInnerLastWire;    ///< position of the last wire                 -calculated
+  Float_t fLastWireUp1;     ///< position of the last wire in outer1 sector
+  Int_t   fNOuter1WiresPerPad; ///< Number of wires per pad
+  Int_t   fNOuter2WiresPerPad; ///< Number of wires per pad
+  Float_t fOuterWWPitch;      ///< pitch between wires in outer sector      -calculated
+  Int_t   fOuterDummyWire;    ///< number of wires without pad readout
+  Float_t fOuterOffWire;      ///< oofset of first wire to the begining of the sector
+  Float_t fROuterFirstWire;   ///< position of the first wire                -calulated
+  Float_t fROuterLastWire;    ///< position of the last wire                 -calculated
   //---------------------------------------------------------------------
   //   ALICE TPC pad parameters
   //--------------------------------------------------------------------
-  Float_t   fInnerPadPitchLength;    //Inner pad pitch length
-  Float_t   fInnerPadPitchWidth;     //Inner pad pitch width
-  Float_t   fInnerPadLength;         //Inner pad  length
-  Float_t   fInnerPadWidth;          //Inner pad  width
-  Float_t   fOuter1PadPitchLength;    //Outer pad pitch length
-  Float_t   fOuter2PadPitchLength;    //Outer pad pitch length
-  Float_t   fOuterPadPitchWidth;     //Outer pad pitch width
-  Float_t   fOuter1PadLength;         //Outer pad  length
-  Float_t   fOuter2PadLength;         //Outer pad length
-  Float_t   fOuterPadWidth;          //Outer pad  width
-  Bool_t    fBMWPCReadout;           //indicate wire readout - kTRUE or GEM readout -kFALSE
-  Int_t     fNCrossRows;             //number of rows to crostalk calculation
-      
-  Int_t fNRowLow;           //number of pad rows per low sector        -set
-  Int_t fNRowUp1;            //number of short pad rows per sector up  -set
-  Int_t fNRowUp2;            //number of long pad rows per sector up   -set
-  Int_t fNRowUp;            //number of pad rows per sector up     -calculated
-  Int_t fNtRows;            //total number of rows in TPC          -calculated
-  Float_t  fPadRowLow[600]; //Lower sector, pad row radii          -calculated
-  Float_t  fPadRowUp[600];  //Upper sector, pad row radii          -calculated 
-  Int_t    fNPadsLow[600];  //Lower sector, number of pads per row -calculated
-  Int_t    fNPadsUp[600];   //Upper sector, number of pads per row -calculated
-  Float_t  fYInner[600];     //Inner sector, wire-length
-  Float_t  fYOuter[600];     //Outer sector, wire-length   
+  Float_t   fInnerPadPitchLength;    ///< Inner pad pitch length
+  Float_t   fInnerPadPitchWidth;     ///< Inner pad pitch width
+  Float_t   fInnerPadLength;         ///< Inner pad  length
+  Float_t   fInnerPadWidth;          ///< Inner pad  width
+  Float_t   fOuter1PadPitchLength;    ///< Outer pad pitch length
+  Float_t   fOuter2PadPitchLength;    ///< Outer pad pitch length
+  Float_t   fOuterPadPitchWidth;     ///< Outer pad pitch width
+  Float_t   fOuter1PadLength;         ///< Outer pad  length
+  Float_t   fOuter2PadLength;         ///< Outer pad length
+  Float_t   fOuterPadWidth;          ///< Outer pad  width
+  Bool_t    fBMWPCReadout;           ///< indicate wire readout - kTRUE or GEM readout -kFALSE
+  Int_t     fNCrossRows;             ///< number of rows to crostalk calculation
+
+  Int_t fNRowLow;           ///< number of pad rows per low sector        -set
+  Int_t fNRowUp1;            ///< number of short pad rows per sector up  -set
+  Int_t fNRowUp2;            ///< number of long pad rows per sector up   -set
+  Int_t fNRowUp;            ///< number of pad rows per sector up     -calculated
+  Int_t fNtRows;            ///< total number of rows in TPC          -calculated
+  Float_t  fPadRowLow[600]; ///< Lower sector, pad row radii          -calculated
+  Float_t  fPadRowUp[600];  ///< Upper sector, pad row radii          -calculated
+  Int_t    fNPadsLow[600];  ///< Lower sector, number of pads per row -calculated
+  Int_t    fNPadsUp[600];   ///< Upper sector, number of pads per row -calculated
+  Float_t  fYInner[600];     ///< Inner sector, wire-length
+  Float_t  fYOuter[600];     ///< Outer sector, wire-length
   //---------------------------------------------------------------------
   //   ALICE TPC Gas Parameters
   //--------------------------------------------------------------------
-  Float_t  fDiffT;          //tangencial diffusion constant
-  Float_t  fDiffL;          //longutudinal diffusion constant
-  Float_t  fGasGain;        //gas gain constant
-  Float_t  fDriftV;         //drift velocity constant
-  Float_t  fOmegaTau;       //omega tau ExB coeficient
-  Float_t  fAttCoef;        //attachment coefitients
-  Float_t  fOxyCont;        //oxygen content
-  Float_t  fFpot;            // first ionisation potential
-  Float_t  fNprim;           // number of primary electrons/cm
-  Float_t  fNtot;            //total number of electrons/c (MIP)
-  Float_t  fWmean;           // mean energy for electron/ion pair
-  Float_t  fExp;             // de = f(E) - energy loss parametrization
-  Float_t  fEend;            // upper cutoff for de generation
-  TVectorD*  fBetheBloch;   // Bethe-Bloch parametrization
-  TVectorD*  fBetheBlochMC;   // Bethe-Bloch parametrization
+  Float_t  fDiffT;          ///< tangencial diffusion constant
+  Float_t  fDiffL;          ///< longutudinal diffusion constant
+  Float_t  fGasGain;        ///< gas gain constant
+  Float_t  fDriftV;         ///< drift velocity constant
+  Float_t  fOmegaTau;       ///< omega tau ExB coeficient
+  Float_t  fAttCoef;        ///< attachment coefitients
+  Float_t  fOxyCont;        ///< oxygen content
+  Float_t  fFpot;            ///< first ionisation potential
+  Float_t  fNprim;           ///< number of primary electrons/cm
+  Float_t  fNtot;            ///< total number of electrons/c (MIP)
+  Float_t  fWmean;           ///< mean energy for electron/ion pair
+  Float_t  fExp;             ///< de = f(E) - energy loss parametrization
+  Float_t  fEend;            ///< upper cutoff for de generation
+  TVectorD*  fBetheBloch;   ///< Bethe-Bloch parametrization
+  TVectorD*  fBetheBlochMC;   ///< Bethe-Bloch parametrization
   // gas mixture composition
-  Float_t  fComposition[6]; 
-  TGraphErrors * fGainSlopesHV;   // graph with the gain slope as function of HV - per chamber
-  TGraphErrors * fGainSlopesPT;   // graph with the gain slope as function of P/T - per chamber
+  Float_t  fComposition[6];
+  TGraphErrors * fGainSlopesHV;   ///< graph with the gain slope as function of HV - per chamber
+  TGraphErrors * fGainSlopesPT;   ///< graph with the gain slope as function of P/T - per chamber
   //---------------------------------------------------------------------
   //   ALICE TPC  Electronics Parameters
   //--------------------------------------------------------------------
-  Float_t fPadCoupling;     //coupling factor ration of  anode signal 
-                            //and total pads signal  
-  Int_t fZeroSup;           //zero suppresion constant
-  Float_t fNoise;           //noise sigma constant
-  Float_t fChipGain;        //preamp shaper constant
-  Float_t fChipNorm;         //preamp shaper normalisation 
-  Float_t fTSample;         //sampling time
-  Float_t fZWidth;          //derived value calculated using TSample and driftw  -computed
-  Float_t fTSigma;          //width of the Preamp/Shaper function
-  Int_t   fMaxTBin;         //maximum time bin number
-  Int_t   fADCSat;          //saturation value of ADC (10 bits)
-  Float_t fADCDynRange;     //input dynamic range (mV)
-  Float_t fTotalNormFac;    //full normalisation factor - calculated
-  Float_t fNoiseNormFac;    //normalisation factor to transform noise in electron to ADC channel
+  Float_t fPadCoupling;     ///< coupling factor ration of  anode signal
+                            //and total pads signal
+  Int_t fZeroSup;           ///< zero suppresion constant
+  Float_t fNoise;           ///< noise sigma constant
+  Float_t fChipGain;        ///< preamp shaper constant
+  Float_t fChipNorm;         ///< preamp shaper normalisation
+  Float_t fTSample;         ///< sampling time
+  Float_t fZWidth;          ///< derived value calculated using TSample and driftw  -computed
+  Float_t fTSigma;          ///< width of the Preamp/Shaper function
+  Int_t   fMaxTBin;         ///< maximum time bin number
+  Int_t   fADCSat;          ///< saturation value of ADC (10 bits)
+  Float_t fADCDynRange;     ///< input dynamic range (mV)
+  Float_t fTotalNormFac;    ///< full normalisation factor - calculated
+  Float_t fNoiseNormFac;    ///< normalisation factor to transform noise in electron to ADC channel
   //---------------------------------------------------------------------
   // High voltage parameters
   //---------------------------------------------------------------------
-  Float_t fNominalVoltage[72];  //nominal voltage in [V] per chamber
-  Float_t fMaxVoltageDeviation; // maximum voltage deviation from nominal voltage before a chamber is masked
-  Float_t fMaxDipVoltage;       // maximum voltage deviation from median before a dip event is marked
-  Float_t fMaxHVfractionBad;    // maximum fraction of bad HV entries (deviation from Median) before a chamber is marked bad
-  Float_t fVoltageDipScanPeriod; // scanning period to detect a high volrage dip: event time stamp +- fVoltageDipScanPeriod [sec]
-  
+  Float_t fNominalVoltage[72];  ///< nominal voltage in [V] per chamber
+  Float_t fMaxVoltageDeviation; ///< maximum voltage deviation from nominal voltage before a chamber is masked
+  Float_t fMaxDipVoltage;       ///< maximum voltage deviation from median before a dip event is marked
+  Float_t fMaxHVfractionBad;    ///< maximum fraction of bad HV entries (deviation from Median) before a chamber is marked bad
+  Float_t fVoltageDipScanPeriod; ///< scanning period to detect a high volrage dip: event time stamp +- fVoltageDipScanPeriod [sec]
+
   //---------------------------------------------------------------------
-  // ALICE TPC response data 
+  // ALICE TPC response data
   //---------------------------------------------------------------------
-  Int_t   fNResponseMax;   //maximal dimension of response        
-  Float_t fResponseThreshold; //threshold for accepted response   
-  Int_t   fCurrentMax;     //!current maximal dimension            -calulated 
-  Int_t   *fResponseBin;    //!array with bins                     -calulated
-  Float_t *fResponseWeight; //!array with response                 -calulated
+  Int_t   fNResponseMax;   ///< maximal dimension of response
+  Float_t fResponseThreshold; ///< threshold for accepted response
+  Int_t   fCurrentMax;     //!< current maximal dimension            -calulated
+  Int_t   *fResponseBin;    //!< array with bins                     -calulated
+  Float_t *fResponseWeight; //!< array with response                 -calulated
 
   //---------------------------------------------------------------------
   //   ALICE TPC L1 Parameters
   //--------------------------------------------------------------------
-  Float_t fGateDelay;       //Delay of L1 arrival for the TPC gate signal
-  Float_t fL1Delay;         //Delay of L1 arrival for the TPC readout 
-  UShort_t fNTBinsBeforeL1; //Number of time bins before L1 arrival which are being read out 
-  Float_t fNTBinsL1;        //Overall L1 delay in time bins
+  Float_t fGateDelay;       ///< Delay of L1 arrival for the TPC gate signal
+  Float_t fL1Delay;         ///< Delay of L1 arrival for the TPC readout
+  UShort_t fNTBinsBeforeL1; ///< Number of time bins before L1 arrival which are being read out
+  Float_t fNTBinsL1;        ///< Overall L1 delay in time bins
  protected:
-  static TObjArray *fBBParam; // array of the Bethe-Bloch parameters. 
+  static TObjArray *fBBParam; ///< array of the Bethe-Bloch parameters.
  private:
   AliTPCParam(const AliTPCParam &);
   AliTPCParam & operator=(const AliTPCParam &);
 
   void CleanGeoMatrices();
 
+  /// \cond CLASSIMP
   ClassDef(AliTPCParam,10)  //parameter  object for set:TPC
+  /// \endcond
 };
 
- 
+
 inline Int_t * AliTPCParam::GetResBin(Int_t i)
 {
-  //return response bin i  - bin given by  padrow [0] pad[1] timebin[2] 
+  /// return response bin i  - bin given by  padrow [0] pad[1] timebin[2]
+
   if (i<fCurrentMax) return &fResponseBin[i*3];
   else return 0;
 }
-  
+
 inline Float_t &AliTPCParam::GetResWeight(Int_t i)
 {
-  //return  weight of response bin i
+  /// return  weight of response bin i
+
   if (i<fCurrentMax) return fResponseWeight[i];
   else return fResponseWeight[i];
 }
@@ -567,28 +570,26 @@ inline Float_t &AliTPCParam::GetResWeight(Int_t i)
 
 inline void  AliTPCParam::AdjustCosSin(Int_t isec, Float_t &cos, Float_t &sin) const
 {
-  //
-  //set cosinus and sinus of rotation angles for sector isec
-  //
+  /// set cosinus and sinus of rotation angles for sector isec
+
   cos=fRotAngle[isec*4];
   sin=fRotAngle[isec*4+1];
 }
 
 inline Float_t   AliTPCParam::GetAngle(Int_t isec) const
 {
-  //
-  //return rotation angle of given sector
-  //
+  /// return rotation angle of given sector
+
   return fRotAngle[isec*4+2];
 }
 
 
 inline void AliTPCParam::Transform1to2Ideal(Float_t *xyz, Int_t *index) const
 {
-  //transformation to rotated coordinates
-  //we must have information about sector!
-  //rotate to given sector
-  // ideal frame
+  /// transformation to rotated coordinates
+  /// we must have information about sector!
+  /// rotate to given sector
+  /// ideal frame
 
   Float_t cos,sin;
   AdjustCosSin(index[1],cos,sin);
@@ -603,12 +604,13 @@ inline void AliTPCParam::Transform1to2Ideal(Float_t *xyz, Int_t *index) const
 
 inline void AliTPCParam::Transform1to2(Float_t *xyz, Int_t *index) const
 {
-  //transformation to rotated coordinates 
-  //we must have information about sector!
-  //rotate to given sector
+  /// transformation to rotated coordinates
+  /// we must have information about sector!
+  /// rotate to given sector
+
   Double_t xyzmaster[3] = {xyz[0],xyz[1],xyz[2]};
   Double_t xyzlocal[3]={0,0,0};
-  if (index[1]>=0 && index[1]<fNSector) 
+  if (index[1]>=0 && index[1]<fNSector)
     fGlobalMatrix[index[1]]->MasterToLocal(xyzmaster,xyzlocal);
   xyz[0] = xyzlocal[0];
   xyz[1] = xyzlocal[1];
@@ -621,39 +623,38 @@ inline void AliTPCParam::Transform1to2(Float_t *xyz, Int_t *index) const
 
 inline void AliTPCParam::Transform2to1(Float_t *xyz, Int_t *index) const
 {
-  //
-  //transformation from  rotated coordinates to global coordinates
-  //
+  /// transformation from  rotated coordinates to global coordinates
+
   Float_t cos,sin;
-  AdjustCosSin(index[1],cos,sin);   
+  AdjustCosSin(index[1],cos,sin);
   Float_t x1=xyz[0]*cos - xyz[1]*sin;
-  Float_t y1=xyz[0]*sin + xyz[1]*cos; 
+  Float_t y1=xyz[0]*sin + xyz[1]*cos;
   xyz[0]=x1;
   xyz[1]=y1;
-  xyz[2]=fZLength-xyz[2]; 
+  xyz[2]=fZLength-xyz[2];
   if (index[1]<fNInnerSector)
     {if ( index[1]>=(fNInnerSector>>1))	xyz[2]*=-1.;}
-  else 
+  else
     {if ( (index[1]-fNInnerSector) >= (fNOuterSector>>1) )    xyz[2]*=-1;}
   index[0]=1;
 }
 
 inline void AliTPCParam::Transform2to2(Float_t *xyz, Int_t *index, Int_t *oindex) const
 {
-  //transform rotated coordinats of one sector to rotated
-  //coordinates relative to another sector
+  /// transform rotated coordinats of one sector to rotated
+  /// coordinates relative to another sector
+
   Transform2to1(xyz,index);
   Transform1to2(xyz,oindex);
   index[0]=2;
-  index[1]=oindex[1];  
+  index[1]=oindex[1];
 }
 
 inline Float_t  AliTPCParam::Transform2to2NearestWire(Float_t *xyz, Int_t *index)  const
 {
-  //
-  // asigns the x-position of the closest wire to xyz[0], return the
-  // electron to closest wire distance
-  //
+  /// asigns the x-position of the closest wire to xyz[0], return the
+  /// electron to closest wire distance
+
   Float_t xnew,dx;
   if (index[1]<fNInnerSector) {
      xnew = fRInnerFirstWire+TMath::Nint((xyz[0]-fRInnerFirstWire)/fInnerWWPitch)*fInnerWWPitch;
@@ -668,17 +669,16 @@ inline Float_t  AliTPCParam::Transform2to2NearestWire(Float_t *xyz, Int_t *index
 
 inline Int_t   AliTPCParam::Transform2to3(Float_t *xyz, Int_t *index)  const
 {
-  //
-  //calulates coresponding pad row number, sets index[2] for straight rows
-  //does not change xyz[] information
-  //valid only for straight row
-  //
-  if  (index[1]<fNInnerSector)   
+  /// calulates coresponding pad row number, sets index[2] for straight rows
+  /// does not change xyz[] information
+  /// valid only for straight row
+
+  if  (index[1]<fNInnerSector)
     index[2] =TMath::Nint((xyz[0]-fPadRowLow[0])/fInnerPadPitchLength);
   else
     if (xyz[0] < fLastWireUp1 )
       index[2] = TMath::Nint((xyz[0]-fPadRowUp[0])/fOuter1PadPitchLength);
-    else 
+    else
       index[2] = TMath::Nint(fNRowUp1+(xyz[0]-fPadRowUp[64])/fOuter2PadPitchLength);
   index[0]=3;
   return index[2];
@@ -686,32 +686,30 @@ inline Int_t   AliTPCParam::Transform2to3(Float_t *xyz, Int_t *index)  const
 
 inline void   AliTPCParam::Transform3to4(Float_t *xyz, Int_t *index)  const
 {
-  //
-  //valid only for straight rows straight rows
-  //calculate xyz[0] position relative to given index
-  //
-  if  (index[1]<fNInnerSector)   
+  /// valid only for straight rows straight rows
+  /// calculate xyz[0] position relative to given index
+
+  if  (index[1]<fNInnerSector)
     xyz[0] -=index[2]*fInnerPadPitchLength+fPadRowLow[0];
   else
     if (index[2]<fNRowUp1)
       xyz[0] -=index[2]*fOuter1PadPitchLength+fPadRowUp[0];
-    else 
+    else
       xyz[0] -=(index[2]-fNRowUp1)*fOuter2PadPitchLength+fPadRowUp[64];
   index[0]  =4;
 }
 
 inline void   AliTPCParam::Transform4to3(Float_t *xyz, Int_t *index) const
 {
-  //
-  //valid only for straight rows 
-  //transforms  relative xyz[0] to the global one within given sector
-  //
-  if  (index[1]<fNInnerSector)   
+  /// valid only for straight rows
+  /// transforms  relative xyz[0] to the global one within given sector
+
+  if  (index[1]<fNInnerSector)
     xyz[0] +=index[2]*fInnerPadPitchLength+fPadRowLow[0];
   else
     if(index[2]<fNRowUp1)
       xyz[0] +=index[2]*fOuter1PadPitchLength+fPadRowUp[0];
-    else 
+    else
       xyz[0] +=index[2]*fOuter2PadPitchLength+fPadRowUp[64];
   index[0]  =3;
 }
@@ -719,9 +717,8 @@ inline void   AliTPCParam::Transform4to3(Float_t *xyz, Int_t *index) const
 
 inline void   AliTPCParam::Transform2to5( Float_t *xyz, Int_t *index) const
 {
-  //
-  //transform [x,y,z] to [r,phi,z]
-  //
+  /// transform [x,y,z] to [r,phi,z]
+
   Float_t angle;
   Float_t r = TMath::Sqrt(xyz[0]*xyz[0]+xyz[1]*xyz[1]);
   if ((xyz[0]==0)&&(xyz[1]==0)) angle = 0;
@@ -738,9 +735,8 @@ inline void   AliTPCParam::Transform2to5( Float_t *xyz, Int_t *index) const
 
 inline void   AliTPCParam::Transform5to2( Float_t *xyz, Int_t *index)  const
 {
-  //
-  //transform [r,rphi,z] to [x,y,z] 
-  //
+  /// transform [r,rphi,z] to [x,y,z]
+
   Float_t r = xyz[0];
   Float_t angle= xyz[1];
   xyz[0]=r*TMath::Cos(angle);
@@ -750,26 +746,24 @@ inline void   AliTPCParam::Transform5to2( Float_t *xyz, Int_t *index)  const
 
 inline void AliTPCParam::Transform4to8(Float_t *xyz, Int_t *index) const
 {
-  //
-  //transform xyz coordinates to 'digit' coordinates
-  //
+  /// transform xyz coordinates to 'digit' coordinates
 
   if (index[1]<fNInnerSector) {
     if ( index[1]>=(fNInnerSector>>1)) xyz[1]*=-1.;
   }
   else {
-    if ( (index[1]-fNInnerSector) >= (fNOuterSector>>1) ) xyz[1]*=-1;      
+    if ( (index[1]-fNInnerSector) >= (fNOuterSector>>1) ) xyz[1]*=-1;
   }
 
-  xyz[2]/=fZWidth;  
-  if  (index[1]<fNInnerSector) {    
+  xyz[2]/=fZWidth;
+  if  (index[1]<fNInnerSector) {
     xyz[0]/=fInnerPadPitchLength;
     xyz[1]/=fInnerPadPitchWidth;
   }
-  else{  
-    xyz[1]/=fOuterPadPitchWidth;  
-    if (index[2]<fNRowUp1 ) xyz[0]/=fOuter1PadPitchLength;      
-    else xyz[0]/=fOuter2PadPitchLength;     
+  else{
+    xyz[1]/=fOuterPadPitchWidth;
+    if (index[2]<fNRowUp1 ) xyz[0]/=fOuter1PadPitchLength;
+    else xyz[0]/=fOuter2PadPitchLength;
   }
   xyz[1]-=0.5;
   index[0]=8;
@@ -777,66 +771,63 @@ inline void AliTPCParam::Transform4to8(Float_t *xyz, Int_t *index) const
 
 inline void AliTPCParam::Transform8to4(Float_t *xyz, Int_t *index) const
 {
-  //
-  //transforms 'digit' coordinates to xyz coordinates
-  //
+  /// transforms 'digit' coordinates to xyz coordinates
+
   if (index[1]<fNInnerSector) {
     if ( index[1]>=(fNInnerSector>>1)) xyz[1]*=-1.;
   }
   else {
-    if ( (index[1]-fNInnerSector) >= (fNOuterSector>>1) ) xyz[1]*=-1;      
+    if ( (index[1]-fNInnerSector) >= (fNOuterSector>>1) ) xyz[1]*=-1;
   }
 
   xyz[2]*=fZWidth;
-  if  (index[1]<fNInnerSector) {    
+  if  (index[1]<fNInnerSector) {
     xyz[0]*=fInnerPadPitchLength;
-    xyz[1]*=fInnerPadPitchWidth;    
+    xyz[1]*=fInnerPadPitchWidth;
   }
-  else{  
-    xyz[1]*=fOuterPadPitchWidth;  
+  else{
+    xyz[1]*=fOuterPadPitchWidth;
     if (index[2] < fNRowUp1 ) xyz[0]*=fOuter1PadPitchLength;
-    else xyz[0]*=fOuter2PadPitchLength;           
-  } 
+    else xyz[0]*=fOuter2PadPitchLength;
+  }
   index[0]=4;
 }
 
 inline void  AliTPCParam::Transform6to8(Float_t *xyz, Int_t *index) const
 {
-  //
-  //transforms cylindrical xyz coordinates to 'digit' coordinates
-  //
+  /// transforms cylindrical xyz coordinates to 'digit' coordinates
+
   xyz[2]/=fZWidth;
-  if  (index[1]<fNInnerSector) {    
+  if  (index[1]<fNInnerSector) {
     xyz[0]/=fInnerPadPitchLength;
     xyz[1]*=xyz[0]/fInnerPadPitchWidth;
   }
-  else{ 
+  else{
     xyz[1]*=xyz[0]/fOuterPadPitchWidth;
     if (index[2] < fNRowUp1 ) xyz[0]/=fOuter1PadPitchLength;
-    else xyz[0]/=fOuter2PadPitchLength;       
+    else xyz[0]/=fOuter2PadPitchLength;
   }
   index[0]=8;
 }
 
 inline void  AliTPCParam::Transform8to6(Float_t *xyz, Int_t *index) const
 {
-  //
-  //transforms 'digit' coordinates to cylindrical xyz coordinates 
-  //
+  /// transforms 'digit' coordinates to cylindrical xyz coordinates
+
   xyz[2]*=fZWidth;
-  if  (index[1]<fNInnerSector) {    
+  if  (index[1]<fNInnerSector) {
     xyz[0]*=fInnerPadPitchLength;
     xyz[1]/=xyz[0]/fInnerPadPitchWidth;
   }
-  else{ 
-    xyz[1]/=xyz[0]/fOuterPadPitchWidth;  
+  else{
+    xyz[1]/=xyz[0]/fOuterPadPitchWidth;
     if (index[2] < fNRowUp1 ) xyz[0]*=fOuter1PadPitchLength;
-    else xyz[0]*=fOuter2PadPitchLength;                
-  }  
+    else xyz[0]*=fOuter2PadPitchLength;
+  }
   index[0]=6;
 }
 inline Float_t AliTPCParam::GetZLength(Int_t sector) const
 { if(sector <18 || (sector>35&&sector<54)) return   fZLength-0.275;
   else return fZLength-0.302;
 }
-#endif  
+#endif
diff --git a/TPC/TPCbase/AliTPCParamSR.cxx b/TPC/TPCbase/AliTPCParamSR.cxx
index a112df279b8..63e66692f30 100644
--- a/TPC/TPCbase/AliTPCParamSR.cxx
+++ b/TPC/TPCbase/AliTPCParamSR.cxx
@@ -13,19 +13,17 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/* $Id$ */
-
-///////////////////////////////////////////////////////////////////////
-//  Manager and of geomety  classes for set: TPC                     //
-//                                                                   //
-//  !sectors are numbered from  0                                     //
-//  !pad rows are numbered from 0                                     //
-//  
-//  27.7.   - AliTPCPaaramSr object for TPC 
-//            TPC with straight pad rows 
-//  Origin:  Marian Ivanov, Uni. of Bratislava, ivanov@fmph.uniba.sk // 
-//                                                                   //  
-///////////////////////////////////////////////////////////////////////
+
+/// \class AliTPCParamSR
+/// \brief Manager and of geomety  classes for set: TPC
+///
+/// !sectors are numbered from  0
+/// !pad rows are numbered from 0
+///
+/// 27.7.   - AliTPCPaaramSr object for TPC
+/// TPC with straight pad rows
+///
+/// \author Marian Ivanov, Uni. of Bratislava, ivanov@fmph.uniba.sk
 
 //#include <Riostream.h>
 #include <TMath.h>
@@ -37,7 +35,9 @@
 #include "AliTPCROC.h"
 #include "TGeoManager.h"
 
+/// \cond CLASSIMP
 ClassImp(AliTPCParamSR)
+/// \endcond
 static const  Int_t kMaxRows=600;
 static const  Float_t  kEdgeSectorSpace = 2.5;
 static const Float_t kFacSigmaPadRow=3.;
@@ -54,10 +54,8 @@ AliTPCParamSR::AliTPCParamSR()
 	       fFacSigmaPadRow(0),
 	       fFacSigmaPad(0),
 	       fFacSigmaTime(0)
-{   
-  //
-  //constructor set the default parameters
-  //
+{
+  /// constructor set the default parameters
 
   fFacSigmaPadRow = Float_t(kFacSigmaPadRow);
   fFacSigmaPad = Float_t(kFacSigmaPad);
@@ -68,8 +66,8 @@ AliTPCParamSR::AliTPCParamSR()
 
 AliTPCParamSR::~AliTPCParamSR()
 {
-  //
-  //destructor destroy some dynmicaly alocated variables
+  /// destructor destroy some dynmicaly alocated variables
+
   if (fInnerPRF != 0) delete fInnerPRF;
   if (fOuter1PRF != 0) delete fOuter1PRF;
   if (fOuter2PRF != 0) delete fOuter2PRF;
@@ -78,28 +76,29 @@ AliTPCParamSR::~AliTPCParamSR()
 
 void AliTPCParamSR::SetDefault()
 {
-  //set default TPC param   
+  /// set default TPC param
+
   fbStatus = kFALSE;
-  AliTPCParam::SetDefault();  
-}  
+  AliTPCParam::SetDefault();
+}
 
 Int_t  AliTPCParamSR::CalcResponse(Float_t* xyz, Int_t * index, Int_t row)
 {
-  //
-  //calculate bin response as function of the input position -x 
-  //return number of valid response bin
-  //
-  //we suppose that coordinate is expressed in float digits 
-  // it's mean coordinate system 8
-  //xyz[0] - float padrow xyz[1] is float pad  (center pad is number 0) and xyz[2] is float time bin
-  //xyz[3] - electron time in float time bin format
-  if ( (fInnerPRF==0)||(fOuter1PRF==0)||(fOuter2PRF==0) ||(fTimeRF==0) ){ 
+  /// calculate bin response as function of the input position -x
+  /// return number of valid response bin
+  ///
+  /// we suppose that coordinate is expressed in float digits
+  /// it's mean coordinate system 8
+  /// xyz[0] - float padrow xyz[1] is float pad  (center pad is number 0) and xyz[2] is float time bin
+  /// xyz[3] - electron time in float time bin format
+
+  if ( (fInnerPRF==0)||(fOuter1PRF==0)||(fOuter2PRF==0) ||(fTimeRF==0) ){
     Error("AliTPCParamSR", "response function was not adjusted");
     return -1;
   }
-  
+
   Float_t sfpadrow;   // sigma of response function
-  Float_t sfpad;      // sigma  of 
+  Float_t sfpad;      // sigma  of
   Float_t sftime= fFacSigmaTime*fTimeRF->GetSigma()/fZWidth;     //3 sigma of time response
   if (index[1]<fNInnerSector){
     sfpadrow =fFacSigmaPadRow*fInnerPRF->GetSigmaY()/fInnerPadPitchLength;
@@ -112,7 +111,7 @@ Int_t  AliTPCParamSR::CalcResponse(Float_t* xyz, Int_t * index, Int_t row)
     else{
       sfpadrow =fFacSigmaPadRow*fOuter2PRF->GetSigmaY()/fOuter2PadPitchLength;
       sfpad    =fFacSigmaPad*fOuter2PRF->GetSigmaX()/fOuterPadPitchWidth;
-    }   
+    }
   }
 
   Int_t fpadrow = TMath::Max(TMath::Nint(index[2]+xyz[0]-sfpadrow),0);  //"first" padrow
@@ -122,32 +121,32 @@ Int_t  AliTPCParamSR::CalcResponse(Float_t* xyz, Int_t * index, Int_t row)
   lpadrow       = TMath::Min(GetNRow(index[1])-1,lpadrow);
   Int_t lpad    = TMath::Min(TMath::Nint(xyz[1]+sfpad),fpad+19);     //last pad
   Int_t ltime   = TMath::Min(TMath::Nint(xyz[2]+xyz[3]+GetZOffset()/GetZWidth()+sftime),ftime+19);    // last time
-  ltime         = TMath::Min(ltime,GetMaxTBin()-1); 
-  // 
+  ltime         = TMath::Min(ltime,GetMaxTBin()-1);
+  //
   Int_t npads = GetNPads(index[1],row);
-  if (fpad<-npads/2) 
+  if (fpad<-npads/2)
     fpad = -npads/2;
-  if (lpad>npads/2) 
+  if (lpad>npads/2)
     lpad= npads/2;
   if (ftime<0) ftime=0;
-  // 
+  //
   if (row>=0) { //if we are interesting about given pad row
     if (fpadrow<=row) fpadrow =row;
-    else 
+    else
       return 0;
     if (lpadrow>=row) lpadrow = row;
-    else 
+    else
       return 0;
   }
 
- 
+
   Float_t  padres[20][20];  //I don't expect bigger number of bins
-  Float_t  timeres[20];     
+  Float_t  timeres[20];
   Int_t cindex3=0;
   Int_t cindex=0;
   Float_t cweight = 0;
   if (fpadrow>=0) {
-  //calculate padresponse function    
+  //calculate padresponse function
   Int_t padrow, pad;
   for (padrow = fpadrow;padrow<=lpadrow;padrow++)
     for (pad = fpad;pad<=lpad;pad++){
@@ -162,8 +161,8 @@ Int_t  AliTPCParamSR::CalcResponse(Float_t* xyz, Int_t * index, Int_t row)
 	  padres[padrow-fpadrow][pad-fpad]=fOuter2PRF->GetPRF(dx*fOuterPadPitchWidth,dy*fOuter2PadPitchLength);}}}
   //calculate time response function
   Int_t time;
-  for (time = ftime;time<=ltime;time++) 
-    timeres[time-ftime]= fTimeRF->GetRF((-xyz[2]-xyz[3]+Float_t(time))*fZWidth);     
+  for (time = ftime;time<=ltime;time++)
+    timeres[time-ftime]= fTimeRF->GetRF((-xyz[2]-xyz[3]+Float_t(time))*fZWidth);
   //write over threshold values to stack
   for (padrow = fpadrow;padrow<=lpadrow;padrow++)
     for (pad = fpad;pad<=lpad;pad++)
@@ -173,21 +172,20 @@ Int_t  AliTPCParamSR::CalcResponse(Float_t* xyz, Int_t * index, Int_t row)
 	  fResponseBin[cindex3]=padrow;
 	  fResponseBin[cindex3+1]=pad;
 	  fResponseBin[cindex3+2]=time;
-	  cindex3+=3;  
+	  cindex3+=3;
 	  fResponseWeight[cindex]=cweight;
 	  cindex++;
 	}
       }
   }
-  fCurrentMax=cindex;	
+  fCurrentMax=cindex;
   return fCurrentMax;
 }
 
 void AliTPCParamSR::TransformTo8(Float_t *xyz, Int_t *index) const
 {
-  //
-  // transformate point to digit coordinate
-  //
+  /// transformate point to digit coordinate
+
   if (index[0]==0) Transform0to1(xyz,index);
   if (index[0]==1) Transform1to2(xyz,index);
   if (index[0]==2) Transform2to3(xyz,index);
@@ -197,43 +195,45 @@ void AliTPCParamSR::TransformTo8(Float_t *xyz, Int_t *index) const
 
 void AliTPCParamSR::TransformTo2(Float_t *xyz, Int_t *index) const
 {
-  //
-  //transformate point to rotated coordinate
-  //
-  //we suppose that   
+  /// transformate point to rotated coordinate
+  ///
+  /// we suppose that
+
   if (index[0]==0) Transform0to1(xyz,index);
   if (index[0]==1) Transform1to2(xyz,index);
   if (index[0]==4) Transform4to3(xyz,index);
   if (index[0]==8) {  //if we are in digit coordinate system transform to global
     Transform8to4(xyz,index);
-    Transform4to3(xyz,index);  
+    Transform4to3(xyz,index);
   }
 }
 
 void AliTPCParamSR::CRXYZtoXYZ(Float_t *xyz,
-	       const Int_t &sector, const Int_t & padrow, Int_t option) const  
-{  
-  //transform relative coordinates to absolute
+	       const Int_t &sector, const Int_t & padrow, Int_t option) const
+{
+  /// transform relative coordinates to absolute
+
   Bool_t rel = ( (option&2)!=0);
   Int_t index[3]={sector,padrow,0};
-  if (rel==kTRUE)      Transform4to3(xyz,index);//if the position is relative to pad row  
+  if (rel==kTRUE)      Transform4to3(xyz,index);//if the position is relative to pad row
   Transform2to1(xyz,index);
 }
 
 void AliTPCParamSR::XYZtoCRXYZ(Float_t *xyz,
 			     Int_t &sector, Int_t & padrow, Int_t option) const
 {
-   //transform global position to the position relative to the sector padrow
-  //if option=0  X calculate absolute            calculate sector
-  //if option=1  X           absolute            use input sector
-  //if option=2  X           relative to pad row calculate sector
-  //if option=3  X           relative            use input sector
-  //!!!!!!!!! WE start to calculate rows from row = 0
+  /// transform global position to the position relative to the sector padrow
+  /// if option=0  X calculate absolute            calculate sector
+  /// if option=1  X           absolute            use input sector
+  /// if option=2  X           relative to pad row calculate sector
+  /// if option=3  X           relative            use input sector
+  /// !!!!!!!!! WE start to calculate rows from row = 0
+
   Int_t index[3];
-  Bool_t rel = ( (option&2)!=0);  
+  Bool_t rel = ( (option&2)!=0);
 
   //option 0 and 2  means that we don't have information about sector
-  if ((option&1)==0)   Transform0to1(xyz,index);  //we calculate sector number 
+  if ((option&1)==0)   Transform0to1(xyz,index);  //we calculate sector number
   else
     index[0]=sector;
   Transform1to2(xyz,index);
@@ -246,8 +246,8 @@ void AliTPCParamSR::XYZtoCRXYZ(Float_t *xyz,
 
 Float_t AliTPCParamSR::GetPrimaryLoss(Float_t */*x*/, Int_t *index, Float_t *angle)
 {
-  //
-  //
+  ///
+
   Float_t padlength=GetPadPitchLength(index[1]);
   Float_t a1=TMath::Sin(angle[0]);
   a1*=a1;
@@ -259,8 +259,8 @@ Float_t AliTPCParamSR::GetPrimaryLoss(Float_t */*x*/, Int_t *index, Float_t *ang
 
 Float_t AliTPCParamSR::GetTotalLoss(Float_t */*x*/, Int_t *index, Float_t *angle)
 {
-  //
-  //
+  ///
+
   Float_t padlength=GetPadPitchLength(index[1]);
   Float_t a1=TMath::Sin(angle[0]);
   a1*=a1;
@@ -268,18 +268,17 @@ Float_t AliTPCParamSR::GetTotalLoss(Float_t */*x*/, Int_t *index, Float_t *angle
   a2*=a2;
   Float_t length =padlength*TMath::Sqrt(1+a1+a2);
   return length*fNTotalLoss;
-  
+
 }
 
 
 void AliTPCParamSR::GetClusterSize(Float_t *x, Int_t *index, Float_t */*angle*/, Int_t /*mode*/, Float_t *sigma)
 {
-  //
-  //return cluster sigma2 (x,y) for particle at position x
-  // in this case x coordinata is in drift direction
-  //and y in pad row direction
-  //we suppose that input coordinate system is digit system
-   
+  /// return cluster sigma2 (x,y) for particle at position x
+  /// in this case x coordinata is in drift direction
+  /// and y in pad row direction
+  /// we suppose that input coordinate system is digit system
+
   Float_t  xx;
   Float_t lx[3] = {x[0],x[1],x[2]};
   Int_t   li[3] = {index[0],index[1],index[2]};
@@ -287,17 +286,17 @@ void AliTPCParamSR::GetClusterSize(Float_t *x, Int_t *index, Float_t */*angle*/,
   //  Float_t  sigmadiff;
   sigma[0]=0;
   sigma[1]=0;
-  
+
   xx = lx[2];  //calculate drift length in cm
   if (xx>0) {
     sigma[0]+= xx*GetDiffL()*GetDiffL();
-    sigma[1]+= xx*GetDiffT()*GetDiffT(); 
+    sigma[1]+= xx*GetDiffT()*GetDiffT();
   }
 
 
   //sigma[0]=sigma[1]=0;
   if (GetTimeRF()!=0) sigma[0]+=GetTimeRF()->GetSigma()*GetTimeRF()->GetSigma();
-  if ( (index[1]<fNInnerSector) &&(GetInnerPRF()!=0))   
+  if ( (index[1]<fNInnerSector) &&(GetInnerPRF()!=0))
     sigma[1]+=GetInnerPRF()->GetSigmaX()*GetInnerPRF()->GetSigmaX();
   if ( (index[1]>=fNInnerSector) &&(index[2]<fNRowUp1) && (GetOuter1PRF()!=0))
     sigma[1]+=GetOuter1PRF()->GetSigmaX()*GetOuter1PRF()->GetSigmaX();
@@ -312,47 +311,42 @@ void AliTPCParamSR::GetClusterSize(Float_t *x, Int_t *index, Float_t */*angle*/,
 
 
 
-void AliTPCParamSR::GetSpaceResolution(Float_t */*x*/, Int_t */*index*/, Float_t */*angle*/, 
+void AliTPCParamSR::GetSpaceResolution(Float_t */*x*/, Int_t */*index*/, Float_t */*angle*/,
 				       Float_t /*amplitude*/, Int_t /*mode*/, Float_t */*sigma*/)
 {
-  //
-  //
-  //
-  
+  ///
+
 }
 Float_t  AliTPCParamSR::GetAmp(Float_t */*x*/, Int_t */*index*/, Float_t */*angle*/)
 {
-  //
-  //
-  //
+  ///
+
   return 0;
 }
 
 Float_t * AliTPCParamSR::GetAnglesAccMomentum(Float_t *x, Int_t * index, Float_t* momentum, Float_t *angle)
 {
-  //
-  //calculate angle of track to padrow at given position
-  // for given magnetic field and momentum of the particle
-  //
+  /// calculate angle of track to padrow at given position
+  /// for given magnetic field and momentum of the particle
 
   TransformTo2(x,index);
-  AliDetectorParam::GetAnglesAccMomentum(x,index,momentum,angle);    
+  AliDetectorParam::GetAnglesAccMomentum(x,index,momentum,angle);
   Float_t addangle = TMath::ASin(x[1]/GetPadRowRadii(index[1],index[2]));
   angle[1] +=addangle;
-  return angle;				 
+  return angle;
 }
 
-         
+
 Bool_t AliTPCParamSR::Update()
 {
   Int_t i;
   if (AliTPCParam::Update()==kFALSE) return kFALSE;
   fbStatus = kFALSE;
 
- Float_t firstrow = fInnerRadiusLow + 1.575;   
+ Float_t firstrow = fInnerRadiusLow + 1.575;
  for( i= 0;i<fNRowLow;i++)
    {
-     Float_t x = firstrow + fInnerPadPitchLength*(Float_t)i;  
+     Float_t x = firstrow + fInnerPadPitchLength*(Float_t)i;
      fPadRowLow[i]=x;
      // number of pads per row
      //     Float_t y = (x-0.5*fInnerPadPitchLength)*tan(fInnerAngle/2.)-fInnerWireMount-
@@ -360,22 +354,22 @@ Bool_t AliTPCParamSR::Update()
      // 0 and fNRowLow+1 reserved for cross talk rows
      fYInner[i+1]  = x*tan(fInnerAngle/2.)-fInnerWireMount;
      //fNPadsLow[i] = 1+2*(Int_t)(y/fInnerPadPitchWidth) ;
-     fNPadsLow[i] = AliTPCROC::Instance()->GetNPads(0,i) ;     // ROC implement     
+     fNPadsLow[i] = AliTPCROC::Instance()->GetNPads(0,i) ;     // ROC implement
    }
  // cross talk rows
  fYInner[0]=(fPadRowLow[0]-fInnerPadPitchLength)*tan(fInnerAngle/2.)-fInnerWireMount;
- fYInner[fNRowLow+1]=(fPadRowLow[fNRowLow-1]+fInnerPadPitchLength)*tan(fInnerAngle/2.)-fInnerWireMount; 
+ fYInner[fNRowLow+1]=(fPadRowLow[fNRowLow-1]+fInnerPadPitchLength)*tan(fInnerAngle/2.)-fInnerWireMount;
  firstrow = fOuterRadiusLow + 1.6;
  for(i=0;i<fNRowUp;i++)
    {
      if(i<fNRowUp1){
-       Float_t x = firstrow + fOuter1PadPitchLength*(Float_t)i; 
+       Float_t x = firstrow + fOuter1PadPitchLength*(Float_t)i;
        fPadRowUp[i]=x;
 //     Float_t y =(x-0.5*fOuter1PadPitchLength)*tan(fOuterAngle/2.)-fOuterWireMount-
 // 	  fOuterPadPitchWidth/2.;
      fYOuter[i+1]= x*tan(fOuterAngle/2.)-fOuterWireMount;
      //fNPadsUp[i] = 1+2*(Int_t)(y/fOuterPadPitchWidth) ;
-     fNPadsUp[i] =  AliTPCROC::Instance()->GetNPads(36,i) ;     // ROC implement      
+     fNPadsUp[i] =  AliTPCROC::Instance()->GetNPads(36,i) ;     // ROC implement
      if(i==fNRowUp1-1) {
        fLastWireUp1=fPadRowUp[i] +0.625;
        firstrow = fPadRowUp[i] + 0.5*(fOuter1PadPitchLength+fOuter2PadPitchLength);
@@ -387,7 +381,7 @@ Bool_t AliTPCParamSR::Update()
          fPadRowUp[i]=x;
 	 //Float_t y =(x-0.5*fOuter2PadPitchLength)*tan(fOuterAngle/2.)-fOuterWireMount-
 	 //  fOuterPadPitchWidth/2.;
-	 //fNPadsUp[i] = 1+2*(Int_t)(y/fOuterPadPitchWidth) ; 
+	 //fNPadsUp[i] = 1+2*(Int_t)(y/fOuterPadPitchWidth) ;
 	 fNPadsUp[i] =  AliTPCROC::Instance()->GetNPads(36,i) ;     // ROC implement
        }
      fYOuter[i+1]  = fPadRowUp[i]*tan(fOuterAngle/2.)-fOuterWireMount;
@@ -410,7 +404,7 @@ Float_t AliTPCParamSR::GetYOuter(Int_t irow) const
 
 void AliTPCParamSR::Streamer(TBuffer &R__b)
 {
-   // Stream an object of class AliTPC.
+   /// Stream an object of class AliTPC.
 
    if (R__b.IsReading()) {
       Version_t R__v = R__b.ReadVersion(); if (R__v) { }
@@ -421,26 +415,26 @@ void AliTPCParamSR::Streamer(TBuffer &R__b)
        if (gGeoManager) ReadGeoMatrices();
    } else {
       R__b.WriteVersion(AliTPCParamSR::IsA());
-      //TObject::Streamer(R__b);  
-      AliTPCParam::Streamer(R__b);    
+      //TObject::Streamer(R__b);
+      AliTPCParam::Streamer(R__b);
    }
 }
 Int_t  AliTPCParamSR::CalcResponseFast(Float_t* xyz, Int_t * index, Int_t row, Float_t phase)
 {
-  //
-  //calculate bin response as function of the input position -x 
-  //return number of valid response bin
-  //
-  //we suppose that coordinate is expressed in float digits 
-  // it's mean coordinate system 8
-  //xyz[0] - electron position w.r.t. pad center, normalized to pad length,
-  //xyz[1] is float pad  (center pad is number 0) and xyz[2] is float time bin
-  //xyz[3] - electron time in float time bin format
-  if ( (fInnerPRF==0)||(fOuter1PRF==0)||(fOuter2PRF==0) ||(fTimeRF==0) ){ 
+  /// calculate bin response as function of the input position -x
+  /// return number of valid response bin
+  ///
+  /// we suppose that coordinate is expressed in float digits
+  /// it's mean coordinate system 8
+  /// xyz[0] - electron position w.r.t. pad center, normalized to pad length,
+  /// xyz[1] is float pad  (center pad is number 0) and xyz[2] is float time bin
+  /// xyz[3] - electron time in float time bin format
+
+  if ( (fInnerPRF==0)||(fOuter1PRF==0)||(fOuter2PRF==0) ||(fTimeRF==0) ){
     Error("AliTPCParamSR", "response function was not adjusted");
     return -1;
   }
-  
+
   const Int_t kpadn =  500;
   const Float_t kfpadn =  500.;
   const Int_t ktimen = 500;
@@ -448,12 +442,12 @@ Int_t  AliTPCParamSR::CalcResponseFast(Float_t* xyz, Int_t * index, Int_t row, F
   const Int_t kpadrn = 500;
   const Float_t kfpadrn = 500.;
 
- 
+
 
   static Float_t prfinner[2*kpadrn][5*kpadn];  //pad divided by 50
   static Float_t prfouter1[2*kpadrn][5*kpadn];  //prfouter division
   static Float_t prfouter2[2*kpadrn][5*kpadn];
-  static Float_t kTanMax =0;  
+  static Float_t kTanMax =0;
 
   static Float_t rftime[5*ktimen];         //time division
   static Int_t blabla=0;
@@ -463,13 +457,13 @@ Int_t  AliTPCParamSR::CalcResponseFast(Float_t* xyz, Int_t * index, Int_t row, F
   static TH1F * hdiff=0;
   static TH1F * hdiff1=0;
   static TH1F * hdiff2=0;
-  
+
   if (blabla==0) {  //calculate Response function - only at the begginning
     kTanMax = TMath::ATan(10.*TMath::DegToRad());
     hdiff =new TH1F("prf_diff","prf_diff",10000,-1,1);
     hdiff1 =new TH1F("no_repsonse1","no_response1",10000,-1,1);
     hdiff2 =new TH1F("no_response2","no_response2",10000,-1,1);
-    
+
     blabla=1;
     zoffset = GetZOffset();
     zwidth  = fZWidth;
@@ -477,7 +471,7 @@ Int_t  AliTPCParamSR::CalcResponseFast(Float_t* xyz, Int_t * index, Int_t row, F
     for (Int_t i=0;i<5*ktimen;i++){
       rftime[i] = fTimeRF->GetRF(((i-2.5*kftimen)/kftimen)*zwidth+zoffset);
     }
-    for (Int_t i=0;i<5*kpadn;i++){    
+    for (Int_t i=0;i<5*kpadn;i++){
       for (Int_t j=0;j<2*kpadrn;j++){
 	prfinner[j][i] =
 	  fInnerPRF->GetPRF((i-2.5*kfpadn)/kfpadn
@@ -491,7 +485,7 @@ Int_t  AliTPCParamSR::CalcResponseFast(Float_t* xyz, Int_t * index, Int_t row, F
 	  fOuter2PRF->GetPRF((i-2.5*kfpadn)/kfpadn
 			    *fOuterPadPitchWidth,(j-kfpadrn)/kfpadrn*fOuter2PadPitchLength);
       }
-    }      
+    }
   } // the above is calculated only once
 
   // calculate central padrow, pad, time
@@ -528,20 +522,20 @@ Int_t  AliTPCParamSR::CalcResponseFast(Float_t* xyz, Int_t * index, Int_t row, F
     dpadrow *= fOuter2PadPitchLength;
     dpadrow += fOuterWWPitch;
     dpadrow /= fOuter1PadPitchLength;
-  }    
+  }
   // cross talk from short pad to long one
-  if(row==fNRowUp1+1 && fpadrow==1){ 
+  if(row==fNRowUp1+1 && fpadrow==1){
     dpadrow *= fOuter1PadPitchLength;
     if(dpadrow < 0.) dpadrow = -1.; //protection against 3rd wire
     dpadrow += fOuterWWPitch;
     dpadrow /= fOuter2PadPitchLength;
-    
+
   }
 
   // "normal"
   Int_t apadrow = TMath::Nint((dpadrow-fpadrow)*kfpadrn+kfpadrn);
   for (Int_t ipadrow = fpadrow; ipadrow<=lpadrow;ipadrow++){
-    if ( (apadrow<0) || (apadrow>=2*kpadrn)) 
+    if ( (apadrow<0) || (apadrow>=2*kpadrn))
       continue;
     // pad angular correction
     Float_t angle = 0.;
@@ -578,23 +572,23 @@ Int_t  AliTPCParamSR::CalcResponseFast(Float_t* xyz, Int_t * index, Int_t row, F
 	}
 	//	if (cweight<fResponseThreshold) continue;
 	Int_t atime = TMath::Nint((dtime-ftime)*kftimen+2.5*kftimen);
-	for (Int_t itime = ftime;itime<=ltime;itime++){	
+	for (Int_t itime = ftime;itime<=ltime;itime++){
 	  Float_t cweight2 = cweight*rftime[atime];
 	  if (cweight2>fResponseThreshold) {
 	    fResponseBin[cindex3++]=cpadrow+ipadrow;
 	    fResponseBin[cindex3++]=cpad+ipad;
 	    fResponseBin[cindex3++]=ctime+itime;
-	    fResponseWeight[cindex++]=cweight2;	  	    
+	    fResponseWeight[cindex++]=cweight2;
 	  }
 	  atime-=ktimen;
 	}
-	apad-= kpadn;	
+	apad-= kpadn;
     }
     apadrow-=kpadrn;
   }
-  fCurrentMax=cindex;	
-  return fCurrentMax;    
-  
+  fCurrentMax=cindex;
+  return fCurrentMax;
+
 }
 
 
diff --git a/TPC/TPCbase/AliTPCParamSR.h b/TPC/TPCbase/AliTPCParamSR.h
index 534b5bd1a85..a4ce814cfd1 100644
--- a/TPC/TPCbase/AliTPCParamSR.h
+++ b/TPC/TPCbase/AliTPCParamSR.h
@@ -3,11 +3,10 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-/* $Id$ */
 
-////////////////////////////////////////////////
-//  Manager class for TPC parameters          //
-////////////////////////////////////////////////
+/// \class AliTPCParamSR
+/// \brief Manager class for TPC parameters
+
 #include "AliTPCParam.h"
 
 class AliTPCRF1D;
@@ -20,11 +19,11 @@ public:
 
   Int_t  CalcResponse(Float_t* x, Int_t * index, Int_t row);
   Int_t CalcResponseFast(Float_t* x, Int_t * index, Int_t row,Float_t phase);
-  //calculate bin response as function of the input position -x 
+  //calculate bin response as function of the input position -x
   //return number of valid response bin
 
-  
-  void XYZtoCRXYZ(Float_t *xyz, 
+
+  void XYZtoCRXYZ(Float_t *xyz,
 		  Int_t &sector, Int_t &padrow, Int_t option=3) const;
   //transform global position to the position relative to the sector padrow
   //if option=0  X calculate absolute            calculate sector
@@ -33,11 +32,11 @@ public:
   //if option=3  X           relative            use input sector
 
   void CRXYZtoXYZ(Float_t *xyz,
-	    const Int_t &sector, const Int_t & padrow, Int_t option=3) const;  
+	    const Int_t &sector, const Int_t & padrow, Int_t option=3) const;
   //transform relative position  to the gloabal position
   void TransformTo8(Float_t *xyz, Int_t *index) const;
   void TransformTo2(Float_t *xyz, Int_t *index) const;
-  Bool_t Update();            //recalculate and check geometric parameters 
+  Bool_t Update();            //recalculate and check geometric parameters
   void SetDefault();          //set default parameters
   void   SetInnerPRF(AliTPCPRF2D * prf) {fInnerPRF = prf;}
   void   SetOuter1PRF(AliTPCPRF2D * prf) {fOuter1PRF = prf;} //e.k
@@ -63,25 +62,27 @@ public:
   virtual void GetClusterSize(Float_t *x, Int_t *index, Float_t *angle, Int_t mode, Float_t *sigma);
   virtual void GetSpaceResolution(Float_t *x, Int_t *index, Float_t *angle, Float_t amplitude, Int_t mode,Float_t *sigma);
   virtual Float_t  GetAmp(Float_t *x, Int_t *index, Float_t *angle);
-  virtual Float_t * GetAnglesAccMomentum(Float_t *x, Int_t * index, Float_t* momentum, Float_t *angle); 
- 
+  virtual Float_t * GetAnglesAccMomentum(Float_t *x, Int_t * index, Float_t* momentum, Float_t *angle);
+
 protected:
-  AliTPCPRF2D * fInnerPRF;         //pad response function  for inner sector
-  AliTPCPRF2D * fOuter1PRF;        //pad response function  for outer sector  
-  AliTPCPRF2D * fOuter2PRF; 
-  AliTPCRF1D  * fTimeRF;           //time response function object
-  Float_t      fFacSigmaPadRow;    //factor-how many sigma of response I accept
-  Float_t      fFacSigmaPad;       //factor-how many sigma of response I accept
-  Float_t      fFacSigmaTime;      //factor-how many sigma of response I accept
+  AliTPCPRF2D * fInnerPRF;         ///< pad response function  for inner sector
+  AliTPCPRF2D * fOuter1PRF;        ///< pad response function  for outer sector
+  AliTPCPRF2D * fOuter2PRF;
+  AliTPCRF1D  * fTimeRF;           ///< time response function object
+  Float_t      fFacSigmaPadRow;    ///< factor-how many sigma of response I accept
+  Float_t      fFacSigmaPad;       ///< factor-how many sigma of response I accept
+  Float_t      fFacSigmaTime;      ///< factor-how many sigma of response I accept
 
 private:
   AliTPCParamSR(const AliTPCParamSR &param); // copy constructor
   AliTPCParamSR &operator = (const AliTPCParamSR & param); //assignment operator
 
+  /// \cond CLASSIMP
   ClassDef(AliTPCParamSR,2)  //parameter  object for set:TPC
+  /// \endcond
 };
 
-#endif  
+#endif
 
 
 
diff --git a/TPC/TPCbase/AliTPCPointCorrection.cxx b/TPC/TPCbase/AliTPCPointCorrection.cxx
index 28afd3c17fd..d4590989dcb 100644
--- a/TPC/TPCbase/AliTPCPointCorrection.cxx
+++ b/TPC/TPCbase/AliTPCPointCorrection.cxx
@@ -1,3 +1,5 @@
+/// \class AliTPCPointCorrection
+
 /**************************************************************************
  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  *                                                                        *
@@ -13,19 +15,19 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/*  
-  
+/*
+
   Unlinearities fitting:
 
   Model for Outer field cage:
   Unlinearities at the edge aproximated using two exponential decays.
- 
-  dz = dz0(r,z) +dr(r,z)*tan(theta) 
+
+  dz = dz0(r,z) +dr(r,z)*tan(theta)
   dy =          +dr(r,z)*tan(phi)
 
-   
-  
-    
+
+
+
 */
 
 #include "AliTPCcalibDB.h"
@@ -44,7 +46,9 @@
 
 AliTPCPointCorrection* AliTPCPointCorrection::fgInstance = 0;
 
+/// \cond CLASSIMP
 ClassImp(AliTPCPointCorrection)
+/// \endcond
 
 AliTPCPointCorrection::AliTPCPointCorrection():
   TNamed(),
@@ -59,12 +63,12 @@ AliTPCPointCorrection::AliTPCPointCorrection():
   fXmiddle(0),
   fXquadrant(0),
   fArraySectorIntParam(36), // array of sector alignment parameters
-  fArraySectorIntCovar(36), // array of sector alignment covariances 
+  fArraySectorIntCovar(36), // array of sector alignment covariances
   //
   // Kalman filter for global alignment
   //
-  fSectorParam(0),     // Kalman parameter   
-  fSectorCovar(0)     // Kalman covariance  
+  fSectorParam(0),     // Kalman parameter
+  fSectorCovar(0)     // Kalman covariance
 
 {
   //
@@ -85,23 +89,22 @@ AliTPCPointCorrection::AliTPCPointCorrection(const Text_t *name, const Text_t *t
   fErrorsOutZ(38),
   fParamOutZVersion(0),
   //
-  // 
+  //
   //
   fXIO(0),
   fXmiddle(0),
   fXquadrant(0),
   fArraySectorIntParam(36), // array of sector alignment parameters
-  fArraySectorIntCovar(36), // array of sector alignment covariances 
+  fArraySectorIntCovar(36), // array of sector alignment covariances
   //
   // Kalman filter for global alignment
   //
   fSectorParam(0),     // Kalman parameter   for A side
-  fSectorCovar(0)     // Kalman covariance  for A side 
-  
+  fSectorCovar(0)     // Kalman covariance  for A side
+
 {
-  //
-  // Non default constructor
-  //
+  /// Non default constructor
+
   AliTPCROC * roc = AliTPCROC::Instance();
   fXquadrant = roc->GetPadRowRadii(36,53);
   fXmiddle   = ( roc->GetPadRowRadii(0,0)+roc->GetPadRowRadii(36,roc->GetNRows(36)-1))*0.5;
@@ -110,18 +113,16 @@ AliTPCPointCorrection::AliTPCPointCorrection(const Text_t *name, const Text_t *t
 }
 
 AliTPCPointCorrection::~AliTPCPointCorrection(){
-  //
-  //
-  //
+  ///
+
 }
 
 
 AliTPCPointCorrection* AliTPCPointCorrection::Instance()
 {
-  //
-  // Singleton implementation
-  // Returns an instance of this class, it is created if neccessary
-  //
+  /// Singleton implementation
+  /// Returns an instance of this class, it is created if neccessary
+
   if (fgInstance == 0){
     fgInstance = new AliTPCPointCorrection();
   }
@@ -131,17 +132,15 @@ AliTPCPointCorrection* AliTPCPointCorrection::Instance()
 
 
 Double_t AliTPCPointCorrection::GetDrOut(Bool_t isGlobal, Bool_t type, Double_t cx, Double_t cy, Double_t cz, Int_t sector){
-  //
-  //  return radial correction
-  //
+  /// return radial correction
+
   if (fParamOutRVersion==0) return CorrectionOutR0(isGlobal, type,cx,cy,cz,sector);
   return 0;
 }
 
 Double_t      AliTPCPointCorrection::SGetDrOut(Bool_t isGlobal, Bool_t type, Double_t cx, Double_t cy, Double_t cz, Int_t sector){
-  //
-  // return radial correction - static function
-  // 
+  /// return radial correction - static function
+
   return fgInstance->GetDrOut(isGlobal, type,cx,cy,cz,sector);
 }
 
@@ -149,18 +148,16 @@ Double_t      AliTPCPointCorrection::SGetDrOut(Bool_t isGlobal, Bool_t type, Dou
 
 
 Double_t AliTPCPointCorrection::GetDzOut(Bool_t isGlobal, Bool_t type, Double_t cx, Double_t cy, Double_t cz, Int_t sector){
-  //
-  //
-  //
+  ///
+
   if (fParamOutZVersion==0) return CorrectionOutZ0(isGlobal, type,cx,cy,cz,sector);
   return 0;
 }
 
 
 Double_t      AliTPCPointCorrection::SGetDzOut(Bool_t isGlobal, Bool_t type, Double_t cx, Double_t cy, Double_t cz, Int_t sector){
-  //
-  //
-  //
+  ///
+
   return fgInstance->GetDzOut(isGlobal, type,cx,cy,cz,sector);
 }
 
@@ -168,13 +165,13 @@ Double_t      AliTPCPointCorrection::SGetDzOut(Bool_t isGlobal, Bool_t type, Dou
 
 
 Double_t AliTPCPointCorrection::CorrectionOutR0(Bool_t isGlobal, Bool_t type,  Double_t cx, Double_t cy, Double_t cz, Int_t sector){
-  //
-  // return dR correction - for correction version 0 
-  // Parameters:
-  // isGlobal   - is the x in global frame
-  // type       - kTRUE - use sectors - kFALSE - only Side param
-  // cx, cy,cz  - cluster position
-  // sector     - sector number
+  /// return dR correction - for correction version 0
+  /// Parameters:
+  /// isGlobal   - is the x in global frame
+  /// type       - kTRUE - use sectors - kFALSE - only Side param
+  /// cx, cy,cz  - cluster position
+  /// sector     - sector number
+
   if (isGlobal){
     // recalculate sector if in global frame
     Double_t alpha    = TMath::ATan2(cy,cx);
@@ -184,10 +181,10 @@ Double_t AliTPCPointCorrection::CorrectionOutR0(Bool_t isGlobal, Bool_t type,  D
 
   if (type==kFALSE) sector=36+(sector%36>=18);  // side level parameters
   // dout
-  Double_t radius = TMath::Sqrt(cx*cx+cy*cy);  
+  Double_t radius = TMath::Sqrt(cx*cx+cy*cy);
   AliTPCROC * roc = AliTPCROC::Instance();
   Double_t xout = roc->GetPadRowRadiiUp(roc->GetNRows(37)-1);
-  Double_t dout = xout-radius;  
+  Double_t dout = xout-radius;
   if (dout<0) return 0;
   //drift
   Double_t dr   = 0.5 - TMath::Abs(cz/250.);
@@ -196,7 +193,7 @@ Double_t AliTPCPointCorrection::CorrectionOutR0(Bool_t isGlobal, Bool_t type,  D
   TVectorD * vec = GetParamOutR(sector);
   if (!vec) return 0;
   Double_t eout10 = TMath::Exp(-dout/10.);
-  Double_t eout5 = TMath::Exp(-dout/5.);		    
+  Double_t eout5 = TMath::Exp(-dout/5.);
   Double_t eoutp  = (eout10+eout5)*0.5;
   Double_t eoutm  = (eout10-eout5)*0.5;
   //
@@ -211,27 +208,26 @@ Double_t AliTPCPointCorrection::CorrectionOutR0(Bool_t isGlobal, Bool_t type,  D
 }
 
 Double_t AliTPCPointCorrection::RPhiCOGCorrection(Int_t sector, Int_t padrow, Float_t pad, Float_t cy, Float_t y, Float_t z, Float_t ky,Float_t qMax, Float_t threshold){
-  //
-  // Calculates COG corection in RPHI direction
-  // cluster and track position  y is supposed to be corrected before for other effects
-  // (e.g ExB and alignemnt)
-  // Rphi distortion dependeds on the distance to the edge-pad, distance to the wire edge and
-  // relative distance to the center of the pad. Therefore the y position is trnsfromed to the 
-  // pad coordiante frame (correction offset (ExB alignemnt) substracted). 
-  //   
-  // Input parameters:
-  //
-  // sector - sector number - 0-71  - cl.GetDetector()
-  // padrow - padrow number -0-63 -IROC 0-95 OROC - cl->GetRow()
-  // pad    - mean pad number  - cl->GetPad()
-  // cy     - cluster y        - cl->GetY()
-  //  y     - track -or cluster y
-  //  qMax  - cluster max charge - cl-.GetMax()
-  //  threshold - clusterer threshold
-  //
+  /// Calculates COG corection in RPHI direction
+  /// cluster and track position  y is supposed to be corrected before for other effects
+  /// (e.g ExB and alignemnt)
+  /// Rphi distortion dependeds on the distance to the edge-pad, distance to the wire edge and
+  /// relative distance to the center of the pad. Therefore the y position is trnsfromed to the
+  /// pad coordiante frame (correction offset (ExB alignemnt) substracted).
+  ///
+  /// Input parameters:
+  ///
+  /// sector - sector number - 0-71  - cl.GetDetector()
+  /// padrow - padrow number -0-63 -IROC 0-95 OROC - cl->GetRow()
+  /// pad    - mean pad number  - cl->GetPad()
+  /// cy     - cluster y        - cl->GetY()
+  ///  y     - track -or cluster y
+  ///  qMax  - cluster max charge - cl-.GetMax()
+  ///  threshold - clusterer threshold
+
   AliTPCClusterParam * clparam = AliTPCcalibDB::Instance()->GetClusterParam();
   if (!clparam) {
-    AliFatal("TPC OCDB not initialized"); 
+    AliFatal("TPC OCDB not initialized");
     return 0;
   }
   Int_t padtype=0;
@@ -243,10 +239,10 @@ Double_t AliTPCPointCorrection::RPhiCOGCorrection(Int_t sector, Int_t padrow, Fl
   Int_t   npads   =  AliTPCROC::Instance()->GetNPads(sector,padrow);
   Float_t yshift  =  TMath::Abs(cy)-TMath::Abs((-npads*0.5+pad)*padwidth);   // the clusters can be corrected before
                                             // shift to undo correction
-  
+
   y -= yshift*((y>0)?1.:-1.);                             // y in the sector coordinate
   Double_t y0     = npads*0.5*padwidth;
-  Double_t dy     = (TMath::Abs(y0)-TMath::Abs(y))/padwidth-0.5;  // distance to  the center of pad0   
+  Double_t dy     = (TMath::Abs(y0)-TMath::Abs(y))/padwidth-0.5;  // distance to  the center of pad0
   //
   Double_t padcenter = TMath::Nint(dy);
   Double_t sumw=0;
@@ -260,7 +256,7 @@ Double_t AliTPCPointCorrection::RPhiCOGCorrection(Int_t sector, Int_t padrow, Fl
     if (ip<0 &&weight> threshold) weight = threshold;  // this is done in cl finder
     if (weight<0) continue;
     sumw+=weight;
-    sumwi+=weight*(ip);    
+    sumwi+=weight*(ip);
   }
   Double_t result =0;
   if (sumw>0) result = sumwi/sumw;
@@ -272,13 +268,13 @@ Double_t AliTPCPointCorrection::RPhiCOGCorrection(Int_t sector, Int_t padrow, Fl
 
 
 Double_t AliTPCPointCorrection::CorrectionOutZ0(Bool_t isGlobal, Bool_t type,  Double_t cx, Double_t cy, Double_t cz, Int_t sector){
-  //
-  // return dR correction - for correction version 0 
-  // Parameters:
-  // isGlobal   - is the x in global frame
-  // type       - kTRUE - use sectors - kFALSE - only Side param
-  // cx, cy,cz  - cluster position
-  // sector     - sector number
+  /// return dR correction - for correction version 0
+  /// Parameters:
+  /// isGlobal   - is the x in global frame
+  /// type       - kTRUE - use sectors - kFALSE - only Side param
+  /// cx, cy,cz  - cluster position
+  /// sector     - sector number
+
   if (isGlobal){
     // recalculate sector if in global frame
     Double_t alpha    = TMath::ATan2(cy,cx);
@@ -288,7 +284,7 @@ Double_t AliTPCPointCorrection::CorrectionOutZ0(Bool_t isGlobal, Bool_t type,  D
 
   if (type==kFALSE) sector=36+(sector%36>=18);  // side level parameters
   // dout
-  Double_t radius = TMath::Sqrt(cx*cx+cy*cy);  
+  Double_t radius = TMath::Sqrt(cx*cx+cy*cy);
   AliTPCROC * roc = AliTPCROC::Instance();
   Double_t xout = roc->GetPadRowRadiiUp(roc->GetNRows(37)-1);
   Double_t dout = xout-radius;
@@ -300,7 +296,7 @@ Double_t AliTPCPointCorrection::CorrectionOutZ0(Bool_t isGlobal, Bool_t type,  D
   TVectorD * vec = GetParamOutR(sector);
   if (!vec) return 0;
   Double_t eout10 = TMath::Exp(-dout/10.);
-  Double_t eout5 = TMath::Exp(-dout/5.);		    
+  Double_t eout5 = TMath::Exp(-dout/5.);
   Double_t eoutp  = (eout10+eout5)*0.5;
   Double_t eoutm  = (eout10-eout5)*0.5;
   //
@@ -316,12 +312,13 @@ Double_t AliTPCPointCorrection::CorrectionOutZ0(Bool_t isGlobal, Bool_t type,  D
 }
 
 Double_t  AliTPCPointCorrection::GetEdgeQ0(Int_t sector, Int_t padrow, Float_t y){
-  //
+  ///
+
   /* TF1 fexp("fexp","1-exp(-[0]*(x-[1]))",0,20)
           | param [0] | param [1]
      IROC | 4.71413   | 1.39558
      OROC1| 2.11437   | 1.52643
-     OROC2| 2.15082   | 1.53537 
+     OROC2| 2.15082   | 1.53537
   */
 
   Double_t params[2]={100,0};
@@ -347,15 +344,14 @@ Double_t AliTPCPointCorrection::SRPhiCOGCorrection(Int_t sector, Int_t padrow, F
 }
 
 Double_t AliTPCPointCorrection::SGetEdgeQ0(Int_t sector, Int_t padrow, Float_t y){
-  //
-  //
+  ///
+
   return fgInstance->GetEdgeQ0(sector, padrow, y);
 }
 
 void     AliTPCPointCorrection::AddCorrectionSector(TObjArray & sideAPar, TObjArray &sideCPar, TObjArray & sideACov, TObjArray &sideCCov, Bool_t reset){
-  //
-  //
-  //
+  ///
+
   for (Int_t isec=0;isec<36;isec++){
     TMatrixD * mat1 = (TMatrixD*)(sideAPar.At(isec));
     TMatrixD * mat1Covar = (TMatrixD*)(sideACov.At(isec));
@@ -363,11 +359,11 @@ void     AliTPCPointCorrection::AddCorrectionSector(TObjArray & sideAPar, TObjAr
     TMatrixD * mat0 = (TMatrixD*)(fArraySectorIntParam.At(isec));
     TMatrixD * mat0Covar = (TMatrixD*)(fArraySectorIntCovar.At(isec));
     if (!mat0) {
-      fArraySectorIntParam.AddAt(mat1->Clone(),isec); 
-      fArraySectorIntCovar.AddAt(mat1Covar->Clone(),isec); 
+      fArraySectorIntParam.AddAt(mat1->Clone(),isec);
+      fArraySectorIntCovar.AddAt(mat1Covar->Clone(),isec);
       continue;
     }
-    (*mat0Covar)=(*mat1Covar);      
+    (*mat0Covar)=(*mat1Covar);
     if (reset)   (*mat0)=(*mat1);
     if (!reset) (*mat0)+=(*mat1);
   }
@@ -379,11 +375,11 @@ void     AliTPCPointCorrection::AddCorrectionSector(TObjArray & sideAPar, TObjAr
     TMatrixD * mat0 = (TMatrixD*)(fArraySectorIntParam.At(isec));
     TMatrixD * mat0Covar = (TMatrixD*)(fArraySectorIntCovar.At(isec));
     if (!mat0) {
-      fArraySectorIntParam.AddAt(mat1->Clone(),isec); 
-      fArraySectorIntCovar.AddAt(mat1Covar->Clone(),isec); 
+      fArraySectorIntParam.AddAt(mat1->Clone(),isec);
+      fArraySectorIntCovar.AddAt(mat1Covar->Clone(),isec);
       continue;
     }
-    (*mat0Covar)=(*mat1Covar);      
+    (*mat0Covar)=(*mat1Covar);
     if (reset)   (*mat0)=(*mat1);
     if (!reset) (*mat0)+=(*mat1);
   }
@@ -391,9 +387,7 @@ void     AliTPCPointCorrection::AddCorrectionSector(TObjArray & sideAPar, TObjAr
 
 
 Double_t AliTPCPointCorrection::GetCorrectionSector(Int_t coord, Int_t sector, Double_t lx, Double_t ly, Double_t /*lz*/, Int_t quadrant){
-  //
-  // Get position correction for given sector
-  //
+  /// Get position correction for given sector
 
   TMatrixD * param = (TMatrixD*)fArraySectorIntParam.At(sector%36);
   if (!param) return 0;
@@ -408,7 +402,7 @@ Double_t AliTPCPointCorrection::GetCorrectionSector(Int_t coord, Int_t sector, D
 	if (ly<0) quadrant=3;
 	if (ly>0) quadrant=4;
       }
-    }    
+    }
   }
   Double_t a10 = (*param)(quadrant*6+0,0);
   Double_t a20 = (*param)(quadrant*6+1,0);
@@ -428,9 +422,8 @@ Double_t AliTPCPointCorrection::GetCorrectionSector(Int_t coord, Int_t sector, D
 }
 
 Double_t AliTPCPointCorrection::SGetCorrectionSector(Int_t coord, Int_t sector, Double_t lx, Double_t ly, Double_t lz, Int_t quadrant){
-  //
-  //
-  //
+  ///
+
   if (!Instance()) return 0;
   return Instance()->GetCorrectionSector(coord,sector,lx,ly,lz, quadrant);
 }
@@ -438,11 +431,10 @@ Double_t AliTPCPointCorrection::SGetCorrectionSector(Int_t coord, Int_t sector,
 
 
 Double_t AliTPCPointCorrection::GetCorrection(Int_t coord, Int_t sector, Double_t lx, Double_t ly, Double_t /*lz*/){
-  //
-  // Get position correction for given sector
-  //
+  /// Get position correction for given sector
+
   if (!fSectorParam) return 0;
-  
+
   Double_t a10 = (*fSectorParam)(sector*6+0,0);
   Double_t a20 = (*fSectorParam)(sector*6+1,0);
   Double_t a21 = (*fSectorParam)(sector*6+2,0);
@@ -461,9 +453,8 @@ Double_t AliTPCPointCorrection::GetCorrection(Int_t coord, Int_t sector, Double_
 }
 
 Double_t AliTPCPointCorrection::SGetCorrection(Int_t coord, Int_t sector, Double_t lx, Double_t ly, Double_t lz){
-  //
-  //
-  //
+  ///
+
   if (!Instance()) return 0;
   return Instance()->GetCorrection(coord,sector,lx,ly,lz);
 }
diff --git a/TPC/TPCbase/AliTPCPointCorrection.h b/TPC/TPCbase/AliTPCPointCorrection.h
index 8a54efac910..dd0e5b03b6b 100644
--- a/TPC/TPCbase/AliTPCPointCorrection.h
+++ b/TPC/TPCbase/AliTPCPointCorrection.h
@@ -1,3 +1,5 @@
+/// \class AliTPCPointCorrection
+
 #ifndef ALITPCPOINTCORRECTION_H
 #define ALITPCPOINTCORRECTION_H
 
@@ -9,13 +11,13 @@
 #include "TObjArray.h"
 #include "TVectorD.h"
 
- 
+
 class AliTPCPointCorrection:public TNamed {
 public:
-  AliTPCPointCorrection(); 
+  AliTPCPointCorrection();
   AliTPCPointCorrection(const Text_t *name, const Text_t *title);
   virtual ~AliTPCPointCorrection();
-  //  
+  //
   TVectorD * GetParamOutR(Int_t sector) {return (TVectorD*)fParamsOutR.At(sector);}
   TVectorD * GetParamOutZ(Int_t sector) {return (TVectorD*)fParamsOutZ.At(sector);}
   //
@@ -24,13 +26,13 @@ public:
 
   static Double_t      SGetDrOut(Bool_t isGlobal, Bool_t type, Double_t cx, Double_t cy, Double_t cz, Int_t sector);
   static Double_t      SGetDzOut(Bool_t isGlobal, Bool_t type, Double_t cx, Double_t cy, Double_t cz, Int_t sector);
-  
+
   static AliTPCPointCorrection* Instance();
   void SetInstance(AliTPCPointCorrection*param){fgInstance = param;}
   //
   Double_t CorrectionOutR0(Bool_t isGlobal, Bool_t type, Double_t cx, Double_t cy, Double_t cz, Int_t sector);
   Double_t CorrectionOutZ0(Bool_t isGlobal, Bool_t type, Double_t cx, Double_t cy, Double_t cz, Int_t sector);
-  
+
   Double_t RPhiCOGCorrection(Int_t sector, Int_t padrow, Float_t pad, Float_t cy, Float_t y, Float_t z, Float_t ky, Float_t qMax, Float_t threhsold);
   Double_t SRPhiCOGCorrection(Int_t sector, Int_t padrow, Float_t pad, Float_t cy, Float_t y, Float_t z, Float_t ky,  Float_t qMax, Float_t threhsold);
   //
@@ -40,51 +42,53 @@ public:
   // IROC -OROC+Quadrant alignment
   //
   void     AddCorrectionSector(TObjArray & sideAPar, TObjArray &sideCPar, TObjArray & sideACov, TObjArray &sideCCov, Bool_t reset);
-  Double_t GetCorrectionSector(Int_t coord, Int_t sector, Double_t lx, Double_t ly, Double_t lz, Int_t quadrant =-1); 
-  static Double_t SGetCorrectionSector(Int_t coord, Int_t sector, Double_t lx, Double_t ly, Double_t lz, Int_t quadrant=-1); 
+  Double_t GetCorrectionSector(Int_t coord, Int_t sector, Double_t lx, Double_t ly, Double_t lz, Int_t quadrant =-1);
+  static Double_t SGetCorrectionSector(Int_t coord, Int_t sector, Double_t lx, Double_t ly, Double_t lz, Int_t quadrant=-1);
   //
   // Global alignment
   //
   Double_t GetCorrection(Int_t coord, Int_t sector, Double_t lx, Double_t ly, Double_t lz);
   static Double_t SGetCorrection(Int_t coord, Int_t sector, Double_t lx, Double_t ly, Double_t lz);
-public: 
+public:
   //
   // Correction out
   //
-  TObjArray   fParamsOutR;       // Parameters  for radial distortion  - outer field cage
-  TObjArray   fParamsOutZ;       // Parameters  for z      distortion  - outer field cage
-  Int_t       fParamOutRVersion;  // version of the parameterization
-  TObjArray   fErrorsOutR;       // Parameters  for radial distortion  - outer field cage
-  TObjArray   fErrorsOutZ;       // Parameters  for z      distortion  - outer field cage
-  Int_t       fParamOutZVersion;  // version of the parameterization
+  TObjArray   fParamsOutR;       ///< Parameters  for radial distortion  - outer field cage
+  TObjArray   fParamsOutZ;       ///< Parameters  for z      distortion  - outer field cage
+  Int_t       fParamOutRVersion;  ///< version of the parameterization
+  TObjArray   fErrorsOutR;       ///< Parameters  for radial distortion  - outer field cage
+  TObjArray   fErrorsOutZ;       ///< Parameters  for z      distortion  - outer field cage
+  Int_t       fParamOutZVersion;  ///< version of the parameterization
   //
   //  Edge rfi
-  // 
+  //
   //
   // Alignment part
   //
-  Double_t fXIO;               // OROC-IROC boundary
-  Double_t fXmiddle;           // center of the TPC sector local X
-  Double_t fXquadrant;         // x quadrant
+  Double_t fXIO;               ///< OROC-IROC boundary
+  Double_t fXmiddle;           ///< center of the TPC sector local X
+  Double_t fXquadrant;         ///< x quadrant
   //
   // IROC OROC alignment
   //
-  TObjArray fArraySectorIntParam; // array of sector alignment parameters
-  TObjArray fArraySectorIntCovar; // array of sector alignment covariances 
+  TObjArray fArraySectorIntParam; ///< array of sector alignment parameters
+  TObjArray fArraySectorIntCovar; ///< array of sector alignment covariances
   //
   // Kalman filter for global alignment
   //
-  TMatrixD  *fSectorParam;     // Kalman parameter   
-  TMatrixD  *fSectorCovar;     // Kalman covariance  
+  TMatrixD  *fSectorParam;     ///< Kalman parameter
+  TMatrixD  *fSectorCovar;     ///< Kalman covariance
   //
   //
   //
 private:
 
-  AliTPCPointCorrection(const AliTPCPointCorrection&); 
-  AliTPCPointCorrection& operator=(const AliTPCPointCorrection&); 
-  static AliTPCPointCorrection*   fgInstance; //! Instance of this class (singleton implementation)
-  ClassDef(AliTPCPointCorrection, 3); 
+  AliTPCPointCorrection(const AliTPCPointCorrection&);
+  AliTPCPointCorrection& operator=(const AliTPCPointCorrection&);
+  static AliTPCPointCorrection*   fgInstance; //!< Instance of this class (singleton implementation)
+  /// \cond CLASSIMP
+  ClassDef(AliTPCPointCorrection, 3);
+  /// \endcond
 };
 
 #endif
diff --git a/TPC/TPCbase/AliTPCPreprocessor.cxx b/TPC/TPCbase/AliTPCPreprocessor.cxx
index 8a303ef61bc..bdf0b3770fa 100644
--- a/TPC/TPCbase/AliTPCPreprocessor.cxx
+++ b/TPC/TPCbase/AliTPCPreprocessor.cxx
@@ -1,3 +1,5 @@
+/// \class AliTPCPreprocessor
+
 /**************************************************************************
  * Copyright(c) 2007, ALICE Experiment at CERN, All rights reserved.      *
  *                                                                        *
@@ -32,47 +34,49 @@
 #include "ARVersion.h"
 #include "TFile.h"
 #include "TTree.h"
-#include "TGraph.h" 
+#include "TGraph.h"
 #include "TEnv.h"
 #include "TParameter.h"
 
 #include <TTimeStamp.h>
 
-const Int_t kValCutTemp = 100;               // discard temperatures > 100 degrees
-const Int_t kDiffCutTemp = 5;	             // discard temperature differences > 5 degrees
-const Double_t kHighVoltageDifference = 1e-4; // don't record High Voltage points 
+const Int_t kValCutTemp = 100;               ///< discard temperatures > 100 degrees
+const Int_t kDiffCutTemp = 5;	             ///< discard temperature differences > 5 degrees
+const Double_t kHighVoltageDifference = 1e-4; ///< don't record High Voltage points
                                              // differing by less than 1e-4 from
 					     // previous point.
-const Double_t kGasCompositionDifference = 1e-3; // don't record Gas Composition points 
+const Double_t kGasCompositionDifference = 1e-3; ///< don't record Gas Composition points
                                              // differing by less than 1e-3 from
 					     // previous point
-const TString kPedestalRunType = "PEDESTAL";  // pedestal run identifier
-const TString kPulserRunType = "PULSER";     // pulser run identifier
-const TString kPhysicsRunType = "PHYSICS";   // physics run identifier
-const TString kCosmicRunType = "COSMIC";     // cosmic run identifier
-const TString kLaserRunType = "LASER";       // laser run identifier
-const TString kDaqRunType = "DAQ"; 	     // DAQ run identifier
-const TString kStandaloneRunType = "STANDALONE";  // STANDALONE run identifier
-const TString kAmandaTemp = "TPC_PT_%d_TEMPERATURE"; // Amanda string for temperature entries
-const TString kAmandaDDL = "DDL%d";   // Amanda string for list of active DDLs
-const Int_t  kNumDDL = 216;           // number of TPC DDLs
-const Int_t  kFirstDDL = 768;         // identifier of first DDL
-//const Double_t kFitFraction = 0.7;                 // Fraction of DCS sensor fits required              
-const Double_t kFitFraction = -1.0;          // Don't require minimum number of fits in commissioning run 
-const Int_t   kNumPressureSensors = 3;    // number of pressure sensors
+const TString kPedestalRunType = "PEDESTAL";  ///< pedestal run identifier
+const TString kPulserRunType = "PULSER";     ///< pulser run identifier
+const TString kPhysicsRunType = "PHYSICS";   ///< physics run identifier
+const TString kCosmicRunType = "COSMIC";     ///< cosmic run identifier
+const TString kLaserRunType = "LASER";       ///< laser run identifier
+const TString kDaqRunType = "DAQ";           ///< DAQ run identifier
+const TString kStandaloneRunType = "STANDALONE";  ///< STANDALONE run identifier
+const TString kAmandaTemp = "TPC_PT_%d_TEMPERATURE"; ///< Amanda string for temperature entries
+const TString kAmandaDDL = "DDL%d";   ///< Amanda string for list of active DDLs
+const Int_t  kNumDDL = 216;           ///< number of TPC DDLs
+const Int_t  kFirstDDL = 768;         ///< identifier of first DDL
+//const Double_t kFitFraction = 0.7;                 // Fraction of DCS sensor fits required
+const Double_t kFitFraction = -1.0;          ///< Don't require minimum number of fits in commissioning run
+const Int_t   kNumPressureSensors = 3;    ///< number of pressure sensors
 const char* kPressureSensorNames[kNumPressureSensors] = {
                    "CavernAtmosPressure",
                    "CavernAtmosPressure2",
                    "SurfaceAtmosPressure" };
-const Int_t  kMinCESectors = 32;      // minimum number of sectors (per side)
+const Int_t  kMinCESectors = 32;      ///< minimum number of sectors (per side)
                                       // to accept CE calibration
-      
+
 
 //
 // This class is the SHUTTLE preprocessor for the TPC detector.
 //
 
+/// \cond CLASSIMP
 ClassImp(AliTPCPreprocessor)
+/// \endcond
 
 //______________________________________________________________________________________________
 AliTPCPreprocessor::AliTPCPreprocessor(AliShuttleInterface* shuttle) :
@@ -84,7 +88,7 @@ AliTPCPreprocessor::AliTPCPreprocessor(AliShuttleInterface* shuttle) :
   fROC = AliTPCROC::Instance();
 
   // define run types to be processed
-  
+
   AddRunType(kPedestalRunType);
   AddRunType(kPulserRunType);
   AddRunType(kPhysicsRunType);
@@ -92,7 +96,6 @@ AliTPCPreprocessor::AliTPCPreprocessor(AliShuttleInterface* shuttle) :
   AddRunType(kLaserRunType);
   AddRunType(kDaqRunType);
   AddRunType(kStandaloneRunType);
-  
 }
 //______________________________________________________________________________________________
  AliTPCPreprocessor::AliTPCPreprocessor(const AliTPCPreprocessor&  ) :
@@ -109,7 +112,7 @@ AliTPCPreprocessor::AliTPCPreprocessor(AliShuttleInterface* shuttle) :
 //______________________________________________________________________________________________
 AliTPCPreprocessor::~AliTPCPreprocessor()
 {
-  // destructor
+  /// destructor
 
   delete fTemp;
   delete fHighVoltage;
@@ -170,7 +173,7 @@ void AliTPCPreprocessor::Initialize(Int_t run, UInt_t startTime,
 
       TString hvConf = fConfEnv->GetValue("HighVoltage","ON");
       hvConf.ToUpper();
-      if (hvConf != "OFF" ) { 
+      if (hvConf != "OFF" ) {
         confTree=0;
         entry=0;
         entry = GetFromOCDB("Config", "HighVoltage");
@@ -182,15 +185,15 @@ void AliTPCPreprocessor::Initialize(Int_t run, UInt_t startTime,
         }
         time_t timeStart = (time_t)(((TString)GetRunParameter("DAQ_time_start")).Atoi());
 	time_t timeEnd = (time_t)(((TString)GetRunParameter("DAQ_time_end")).Atoi());
-        fHighVoltage = new AliDCSSensorArray (UInt_t(timeStart), 
+        fHighVoltage = new AliDCSSensorArray (UInt_t(timeStart),
 	                                    UInt_t(timeEnd), confTree);
       }
 
    // High voltage status values
-     
+
       TString hvStatConf = fConfEnv->GetValue("HighVoltageStat","ON");
       hvStatConf.ToUpper();
-      if (hvStatConf != "OFF" ) { 
+      if (hvStatConf != "OFF" ) {
         confTree=0;
         entry=0;
         entry = GetFromOCDB("Config", "HighVoltageStat");
@@ -204,10 +207,10 @@ void AliTPCPreprocessor::Initialize(Int_t run, UInt_t startTime,
       }
 
    // Goofie values
-     
+
       TString goofieConf = fConfEnv->GetValue("Goofie","ON");
       goofieConf.ToUpper();
-      if (goofieConf != "OFF" ) { 
+      if (goofieConf != "OFF" ) {
         confTree=0;
         entry=0;
         entry = GetFromOCDB("Config", "Goofie");
@@ -225,7 +228,7 @@ void AliTPCPreprocessor::Initialize(Int_t run, UInt_t startTime,
 
       TString gasConf = fConfEnv->GetValue("GasComposition","OFF");
       gasConf.ToUpper();
-      if (gasConf != "OFF" ) { 
+      if (gasConf != "OFF" ) {
         confTree=0;
         entry=0;
         entry = GetFromOCDB("Config", "GasComposition");
@@ -237,19 +240,19 @@ void AliTPCPreprocessor::Initialize(Int_t run, UInt_t startTime,
         }
         time_t timeStart = (time_t)(((TString)GetRunParameter("DAQ_time_start")).Atoi());
 	time_t timeEnd = (time_t)(((TString)GetRunParameter("DAQ_time_end")).Atoi());
-        fGasComposition = new AliDCSSensorArray (UInt_t(timeStart), 
+        fGasComposition = new AliDCSSensorArray (UInt_t(timeStart),
 	                                    UInt_t(timeEnd), confTree);
       }
    // Pressure values
-     
+
        TString runType = GetRunType();
 
-       if( runType == kPhysicsRunType || 
-        runType == kLaserRunType ) {    
+       if( runType == kPhysicsRunType ||
+        runType == kLaserRunType ) {
        TString pressureConf = fConfEnv->GetValue("Pressure","ON");
        pressureConf.ToUpper();
-       if (pressureConf != "OFF" ) { 
-         TClonesArray * array = new TClonesArray("AliDCSSensor",kNumPressureSensors); 
+       if (pressureConf != "OFF" ) {
+         TClonesArray * array = new TClonesArray("AliDCSSensor",kNumPressureSensors);
          for(Int_t j = 0; j < kNumPressureSensors; j++) {
            AliDCSSensor * sens = new ((*array)[j])AliDCSSensor;
            sens->SetStringID(kPressureSensorNames[j]);
@@ -262,11 +265,11 @@ void AliTPCPreprocessor::Initialize(Int_t run, UInt_t startTime,
 //______________________________________________________________________________________________
 UInt_t AliTPCPreprocessor::Process(TMap* dcsAliasMap)
 {
-  // Fills data into TPC calibrations objects
+  /// Fills data into TPC calibrations objects
 
   // Amanda servers provide information directly through dcsAliasMap
 
-  
+
   if (!fConfigOK) return 9;
   UInt_t result = 0;
   TObjArray *resultArray = new TObjArray();
@@ -275,11 +278,11 @@ UInt_t AliTPCPreprocessor::Process(TMap* dcsAliasMap)
   TObject * status;
 
   UInt_t dcsResult=0;
-  if (!dcsAliasMap) { 
+  if (!dcsAliasMap) {
      dcsResult=1;
   } else {
      if (dcsAliasMap->GetEntries() == 0 ) dcsResult=1;
-  }  
+  }
   status = new TParameter<int>("dcsResult",dcsResult);
   resultArray->Add(status);
 
@@ -304,7 +307,7 @@ UInt_t AliTPCPreprocessor::Process(TMap* dcsAliasMap)
 
     TString hvConf = fConfEnv->GetValue("HighVoltage","ON");
     hvConf.ToUpper();
-    if (hvConf != "OFF" ) { 
+    if (hvConf != "OFF" ) {
      UInt_t hvResult = MapHighVoltage(dcsAliasMap);
      if (hvConf != "TRY") result+=hvResult;
      status = new TParameter<int>("hvResult",hvResult);
@@ -316,7 +319,7 @@ UInt_t AliTPCPreprocessor::Process(TMap* dcsAliasMap)
 
     TString goofieConf = fConfEnv->GetValue("Goofie","ON");
     goofieConf.ToUpper();
-    if (goofieConf != "OFF" ) { 
+    if (goofieConf != "OFF" ) {
      UInt_t goofieResult = MapGoofie(dcsAliasMap);
      if (goofieConf != "TRY") result+=goofieResult;
      status = new TParameter<int>("goofieResult",goofieResult);
@@ -329,7 +332,7 @@ UInt_t AliTPCPreprocessor::Process(TMap* dcsAliasMap)
 
     TString gasConf = fConfEnv->GetValue("GasComposition","OFF");
     gasConf.ToUpper();
-    if (gasConf != "OFF" ) { 
+    if (gasConf != "OFF" ) {
      UInt_t gasResult = MapGasComposition(dcsAliasMap);
      if (gasConf != "TRY") result+=gasResult;
      status = new TParameter<int>("gasResult",gasResult);
@@ -343,7 +346,7 @@ UInt_t AliTPCPreprocessor::Process(TMap* dcsAliasMap)
 
       TString pressureConf = fConfEnv->GetValue("Pressure","ON");
       pressureConf.ToUpper();
-      if (pressureConf != "OFF" ) { 
+      if (pressureConf != "OFF" ) {
        UInt_t pressureResult = MapPressure(dcsAliasMap);
        status = new TParameter<int>("pressureResult",pressureResult);
        resultArray->Add(status);
@@ -365,7 +368,7 @@ UInt_t AliTPCPreprocessor::Process(TMap* dcsAliasMap)
     Int_t pedestalSource[2] = {AliShuttleInterface::kDAQ,AliShuttleInterface::kHLT} ;
     TString source = fConfEnv->GetValue("Pedestal","DAQ");
     source.ToUpper();
-    if (source != "OFF" ) { 
+    if (source != "OFF" ) {
      if ( source == "HLT") pedestalSource[0] = AliShuttleInterface::kHLT;
      if (!GetHLTStatus()) pedestalSource[0] = AliShuttleInterface::kDAQ;
      if (source == "HLTDAQ" ) {
@@ -375,7 +378,7 @@ UInt_t AliTPCPreprocessor::Process(TMap* dcsAliasMap)
      }
      if (source == "DAQHLT" ) numSources=2;
      UInt_t pedestalResult=0;
-     for (Int_t i=0; i<numSources; i++ ) {	
+     for (Int_t i=0; i<numSources; i++ ) {
        pedestalResult = ExtractPedestals(pedestalSource[i]);
        if ( pedestalResult == 0 ) break;
      }
@@ -392,7 +395,7 @@ UInt_t AliTPCPreprocessor::Process(TMap* dcsAliasMap)
     Int_t pulserSource[2] = {AliShuttleInterface::kDAQ,AliShuttleInterface::kHLT} ;
     TString source = fConfEnv->GetValue("Pulser","DAQ");
     source.ToUpper();
-    if ( source != "OFF") { 
+    if ( source != "OFF") {
      if ( source == "HLT") pulserSource[0] = AliShuttleInterface::kHLT;
      if (!GetHLTStatus()) pulserSource[0] = AliShuttleInterface::kDAQ;
      if (source == "HLTDAQ" ) {
@@ -403,7 +406,7 @@ UInt_t AliTPCPreprocessor::Process(TMap* dcsAliasMap)
      if (source == "DAQHLT" ) numSources=2;
      if (source == "TRY" ) numSources=1;
      UInt_t pulserResult=0;
-     for (Int_t i=0; i<numSources; i++ ) {	
+     for (Int_t i=0; i<numSources; i++ ) {
        pulserResult = ExtractPulser(pulserSource[i]);
        if ( pulserResult == 0 ) break;
      }
@@ -421,7 +424,7 @@ UInt_t AliTPCPreprocessor::Process(TMap* dcsAliasMap)
     Int_t rawSource[2] = {AliShuttleInterface::kDAQ,AliShuttleInterface::kHLT} ;
     TString source = fConfEnv->GetValue("Raw","DAQ");
     source.ToUpper();
-    if ( source != "OFF") { 
+    if ( source != "OFF") {
      if ( source == "HLT") rawSource[0] = AliShuttleInterface::kHLT;
      if (!GetHLTStatus()) rawSource[0] = AliShuttleInterface::kDAQ;
      if (source == "HLTDAQ" ) {
@@ -432,7 +435,7 @@ UInt_t AliTPCPreprocessor::Process(TMap* dcsAliasMap)
      if (source == "DAQHLT" ) numSources=2;
      if (source == "TRY" ) numSources=1;
      UInt_t rawResult=0;
-     for (Int_t i=0; i<numSources; i++ ) {	
+     for (Int_t i=0; i<numSources; i++ ) {
        rawResult = ExtractRaw(rawSource[i]);
        if ( rawResult == 0 ) break;
      }
@@ -448,7 +451,7 @@ UInt_t AliTPCPreprocessor::Process(TMap* dcsAliasMap)
 
   TString altroConf = fConfEnv->GetValue("AltroConf","ON");
   altroConf.ToUpper();
-  if (altroConf != "OFF" ) { 
+  if (altroConf != "OFF" ) {
    UInt_t altroResult = ExtractAltro(AliShuttleInterface::kDCS,dcsAliasMap);
    if (altroConf != "TRY" ) result+=altroResult;
    status = new TParameter<int>("altroResult",altroResult);
@@ -458,14 +461,14 @@ UInt_t AliTPCPreprocessor::Process(TMap* dcsAliasMap)
 
   // Central Electrode processing
 
-  if( runType == kPhysicsRunType || 
-      runType == kLaserRunType ) {    
+  if( runType == kPhysicsRunType ||
+      runType == kLaserRunType ) {
 
     Int_t numSources = 1;
     Int_t ceSource[2] = {AliShuttleInterface::kDAQ,AliShuttleInterface::kHLT} ;
     TString source = fConfEnv->GetValue("CE","DAQ");
     source.ToUpper();
-    if ( source != "OFF" ) { 
+    if ( source != "OFF" ) {
      if ( source == "HLT") ceSource[0] = AliShuttleInterface::kHLT;
      if (!GetHLTStatus()) ceSource[0] = AliShuttleInterface::kDAQ;
      if (source == "HLTDAQ" ) {
@@ -476,14 +479,14 @@ UInt_t AliTPCPreprocessor::Process(TMap* dcsAliasMap)
      if (source == "DAQHLT" ) numSources=2;
      if (source == "TRY" ) numSources=1;
      UInt_t ceResult=0;
-     for (Int_t i=0; i<numSources; i++ ) {	
+     for (Int_t i=0; i<numSources; i++ ) {
        ceResult = ExtractCE(ceSource[i]);
        if ( ceResult == 0 ) break;
      }
 
    // only flag error if CE result is missing from LASER runs
    //    -- for PHYSICS run do CE processing if data available
-   
+
      if ( runType == kLaserRunType && source != "TRY"  && ceResult<10 ) result += ceResult;
      status = new TParameter<int>("ceResult",ceResult);
      resultArray->Add(status);
@@ -492,7 +495,7 @@ UInt_t AliTPCPreprocessor::Process(TMap* dcsAliasMap)
     Int_t qaSource[2] = {AliShuttleInterface::kDAQ,AliShuttleInterface::kHLT} ;
     source = fConfEnv->GetValue("QA","DAQ");
     source.ToUpper();
-    if ( source != "OFF" ) { 
+    if ( source != "OFF" ) {
      if ( source == "HLT") qaSource[0] = AliShuttleInterface::kHLT;
      if (!GetHLTStatus()) qaSource[0] = AliShuttleInterface::kDAQ;
      if (source == "HLTDAQ" ) {
@@ -503,7 +506,7 @@ UInt_t AliTPCPreprocessor::Process(TMap* dcsAliasMap)
      if (source == "DAQHLT" ) numSources=2;
      if (source == "TRY" ) numSources=1;
      UInt_t qaResult=0;
-     for (Int_t i=0; i<numSources; i++ ) {	
+     for (Int_t i=0; i<numSources; i++ ) {
        qaResult = ExtractQA(qaSource[i]);
        if ( qaResult == 0 ) break;
      }
@@ -514,7 +517,7 @@ UInt_t AliTPCPreprocessor::Process(TMap* dcsAliasMap)
     }
    }
   }
-  
+
 // Store component status to OCDB
 
   AliCDBMetaData metaData;
@@ -524,28 +527,28 @@ UInt_t AliTPCPreprocessor::Process(TMap* dcsAliasMap)
   metaData.SetComment("Preprocessor AliTPC status.");
   Bool_t storeOK = Store("Calib", "PreprocStatus", resultArray, &metaData, 0,  kFALSE);
   if (!storeOK) Log ("Unable to store preprocessor status entry");
- 
+
   resultArray->Delete();
   delete resultArray;
 
   if (errorHandling == "OFF" ) return 0;
   return result;
-  
+
 }
 //______________________________________________________________________________________________
 UInt_t AliTPCPreprocessor::MapTemperature(TMap* dcsAliasMap)
 {
 
-   // extract DCS temperature maps. Perform fits to save space
+   /// extract DCS temperature maps. Perform fits to save space
 
   UInt_t result=0;
   TMap *map = fTemp->ExtractDCS(dcsAliasMap);
   if (map) {
     fTemp->MakeSplineFit(map);
-    Double_t fitFraction = 1.0*fTemp->NumFits()/fTemp->NumSensors(); 
+    Double_t fitFraction = 1.0*fTemp->NumFits()/fTemp->NumSensors();
     if (fitFraction > kFitFraction ) {
       AliInfo(Form("Temperature values extracted, fits performed.\n"));
-    } else { 
+    } else {
       Log ("Too few temperature maps fitted. \n");
       result = 9;
     }
@@ -575,16 +578,16 @@ UInt_t AliTPCPreprocessor::MapTemperature(TMap* dcsAliasMap)
 UInt_t AliTPCPreprocessor::MapPressure(TMap* dcsAliasMap)
 {
 
-   // extract DCS pressure maps. Perform fits to save space
+   /// extract DCS pressure maps. Perform fits to save space
 
   UInt_t result=0;
   TMap *map = fPressure->ExtractDCS(dcsAliasMap);
   if (map) {
     fPressure->MakeSplineFit(map);
-    Double_t fitFraction = 1.0*fPressure->NumFits()/fPressure->NumSensors(); 
+    Double_t fitFraction = 1.0*fPressure->NumFits()/fPressure->NumSensors();
     if (fitFraction > kFitFraction ) {
       AliInfo(Form("Pressure values extracted, fits performed.\n"));
-    } else { 
+    } else {
       Log ("Too few pressure maps fitted. \n");
       result = 9;
     }
@@ -600,7 +603,7 @@ UInt_t AliTPCPreprocessor::MapPressure(TMap* dcsAliasMap)
 UInt_t AliTPCPreprocessor::MapHighVoltage(TMap* dcsAliasMap)
 {
 
-   // extract DCS HV maps. Perform fits to save space
+   /// extract DCS HV maps. Perform fits to save space
 
   UInt_t result=0;
   TMap *map = fHighVoltage->ExtractDCS(dcsAliasMap);
@@ -617,7 +620,7 @@ UInt_t AliTPCPreprocessor::MapHighVoltage(TMap* dcsAliasMap)
 
   TString hvStatConf = fConfEnv->GetValue("HighVoltageStat","ON");
   hvStatConf.ToUpper();
-  if (hvStatConf != "OFF" ) { 
+  if (hvStatConf != "OFF" ) {
     TMap *map2 = fHighVoltageStat->ExtractDCS(dcsAliasMap);
     if (map2) {
       fHighVoltageStat->ClearFit();
@@ -654,7 +657,7 @@ UInt_t AliTPCPreprocessor::MapHighVoltage(TMap* dcsAliasMap)
 UInt_t AliTPCPreprocessor::MapGoofie(TMap* dcsAliasMap)
 {
 
-   // extract DCS Goofie maps. Do not perform fits (low update rate)
+   /// extract DCS Goofie maps. Do not perform fits (low update rate)
 
   UInt_t result=0;
 
@@ -690,7 +693,7 @@ UInt_t AliTPCPreprocessor::MapGoofie(TMap* dcsAliasMap)
 UInt_t AliTPCPreprocessor::MapGasComposition(TMap* dcsAliasMap)
 {
 
-   // extract DCS HV maps. Perform fits to save space
+   /// extract DCS HV maps. Perform fits to save space
 
   UInt_t result=0;
   TMap *map = fGasComposition->ExtractDCS(dcsAliasMap);
@@ -728,10 +731,9 @@ UInt_t AliTPCPreprocessor::MapGasComposition(TMap* dcsAliasMap)
 
 UInt_t AliTPCPreprocessor::ExtractPedestals(Int_t sourceFXS)
 {
- //
- //  Read pedestal file from file exchage server
- //  Keep original entry from OCDB in case no new pedestals are available
- //
+ /// Read pedestal file from file exchage server
+ /// Keep original entry from OCDB in case no new pedestals are available
+
  AliTPCCalPad *calPadPedOCDB=0;
  AliCDBEntry* entry = GetFromOCDB("Calib", "Pedestals");
  if (entry) calPadPedOCDB = (AliTPCCalPad*)entry->GetObject();
@@ -759,7 +761,7 @@ UInt_t AliTPCPreprocessor::ExtractPedestals(Int_t sourceFXS)
  foundSectorsRMS=0;
 
  TList* list = GetFileSources(sourceFXS,"pedestals");
- 
+
  if (list && list->GetEntries()>0) {
 
 //  loop through all files from LDCs
@@ -800,9 +802,9 @@ UInt_t AliTPCPreprocessor::ExtractPedestals(Int_t sourceFXS)
                AliTPCCalROC* roc=calPadRMS->GetCalROC(sector);
 	       roc->Add(rocRMS,1);
 	       foundSectorsRMS[sector]++;
-	   } 
+	   }
         }
-        delete calPed; 
+        delete calPed;
         f->Close();
       }
      ++index;
@@ -837,7 +839,7 @@ UInt_t AliTPCPreprocessor::ExtractPedestals(Int_t sourceFXS)
 	             sector);
 	    Log (message);
 	    result = 2;
-	  }       
+	  }
        }
     }
 
@@ -869,12 +871,12 @@ UInt_t AliTPCPreprocessor::ExtractPedestals(Int_t sourceFXS)
 	             sector);
 	    Log (message);
 	    result = 2;
-	  }       
+	  }
 
-       }       
+       }
     }
 
-    
+
 //
 //  Store updated pedestal entry to OCDB
 //
@@ -883,8 +885,8 @@ UInt_t AliTPCPreprocessor::ExtractPedestals(Int_t sourceFXS)
      metaData.SetBeamPeriod(0);
      metaData.SetResponsible("Haavard Helstrup");
      metaData.SetAliRootVersion(ALIROOT_BRANCH);
-     metaData.SetComment("Preprocessor AliTPC data base entries."); 
- 
+     metaData.SetComment("Preprocessor AliTPC data base entries.");
+
      Bool_t storeOK = Store("Calib", "Pedestals", calPadPed, &metaData, 0, kTRUE);
      if ( !storeOK ) ++result;
      storeOK = Store("Calib", "PadNoise", calPadRMS, &metaData, 0, kTRUE);
@@ -908,14 +910,12 @@ UInt_t AliTPCPreprocessor::ExtractPedestals(Int_t sourceFXS)
 
 UInt_t AliTPCPreprocessor::ExtractPulser(Int_t sourceFXS)
 {
- //
- //  Read pulser calibration file from file exchage server
- //  Keep original entry from OCDB in case no new pulser calibration is available
- //
- 
+ /// Read pulser calibration file from file exchage server
+ /// Keep original entry from OCDB in case no new pulser calibration is available
+
  TObjArray *pulserObjects = new TObjArray;
- TObjArray *pulserObjectsOCDB=0;   
-  
+ TObjArray *pulserObjectsOCDB=0;
+
  AliCDBEntry* entry = GetFromOCDB("Calib", "Pulser");
  if (entry) pulserObjectsOCDB = (TObjArray*)entry->GetObject();
  if ( pulserObjectsOCDB==NULL ) {
@@ -924,13 +924,13 @@ UInt_t AliTPCPreprocessor::ExtractPulser(Int_t sourceFXS)
 
  AliTPCCalPad *pulserTmean = new AliTPCCalPad("PulserTmean","PulserTmean");
  pulserObjects->Add(pulserTmean);
- 
+
  AliTPCCalPad *pulserTrms = new AliTPCCalPad("PulserTrms","PulserTrms");
  pulserObjects->Add(pulserTrms);
- 
+
  AliTPCCalPad *pulserQmean = new AliTPCCalPad("PulserQmean","PulserQmean");
  pulserObjects->Add(pulserQmean);
- 
+
 
 
  UInt_t result=0;
@@ -945,7 +945,7 @@ UInt_t AliTPCPreprocessor::ExtractPulser(Int_t sourceFXS)
 
 
  TList* list = GetFileSources(sourceFXS,"pulser");
- 
+
  if (list && list->GetEntries()>0) {
 
 //  loop through all files from LDCs
@@ -1007,7 +1007,7 @@ if (pulserObjectsOCDB) {
   AliTPCCalPad* pulserTmeanOCDB = (AliTPCCalPad*)pulserObjectsOCDB->FindObject("PulserTmean");
   AliTPCCalPad* pulserTrmsOCDB  = (AliTPCCalPad*)pulserObjectsOCDB->FindObject("PulserTrms");
   AliTPCCalPad* pulserQmeanOCDB = (AliTPCCalPad*)pulserObjectsOCDB->FindObject("PulserQmean");
- 
+
 //
 //  Check if calibration is complete -- otherwise take from old OCDB entry
 
@@ -1032,7 +1032,7 @@ if (pulserObjectsOCDB) {
          }
        }
     }
-  
+
 // outer sectors -- two updates needed
 
     for (Int_t sector=0; sector<nSectors/2; sector++) {
@@ -1070,7 +1070,7 @@ if (pulserObjectsOCDB) {
 
      Bool_t storeOK = Store("Calib", "Pulser", pulserObjects, &metaData, 0, kTRUE);
      if ( !storeOK ) ++result;
-    }  
+    }
   } else {
     Log ("Error: no entries in pulser file list!");
     result = 1;
@@ -1088,15 +1088,13 @@ if (pulserObjectsOCDB) {
 
 UInt_t AliTPCPreprocessor::ExtractRaw(Int_t sourceFXS)
 {
- //
- //  Read Raw calibration file from file exchage server
- //
- 
+ /// Read Raw calibration file from file exchage server
+
  UInt_t result=0;
  TObjArray* rawArray = new TObjArray;
 
  TList* list = GetFileSources(sourceFXS,"tpcCalibRaw");
- 
+
  if (list && list->GetEntries()>0) {
 
 //  loop through all files
@@ -1140,7 +1138,7 @@ UInt_t AliTPCPreprocessor::ExtractRaw(Int_t sourceFXS)
     Log ("Error: no entries in raw file list!");
     result = 1;
   }
-  
+
   rawArray->Delete();
   delete rawArray;
 
@@ -1150,34 +1148,32 @@ UInt_t AliTPCPreprocessor::ExtractRaw(Int_t sourceFXS)
 
 UInt_t AliTPCPreprocessor::ExtractCE(Int_t sourceFXS)
 {
- //
- //  Read Central Electrode file from file exchage server
- //
- //
+ /// Read Central Electrode file from file exchage server
+
   AliTPCCalPad *ceTmean=0;
   AliTPCCalPad *ceTrms=0;
   AliTPCCalPad *ceQmean=0;
   TObjArray    *rocTtime=0;
   TObjArray    *rocQtime=0;
-  
+
   TObjArray    *ceObjects= new TObjArray;
-  
-  
+
+
   Int_t nSectors = fROC->GetNSectors();
-  
+
   ceTmean = new AliTPCCalPad("CETmean","CETmean");
   ceObjects->Add(ceTmean);
-  
+
   ceTrms = new AliTPCCalPad("CETrms","CETrms");
   ceObjects->Add(ceTrms);
-  
+
   ceQmean = new AliTPCCalPad("CEQmean","CEQmean");
   ceObjects->Add(ceQmean);
-  
+
   rocTtime = new TObjArray(nSectors+2);   // also make room for A and C side average
   rocTtime->SetName("rocTtime");
   ceObjects->Add(rocTtime);
-  
+
   rocQtime = new TObjArray(nSectors);
   rocQtime->SetName("rocQtime");
   ceObjects->Add(rocQtime);
@@ -1186,17 +1182,17 @@ UInt_t AliTPCPreprocessor::ExtractCE(Int_t sourceFXS)
   TObjArray *arrFitGraphs=new TObjArray;
   arrFitGraphs->SetName("ceFitsDrift");
   ceObjects->Add(arrFitGraphs);
-  
-// Temperature maps 
-  
+
+// Temperature maps
+
   if (fTemp) {
     AliTPCSensorTempArray *tempMap = new AliTPCSensorTempArray(*fTemp);
     tempMap->SetNameTitle("TempMap","TempMap");
     ceObjects->Add(tempMap);
   }
-  
+
 // Pressure maps
-  
+
   if (fPressure) {
     AliDCSSensor *sensor=0, *sensorCopy=0;
     for (Int_t isensor=0; isensor<kNumPressureSensors; ++isensor ) {
@@ -1208,30 +1204,30 @@ UInt_t AliTPCPreprocessor::ExtractCE(Int_t sourceFXS)
       }
     }
   }
-  
+
   UInt_t result=0;
-  
+
   TList* list = GetFileSources(sourceFXS,"CE");
-  
+
   if (list && list->GetEntries()>0) {
-    
+
 //  loop through all files from LDCs
-    
+
     UInt_t index = 0;
     while (list->At(index)!=NULL) {
       TObjString* fileNameEntry = (TObjString*) list->At(index);
       if (fileNameEntry!=NULL) {
         TString fileName = GetFile(sourceFXS, "CE",
                                    fileNameEntry->GetString().Data());
-        AliTPCCalibCE *calCE=AliTPCCalibCE::ReadFromFile(fileName.Data());        
-        
+        AliTPCCalibCE *calCE=AliTPCCalibCE::ReadFromFile(fileName.Data());
+
         if (!calCE) {
           Log ("No valid calibCE object.");
           result=2;
           break;
         }
         //  replace entries for the sectors available in the present file
-        
+
         for (Int_t sector=0; sector<nSectors; sector++) {
           AliTPCCalROC *rocTmean=calCE->GetCalRocT0(sector);
           if ( rocTmean )  ceTmean->SetCalROC(rocTmean,sector);
@@ -1244,7 +1240,7 @@ UInt_t AliTPCPreprocessor::ExtractCE(Int_t sourceFXS)
           TGraph *grQ=calCE->MakeGraphTimeCE(sector,0,3); // Q time graph
           if ( grQ ) rocQtime->AddAt(grQ,sector);
         }
-        
+
         TGraph *grT=calCE->MakeGraphTimeCE(-1,0,2); // A side average
         if ( grT ) {
           rocTtime->AddAt(grT,nSectors);
@@ -1264,7 +1260,7 @@ UInt_t AliTPCPreprocessor::ExtractCE(Int_t sourceFXS)
     }  // while(list)
 //
 //   Check number of calibrated sectors per side
-// 
+//
     Int_t aside=0, cside=0;
     for (Int_t ind=0; ind<nSectors/4; ind++ ) {
         TGraph *grT=(TGraph*)rocTtime->At(ind);
@@ -1288,19 +1284,19 @@ UInt_t AliTPCPreprocessor::ExtractCE(Int_t sourceFXS)
     //    currently its only processed if there is a valid standard CE object
     //
     list = GetFileSources(sourceFXS,"CEnew");
-    
+
     if (result==0 && list && list->GetEntries()>0) {
-      
+
 //  loop through all files from LDCs
-      
+
       UInt_t index2 = 0;
       while (list->At(index2)!=NULL) {
         TObjString* fileNameEntry = (TObjString*) list->At(index2);
         if (fileNameEntry!=NULL) {
           TString fileName = GetFile(sourceFXS, "CEnew",
                                      fileNameEntry->GetString().Data());
-          AliTPCCalibCE *calCE=AliTPCCalibCE::ReadFromFile(fileName.Data());        
-          
+          AliTPCCalibCE *calCE=AliTPCCalibCE::ReadFromFile(fileName.Data());
+
           if (!calCE) {
             Log ("No valid new calibCE object.");
 //             result=2;
@@ -1317,7 +1313,7 @@ UInt_t AliTPCPreprocessor::ExtractCE(Int_t sourceFXS)
         ++index2;
       }
     }
-    
+
 //
 //  Store updated pedestal entry to OCDB
 //
@@ -1326,7 +1322,7 @@ UInt_t AliTPCPreprocessor::ExtractCE(Int_t sourceFXS)
     metaData.SetResponsible("Haavard Helstrup");
     metaData.SetAliRootVersion(ALIROOT_BRANCH);
     metaData.SetComment("Preprocessor AliTPC data base entries.");
-    
+
     if ( result == 0 ) {
       Bool_t storeOK = Store("Calib", "CE", ceObjects, &metaData, 0, kTRUE);
       if ( !storeOK ) ++result;
@@ -1337,33 +1333,31 @@ UInt_t AliTPCPreprocessor::ExtractCE(Int_t sourceFXS)
     Log ("Error: no CE entries available from FXS!");
     result = 1;
   }
-  
+
   ceObjects->Delete();
   delete ceObjects;
-  
+
   return result;
 }
 //______________________________________________________________________________________________
 
 UInt_t AliTPCPreprocessor::ExtractQA(Int_t sourceFXS)
 {
- //
- //  Read Quality Assurance file from file exchage server
- //
- 
+ /// Read Quality Assurance file from file exchage server
+
  UInt_t result=0;
 
  TList* list = GetFileSources(sourceFXS,"QA");
- 
+
  if (list && list->GetEntries()>0) {
 
 //  only one QA object should be available!
 
     AliTPCdataQA *calQA;
 
-    UInt_t nentries = list->GetEntries();  
+    UInt_t nentries = list->GetEntries();
     UInt_t index=0;
-    if ( nentries > 1) Log ( "More than one QA entry. First one processed");      
+    if ( nentries > 1) Log ( "More than one QA entry. First one processed");
     TObjString* fileNameEntry = (TObjString*) list->At(index);
     if (fileNameEntry!=NULL) {
         TString fileName = GetFile(sourceFXS, "QA",
@@ -1371,10 +1365,10 @@ UInt_t AliTPCPreprocessor::ExtractQA(Int_t sourceFXS)
         TFile *f = TFile::Open(fileName);
         if (!f) {
 	  Log ("Error opening QA file.");
-	  result =2;          
+	  result =2;
 	} else {
    	  f->GetObject("tpcCalibQA",calQA);
-          if ( calQA ) {      
+          if ( calQA ) {
 //
 //  Store updated pedestal entry to OCDB
 //
@@ -1406,10 +1400,9 @@ UInt_t AliTPCPreprocessor::ExtractQA(Int_t sourceFXS)
 
 UInt_t AliTPCPreprocessor::ExtractAltro(Int_t sourceFXS, TMap* dcsMap)
 {
- //
- //  Read Altro configuration file from file exchage server
- //  Keep original entry from OCDB in case no new pulser calibration is available
- //
+ /// Read Altro configuration file from file exchage server
+ /// Keep original entry from OCDB in case no new pulser calibration is available
+
  TObjArray    *altroObjects=0;
  AliTPCCalPad *acqStart=0;
  AliTPCCalPad *zsThr=0;
@@ -1424,7 +1417,7 @@ UInt_t AliTPCPreprocessor::ExtractAltro(Int_t sourceFXS, TMap* dcsMap)
  if (entry) altroObjects = (TObjArray*)entry->GetObject();
  if ( altroObjects==NULL ) {
      Log("AliTPCPreprocsessor: No previous TPC altro calibration entry available.\n");
-     altroObjects = new TObjArray;    
+     altroObjects = new TObjArray;
  }
 
  acqStart = (AliTPCCalPad*)altroObjects->FindObject("AcqStart");
@@ -1433,12 +1426,12 @@ UInt_t AliTPCPreprocessor::ExtractAltro(Int_t sourceFXS, TMap* dcsMap)
     altroObjects->Add(acqStart);
  }
  zsThr = (AliTPCCalPad*)altroObjects->FindObject("ZsThr");
- if ( !zsThr )  { 
+ if ( !zsThr )  {
     zsThr = new AliTPCCalPad("ZsThr","ZsThr");
     altroObjects->Add(zsThr);
  }
  FPED = (AliTPCCalPad*)altroObjects->FindObject("FPED");
- if ( !FPED )  { 
+ if ( !FPED )  {
     FPED = new AliTPCCalPad("FPED","FPED");
     altroObjects->Add(FPED);
  }
@@ -1448,37 +1441,37 @@ UInt_t AliTPCPreprocessor::ExtractAltro(Int_t sourceFXS, TMap* dcsMap)
     altroObjects->Add(acqStop);
  }
  masked = (AliTPCCalPad*)altroObjects->FindObject("Masked");
- if ( !masked )  { 
+ if ( !masked )  {
     masked = new AliTPCCalPad("Masked","Masked");
     altroObjects->Add(masked);
  }
  k1 = (AliTPCCalPad*)altroObjects->FindObject("K1");
- if ( !k1 )  { 
+ if ( !k1 )  {
     k1 = new AliTPCCalPad("K1","K1");
     altroObjects->Add(k1);
  }
  k2 = (AliTPCCalPad*)altroObjects->FindObject("K2");
- if ( !k2 )  { 
+ if ( !k2 )  {
     k2 = new AliTPCCalPad("K2","K2");
     altroObjects->Add(k2);
  }
  k3 = (AliTPCCalPad*)altroObjects->FindObject("K3");
- if ( !k3 )  { 
+ if ( !k3 )  {
     k3 = new AliTPCCalPad("K3","K3");
     altroObjects->Add(k3);
  }
  l1 = (AliTPCCalPad*)altroObjects->FindObject("L1");
- if ( !l1 )  { 
+ if ( !l1 )  {
     l1 = new AliTPCCalPad("L1","L1");
     altroObjects->Add(l1);
  }
  l2 = (AliTPCCalPad*)altroObjects->FindObject("L2");
- if ( !l2 )  { 
+ if ( !l2 )  {
     l2 = new AliTPCCalPad("L2","L2");
     altroObjects->Add(l2);
  }
  l3 = (AliTPCCalPad*)altroObjects->FindObject("L3");
- if ( !l3 )  { 
+ if ( !l3 )  {
     l3 = new AliTPCCalPad("L3","L3");
     altroObjects->Add(l3);
  }
@@ -1500,7 +1493,7 @@ UInt_t AliTPCPreprocessor::ExtractAltro(Int_t sourceFXS, TMap* dcsMap)
 // extract list of active DDLs
 
  if (dcsMap) {
-  Bool_t found; 
+  Bool_t found;
   TString arrDDL(kNumDDL);
   arrDDL.Append('x',kNumDDL);
   for ( Int_t iDDL = 0; iDDL<kNumDDL; iDDL++ ) {
@@ -1509,18 +1502,18 @@ UInt_t AliTPCPreprocessor::ExtractAltro(Int_t sourceFXS, TMap* dcsMap)
     found = false;
     if ( pair ) {
         TObjArray *valueSet=(TObjArray*)pair->Value();
-        if ( valueSet) { 
+        if ( valueSet) {
 	  AliDCSValue *val = (AliDCSValue*)valueSet->At(0);
-	  if (val) { 
+	  if (val) {
 	      found = val->GetBool();
 	      if (found){
                arrDDL[iDDL] = '1';
-              } else { 
+              } else {
                arrDDL[iDDL] = '0';
               }
-	  }    
+	  }
 	}
-    } 
+    }
   }
   TObjString *ddlArray = new TObjString;
   ddlArray->SetString(arrDDL);
@@ -1533,13 +1526,13 @@ UInt_t AliTPCPreprocessor::ExtractAltro(Int_t sourceFXS, TMap* dcsMap)
  } else {
    Log ("ExtractAltro: No DCS map available. Active DDL list cannot be obtained.");
    result = 3;
- }        
+ }
 
 // extract Altro configuration files
 
  for ( Int_t id=0; id<2; id++) {
    TList* list = GetFileSources(sourceFXS,idFXS[id].Data());
- 
+
    if (list && list->GetEntries()>0) {
 
 //  loop through all files from LDCs
@@ -1581,10 +1574,10 @@ UInt_t AliTPCPreprocessor::ExtractAltro(Int_t sourceFXS, TMap* dcsMap)
         AliTPCCalPad *l3FXS=(AliTPCCalPad*)altroFXS->FindObject("L3");
         TMap *mapRCUconfigFXS = (TMap*)altroFXS->FindObject("RCUconfig");
         TIterator *mapFXSiter = mapRCUconfigFXS->MakeIterator();
-	
+
         changed=true;
         for (Int_t sector=0; sector<nSectors; sector++) {
-            
+
            if (acqStartFXS) {
 	      AliTPCCalROC *rocAcqStart=acqStartFXS->GetCalROC(sector);
               if ( rocAcqStart )  acqStart->SetCalROC(rocAcqStart,sector);
@@ -1679,10 +1672,10 @@ UInt_t AliTPCPreprocessor::ExtractAltro(Int_t sourceFXS, TMap* dcsMap)
 
      Bool_t storeOK = Store("Calib", "AltroConfig", altroObjects, &metaData, 0, kFALSE);
      if ( !storeOK ) ++result;
-    }  
+    }
 
   altroObjects->Delete();
   delete altroObjects;
-  
+
   return result;
 }
diff --git a/TPC/TPCbase/AliTPCPreprocessor.h b/TPC/TPCbase/AliTPCPreprocessor.h
index 0df9c032426..a968bbd205e 100644
--- a/TPC/TPCbase/AliTPCPreprocessor.h
+++ b/TPC/TPCbase/AliTPCPreprocessor.h
@@ -4,7 +4,8 @@
 #include "AliPreprocessor.h"
 
 
-// test preprocessor that writes data to AliTestDataDCS
+/// \class AliTPCPreprocessor
+/// \brief test preprocessor that writes data to AliTestDataDCS
 
 class AliTestDataDCS;
 class AliTPCSensorTempArray;
@@ -37,17 +38,19 @@ class AliTPCPreprocessor : public AliPreprocessor
     AliTPCPreprocessor& operator = (const AliTPCPreprocessor& rhs);
 
   private:
-    TEnv                   *fConfEnv;  // Preprocessor configuration map
-    AliTPCSensorTempArray  *fTemp;     // CDB class for temperature sensors
-    AliDCSSensorArray      *fHighVoltage; // DCS high voltage measurements
-    AliDCSSensorArray      *fHighVoltageStat; // DCS high voltage status
-    AliDCSSensorArray      *fGoofie;   // Goofie values from DCS
-    AliDCSSensorArray      *fPressure;   // Pressure values from DCS
-    AliDCSSensorArray      *fGasComposition;   // Gas composition values from DCS
-    Bool_t                 fConfigOK;  // Identify succesful reading of OCDB Config
-    AliTPCROC              *fROC;      // TPC Read-Out configuration
-
+    TEnv                   *fConfEnv;  ///< Preprocessor configuration map
+    AliTPCSensorTempArray  *fTemp;     ///< CDB class for temperature sensors
+    AliDCSSensorArray      *fHighVoltage; ///< DCS high voltage measurements
+    AliDCSSensorArray      *fHighVoltageStat; ///< DCS high voltage status
+    AliDCSSensorArray      *fGoofie;   ///< Goofie values from DCS
+    AliDCSSensorArray      *fPressure;   ///< Pressure values from DCS
+    AliDCSSensorArray      *fGasComposition;   ///< Gas composition values from DCS
+    Bool_t                 fConfigOK;  ///< Identify succesful reading of OCDB Config
+    AliTPCROC              *fROC;      ///< TPC Read-Out configuration
+
+    /// \cond CLASSIMP
     ClassDef(AliTPCPreprocessor, 4)
+    /// \endcond
 };
 
 #endif
diff --git a/TPC/TPCbase/AliTPCPreprocessorOnline.cxx b/TPC/TPCbase/AliTPCPreprocessorOnline.cxx
index f61f08c13ca..065dcd2c140 100644
--- a/TPC/TPCbase/AliTPCPreprocessorOnline.cxx
+++ b/TPC/TPCbase/AliTPCPreprocessorOnline.cxx
@@ -14,37 +14,27 @@
  **************************************************************************/
 
 
-////////////////////////////////////////////////////////////////////////////////
-//                                                                            //
-//  Preprocessor class for HLT and DAQ                                        //
-//  Possible usage: preprocess TPC calibration data                           //
-//  to form needed for online viewing/visualizing TPC calibration data        //
-//                                                                            //
-//  On HLT or DAQ AliTPCPreprocessorOnline::AddComponent(...) is called,      //
-//  whereas ... is either an AliTPCCalPad, or an AliTPCCalROC.                //
-//  Their names have to be acording the naming convention for AliTPCCalPads   //
-//  Special for CalROCs: Add '_ROC<ROC_Number>' to the name.                  //
-//                                                                            //
-//  Internal the AliTPCCalPads are stored in a TMap, they are retrieved by    //
-//  their name.                                                               //
-//                                                                            //
-//  Once enough values are accumulated, call ::DumpToFile(fileName).          //
-//  A TObjArray is created out of the TMap, which is passed to                //
-//  AliTPCCalibViewer::MakeTree(...) and the calibratioTree is written        //
-//  is written to "filenName". 
-//                               
-//  The data flow is as follows: 
-/* 
-Begin_Html 
-   <img src="../TPC/doc/dataFlowCalibViewer.png"> 
-End_Html
-*/
-//                                                                            //
-//                                                                            //
-////////////////////////////////////////////////////////////////////////////////
-
-//     
-// ROOT includes 
+/// \class AliTPCPreprocessorOnline
+/// \brief Preprocessor class for HLT and DAQ
+///
+/// Possible usage: preprocess TPC calibration data
+/// to form needed for online viewing/visualizing TPC calibration data
+///
+/// On HLT or DAQ AliTPCPreprocessorOnline::AddComponent(...) is called,
+/// whereas ... is either an AliTPCCalPad, or an AliTPCCalROC.
+/// Their names have to be acording the naming convention for AliTPCCalPads
+/// Special for CalROCs: Add '_ROC<ROC_Number>' to the name.
+///
+/// Internal the AliTPCCalPads are stored in a TMap, they are retrieved by
+/// their name.
+///
+/// Once enough values are accumulated, call ::DumpToFile(fileName).
+/// A TObjArray is created out of the TMap, which is passed to
+/// AliTPCCalibViewer::MakeTree(...) and the calibratioTree is written
+/// is written to "filenName".
+
+//
+// ROOT includes
 //
 #include <TObject.h>
 #include <iostream>
@@ -66,7 +56,9 @@ End_Html
 
 
 
+/// \cond CLASSIMP
 ClassImp(AliTPCPreprocessorOnline)
+/// \endcond
 
 AliTPCPreprocessorOnline::AliTPCPreprocessorOnline():TObject(), fMap(0)
 {
@@ -80,10 +72,9 @@ AliTPCPreprocessorOnline::AliTPCPreprocessorOnline():TObject(), fMap(0)
 //_____________________________________________________________________________
 AliTPCPreprocessorOnline::AliTPCPreprocessorOnline(const AliTPCPreprocessorOnline &c):TObject(c), fMap(0)
 {
-  //
-  // dummy AliTPCPreprocessorOnline copy constructor
-  // not yet working!!!
-  //
+  /// dummy AliTPCPreprocessorOnline copy constructor
+  /// not yet working!!!
+
   fMap = c.fMap;
   printf("AliTPCPreprocessorOnline's copy constructor called, NOT WORKING!!!\n");
 }
@@ -91,19 +82,17 @@ AliTPCPreprocessorOnline::AliTPCPreprocessorOnline(const AliTPCPreprocessorOnlin
 //_____________________________________________________________________________
 AliTPCPreprocessorOnline::AliTPCPreprocessorOnline(TMap *map):TObject(), fMap(0)
 {
-  //
-  // Constructor to "copy" the AliTPCPreprocessorOnline
-  //
+  /// Constructor to "copy" the AliTPCPreprocessorOnline
+
   fMap = map;
 }
 
 
 //____________________________________________________________________________
 AliTPCPreprocessorOnline & AliTPCPreprocessorOnline::operator =(const AliTPCPreprocessorOnline & param){
-   //
-   // assignment operator - dummy
-   // not yet working!!!
-   //
+   /// assignment operator - dummy
+   /// not yet working!!!
+
   if (this == &param) return (*this);
 
    fMap = param.fMap;
@@ -115,9 +104,8 @@ AliTPCPreprocessorOnline & AliTPCPreprocessorOnline::operator =(const AliTPCPrep
 //_____________________________________________________________________________
 AliTPCPreprocessorOnline::~AliTPCPreprocessorOnline()
 {
-   //
-   // AliTPCPreprocessorOnline destructor
-   //
+   /// AliTPCPreprocessorOnline destructor
+
    printf("AliTPCPreprocessorOnline's destructor called. \n");
    fMap->DeleteValues();
    delete fMap;
@@ -126,32 +114,29 @@ AliTPCPreprocessorOnline::~AliTPCPreprocessorOnline()
 
 
 void AliTPCPreprocessorOnline::AddComponent(TObject *obj) {
-   //
-   // Add components form HLT or DAQ here 
-   // The components are either AliTPCCalPads or AliTPCCalROCs
-   // other to be defined
-   // 
-   // As from HLT they will come ROC wise, they have to be set together to one AliTPCCalPad here
-   // Then they are added to the Calibration Tree
-   // This calibration tree will be written by AliTPCCalibViewer::MakeTree, once you call ::DumpToFile(fileName)
-   // 
-   // To distinguish, what kind of component is added, there is a Naming-Convention:
-   // The normal, already definded naming-Convention for AliTPCCalPads <PadName>
-   // <padName>_ROC<ROC_Number>  for example: "CEQmean_ROC34"
-   // 
-   // 
-   // Get name of obj
-   // Check, if it ends with "_ROC<Int_t>" / check, if it contains "ROC"
-   // If it contains "ROC", find out, to which calibration CalPad it belongs -> Parse first part of the name
-   // Get the corsponding AliTPCCalPad / Make a new AliTPCCalPad 
-   // Set "_ROC<Int_t>" to zero /? delete it -> Set the new values, out of obj
-   // 
-
-   
+   /// Add components form HLT or DAQ here
+   /// The components are either AliTPCCalPads or AliTPCCalROCs
+   /// other to be defined
+   ///
+   /// As from HLT they will come ROC wise, they have to be set together to one AliTPCCalPad here
+   /// Then they are added to the Calibration Tree
+   /// This calibration tree will be written by AliTPCCalibViewer::MakeTree, once you call ::DumpToFile(fileName)
+   ///
+   /// To distinguish, what kind of component is added, there is a Naming-Convention:
+   /// The normal, already definded naming-Convention for AliTPCCalPads <PadName>
+   /// <padName>_ROC<ROC_Number>  for example: "CEQmean_ROC34"
+   ///
+   /// Get name of obj
+   /// Check, if it ends with "_ROC<Int_t>" / check, if it contains "ROC"
+   /// If it contains "ROC", find out, to which calibration CalPad it belongs -> Parse first part of the name
+   /// Get the corsponding AliTPCCalPad / Make a new AliTPCCalPad
+   /// Set "_ROC<Int_t>" to zero /? delete it -> Set the new values, out of obj
+
+
    // printf(" ****** AliTPCPreprocessorOnline::AddComponent ****** \n");
   if (!obj) return;
    TString objName = obj->GetName();
-   
+
    // Add a whole AliTPCCalPad to the list
    if (TString(obj->ClassName()) == "AliTPCCalPad") {
       // printf("AliTPCCalPad found\n");
@@ -163,35 +148,35 @@ void AliTPCPreprocessorOnline::AddComponent(TObject *obj) {
          return;
       }
       // current data already present
-      if (TString(listObj->ClassName()) != "AliTPCCalPad") 
+      if (TString(listObj->ClassName()) != "AliTPCCalPad")
          Error("AddComponent", "Mismatch in internal list: '%s' is no AliTPCCalPad. \n", listObj->ClassName());
       AliTPCCalPad *listCalPad = (AliTPCCalPad*)listObj;
       listCalPad->Add(listCalPad, -1); // reset the current CalPad
       listCalPad->Add(calPad);
       return;
    }
-   
+
    if (TString(obj->ClassName()) == "AliTPCCalROC") {
       // printf("AliTPCCalROC found\n");
       if (! objName.Contains("_ROC"))
          Warning("AddComponent", "Uncomplete object name: '%s' is missing _ROC<ROC_number>\n", objName.Data());
       TObjArray *stokens = objName.Tokenize("_ROC");
-      TString rocNumber(""); 
+      TString rocNumber("");
       if (stokens->GetEntriesFast()>1) rocNumber = ((TObjString*)stokens->At(1))->GetString();
       delete stokens;
       Int_t iroc = -1;
       if (rocNumber.IsAlnum()) iroc = rocNumber.Atoi();
-      
+
       // Extract CalPad Name:
       TString removeString("_ROC");
       removeString += rocNumber;
       objName.ReplaceAll(removeString, "");  // Remove "_ROC<number>" from the end
-      
+
       // objName is cleaned and can now be used to extract the coresponding CalPad from the list
       TObject *listObj = fMap->GetValue(objName.Data());
       AliTPCCalROC *calROC = (AliTPCCalROC*)obj;
       if (iroc == -1) iroc = calROC->GetSector();
-      if (iroc != (Int_t)calROC->GetSector()) 
+      if (iroc != (Int_t)calROC->GetSector())
          Warning("AddComponent","Mismatch in  ROC_number: ROC has number %i, in its name %i was specified. Treating now as %i. \n", calROC->GetSector(), iroc, iroc);
       calROC->SetNameTitle(objName.Data(), objName.Data());
       if (listObj == 0) {
@@ -202,31 +187,29 @@ void AliTPCPreprocessorOnline::AddComponent(TObject *obj) {
          return;
       }
       // current data already present
-      if (TString(listObj->ClassName()) != "AliTPCCalPad") 
+      if (TString(listObj->ClassName()) != "AliTPCCalPad")
          Error("AddComponent", "Mismatch in internal list: '%s' is no AliTPCCalPad \n", listObj->ClassName());
       AliTPCCalPad *listCalPad = (AliTPCCalPad*)listObj;
       listCalPad->SetCalROC(calROC, iroc);
       return;
-     
-      
+
+
    }
-   
+
    Warning("AddComponent", "Unknown calibration object '%s', skipped.\n", obj->ClassName());
-   
+
    return;
-   
-   
+
+
 }
 
 
 
 void AliTPCPreprocessorOnline::DumpToFile(const char* fileName){
-   // 
-   // Function to dump the tree to file
-   // A TObjArray is created out of the TMap, which is passed to   
-   // AliTPCCalibViewer::MakeTree(...)  
-   // 
-   
+   /// Function to dump the tree to file
+   /// A TObjArray is created out of the TMap, which is passed to
+   /// AliTPCCalibViewer::MakeTree(...)
+
    printf("AliTPCPreprocessorOnline::DumpToFile\n");
    TObjArray *listOfCalPads = new TObjArray();
    TIterator *iterator = fMap->MakeIterator();
@@ -246,6 +229,6 @@ void AliTPCPreprocessorOnline::DumpToFile(const char* fileName){
    printf("writing the tree... \n");
    //   AliTPCCalibViewer::MakeTree(fileName, listOfCalPads, "$ALICE_ROOT/TPC/Calib/MapCalibrationObjects.root");
    AliTPCCalibViewer::MakeTree(fileName, listOfCalPads, 0);
- 
+
 }
 
diff --git a/TPC/TPCbase/AliTPCPreprocessorOnline.h b/TPC/TPCbase/AliTPCPreprocessorOnline.h
index d7a4f7ec125..6c7cb542105 100644
--- a/TPC/TPCbase/AliTPCPreprocessorOnline.h
+++ b/TPC/TPCbase/AliTPCPreprocessorOnline.h
@@ -5,12 +5,10 @@
 
 /* $Id: AliTPCPreprocessorOnline.h,v */
 
-////////////////////////////////////////////////////////////////////////////////
-//                                                                            //
-//  Preprocessor class for HLT and DAQ                                        //
-//  Possible usage: preprocess TPC calibration data                           //
-//                                                                            //
-////////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCPreprocessorOnline
+/// \brief Preprocessor class for HLT and DAQ
+///
+/// Possible usage: preprocess TPC calibration data
 
 
 class AliTPCCalPad;
@@ -25,17 +23,19 @@ public:
    AliTPCPreprocessorOnline(TMap *map);
    AliTPCPreprocessorOnline &operator = (const AliTPCPreprocessorOnline & param);
    virtual ~AliTPCPreprocessorOnline();
-   
+
    void AddComponent(TObject *obj);
    void DumpToFile(const char* fileName);
-   
+
    TMap *GetMap() {return fMap; } // for debugging
-   
-         
+
+
 protected:
-   TMap *fMap;       // Map of the AliTPCCalPads
-   
+   TMap *fMap;       ///< Map of the AliTPCCalPads
+
+   /// \cond CLASSIMP
    ClassDef(AliTPCPreprocessorOnline,1)    //  TPC preprocessor class
+   /// \endcond
 };
 
 #endif
diff --git a/TPC/TPCbase/AliTPCQAChecker.cxx b/TPC/TPCbase/AliTPCQAChecker.cxx
index 01616f68ca9..e8ce91ad591 100644
--- a/TPC/TPCbase/AliTPCQAChecker.cxx
+++ b/TPC/TPCbase/AliTPCQAChecker.cxx
@@ -13,17 +13,17 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/* $Id: $ */
 
-/*
-  Checks implemented a la AliMUONQAChecker.
-  Checks the quality assurance by realzed checks on histogram content.
-  P. Christiansen, Lund, September 2009.
-
-  Based on AliPHOSQAChecker.
-  Checks the quality assurance by comparing with reference data.
-  P. Christiansen, Lund, January 2008.
-*/
+/// \class AliTPCQAChecker
+/// \brief Checks implemented a la AliMUONQAChecker.
+///
+/// Checks the quality assurance by realzed checks on histogram content.
+///
+/// Based on AliPHOSQAChecker.
+/// Checks the quality assurance by comparing with reference data.
+///
+/// \author P. Christiansen, Lund
+/// \date January 2008 - September 2009.
 
 // --- ROOT header files ---
 #include <TH1.h>
@@ -32,67 +32,69 @@
 #include "AliTPCQAChecker.h"
 #include "AliTPCQADataMakerRec.h"
 
+/// \cond CLASSIMP
 ClassImp(AliTPCQAChecker)
+/// \endcond
 
 
 //__________________________________________________________________
 AliTPCQAChecker& AliTPCQAChecker::operator = (const AliTPCQAChecker &checker)
 {
-  // Equal operator.
+  /// Equal operator.
+
   this->~AliTPCQAChecker();
   new(this) AliTPCQAChecker(checker);
-  return *this;  
+  return *this;
 }
 
 //__________________________________________________________________
 void
-AliTPCQAChecker::Check(Double_t * rv, AliQAv1::ALITASK_t index, TObjArray ** list, 
+AliTPCQAChecker::Check(Double_t * rv, AliQAv1::ALITASK_t index, TObjArray ** list,
 		       const AliDetectorRecoParam * /*recoParam*/)
 {
-  /* It is important to understand the destinction between indexed tasks (AliQAv1::TASKINDEX_t) which are used in the DataMaker classes and indexed tasks (AliQAv1::ALITASK_t) whihc are used in the checker class.
-
-     From the AliQAChecker::Run() methods we have:
-     AliQAv1::kRAW
-     - AliQAv1::kRAWS 
-     
-     AliQAv1::kSIM 
-     - AliQAv1::kHITS
-     - AliQAv1::kSDIGITS
-     - AliQAv1::kDIGITS
-     
-     AliQAv1::kREC
-     - AliQAv1::kDIGITSR 
-     - AliQAv1::kRECPOINTS
-     - AliQAv1::kTRACKSEGMENTS 
-     - AliQAv1::kRECPARTICLES
-     
-     AliQAv1::kESD ; 
-     -AliQAv1::kESDS
-
-     This means that for each group of tasks the Check will be called
-     one or more times.  This also mean that we cannot know what
-     histograms will be or not be there in a single call... And we
-     also do not know the position in the list of the histogram.
-  */
-  
+  /// It is important to understand the destinction between indexed tasks (AliQAv1::TASKINDEX_t) which are used in the DataMaker classes and indexed tasks (AliQAv1::ALITASK_t) whihc are used in the checker class.
+  ///
+  ///     From the AliQAChecker::Run() methods we have:
+  ///     AliQAv1::kRAW
+  ///     - AliQAv1::kRAWS
+  ///
+  ///     AliQAv1::kSIM
+  ///     - AliQAv1::kHITS
+  ///     - AliQAv1::kSDIGITS
+  ///     - AliQAv1::kDIGITS
+  ///
+  ///     AliQAv1::kREC
+  ///     - AliQAv1::kDIGITSR
+  ///     - AliQAv1::kRECPOINTS
+  ///     - AliQAv1::kTRACKSEGMENTS
+  ///     - AliQAv1::kRECPARTICLES
+  ///
+  ///     AliQAv1::kESD ;
+  ///     -AliQAv1::kESDS
+  ///
+  ///     This means that for each group of tasks the Check will be called
+  ///     one or more times.  This also mean that we cannot know what
+  ///     histograms will be or not be there in a single call... And we
+  ///     also do not know the position in the list of the histogram.
+
   /// Check objects in list
   if(fDebug>0)
     AliInfo("In AliTPCQAChecker::Check");
-  
+
   if (index!=AliQAv1::kRAW&&index!=AliQAv1::kSIM&&index!=AliQAv1::kREC&&index!=AliQAv1::kESD) {
-    
+
     AliWarning(Form("Checker for task %d not implement for the moment",index));
     return;
   }
-  
-  for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) 
-    rv[specie] = 1.0; // All is fine 
-  
+
+  for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++)
+    rv[specie] = 1.0; // All is fine
+
   for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
-    
-    if ( !AliQAv1::Instance()->IsEventSpecieSet(specie) ) 
-      continue ; 
-    
+
+    if ( !AliQAv1::Instance()->IsEventSpecieSet(specie) )
+      continue ;
+
     if (index == AliQAv1::kRAW)
       rv[specie] = CheckRAW(specie, list[specie]);
     if (index == AliQAv1::kSIM)
@@ -103,7 +105,7 @@ AliTPCQAChecker::Check(Double_t * rv, AliQAv1::ALITASK_t index, TObjArray ** lis
       rv[specie] = CheckESD(specie, list[specie]);
 
     if(fDebug>3)
-      AliInfo(Form("Specie: %s. Task: %s. Value: %f",  
+      AliInfo(Form("Specie: %s. Task: %s. Value: %f",
 		   AliRecoParam::GetEventSpecieName(specie),
 		   AliQAv1::GetAliTaskName(index),
 		   rv[specie]));
@@ -114,9 +116,10 @@ AliTPCQAChecker::Check(Double_t * rv, AliQAv1::ALITASK_t index, TObjArray ** lis
 Double_t AliTPCQAChecker::CheckRAW(Int_t specie, TObjArray* list)
 {
   /// Check ESD
+
   if(fDebug>0)
     AliInfo("In AliTPCQAChecker::CheckRAW");
-  
+
   if(fDebug>2)
     list->Print();
 
@@ -124,77 +127,78 @@ Double_t AliTPCQAChecker::CheckRAW(Int_t specie, TObjArray* list)
     (list->FindObject(Form("%s_hRawsOccupancyVsSector",AliRecoParam::GetEventSpecieName(specie))));
   TH1* hRawsQmaxVsSector = static_cast<TH1*>
     (list->FindObject(Form("%s_hRawsQmaxVsSector",AliRecoParam::GetEventSpecieName(specie))));
-  
+
   if (!hRawsOccupancyVsSector || !hRawsQmaxVsSector)
     return -0.5; // fatal
-  
+
   if(hRawsOccupancyVsSector->GetEntries()==0) {
     return 0.25; // error - No TPC data!
   }
-  
+
   Int_t nBinsX = hRawsOccupancyVsSector->GetNbinsX();
   for(Int_t i = 1; i <= nBinsX; i++) {
-    
+
     if(hRawsOccupancyVsSector->GetBinContent(i)==0)
       return 0.75; // warning - no TPC data for at least one sector
   }
-  
+
   return 1.0; // ok
 }
 
 //______________________________________________________________________________
 Double_t AliTPCQAChecker::CheckSIM(Int_t specie, TObjArray* list)
 {
-  // This method checks the QA histograms associated with simulation
-  //
-  // For TPC this is:
-  // Digits : 
-  // The digit histogram gives the ADC distribution for all sigbnals
-  // above threshold. The check is just that there are digits.
-  // Hits : The hit histograms are checked to see that they are not
-  // empty. They contain a lot of detailed information on the
-  // energyloss model (they were used to debug the AliRoot TPC use of
-  // FLUKA).
-  //
-  // The check methods are simple:
-  // We do not know if it is bad that histograms are missing because
-  // this will always be the case for summable digits. So this check
-  // is not possible here.
-  // If digit histogram is empty (set error)
-  // If one of the hit histograms are empty (set error)
+  /// This method checks the QA histograms associated with simulation
+  ///
+  /// For TPC this is:
+  /// Digits :
+  /// The digit histogram gives the ADC distribution for all sigbnals
+  /// above threshold. The check is just that there are digits.
+  /// Hits : The hit histograms are checked to see that they are not
+  /// empty. They contain a lot of detailed information on the
+  /// energyloss model (they were used to debug the AliRoot TPC use of
+  /// FLUKA).
+  ///
+  /// The check methods are simple:
+  /// We do not know if it is bad that histograms are missing because
+  /// this will always be the case for summable digits. So this check
+  /// is not possible here.
+  /// If digit histogram is empty (set error)
+  /// If one of the hit histograms are empty (set error)
+
   if(fDebug>0)
     AliInfo("In AliTPCQAChecker::CheckSIM");
-  
+
   if(fDebug>2)
     list->Print();
 
   TH1* hDigits = static_cast<TH1*>
     (list->FindObject(Form("%s_hDigitsADC",AliRecoParam::GetEventSpecieName(specie))));
-  TH1* hHitsNhits = static_cast<TH1*> 
+  TH1* hHitsNhits = static_cast<TH1*>
     (list->FindObject(Form("%s_hHitsNhits",AliRecoParam::GetEventSpecieName(specie))));
-  TH1* hHitsElectrons         = static_cast<TH1*> 
+  TH1* hHitsElectrons         = static_cast<TH1*>
     (list->FindObject(Form("%s_hHitsElectrons",AliRecoParam::GetEventSpecieName(specie))));
-  TH1* hHitsRadius        = static_cast<TH1*> 
+  TH1* hHitsRadius        = static_cast<TH1*>
     (list->FindObject(Form("%s_hHitsRadius",AliRecoParam::GetEventSpecieName(specie))));
-  TH1* histHitsPrimPerCm          = static_cast<TH1*> 
+  TH1* histHitsPrimPerCm          = static_cast<TH1*>
     (list->FindObject(Form("%s_histHitsPrimPerCm",AliRecoParam::GetEventSpecieName(specie))));
-  TH1* histHitsElectronsPerCm          = static_cast<TH1*> 
+  TH1* histHitsElectronsPerCm          = static_cast<TH1*>
     (list->FindObject(Form("%s_histHitsElectronsPerCm",AliRecoParam::GetEventSpecieName(specie))));
-  
+
 //   if (!(hDigits) ||                                             // digit hists
 //       !(hHitsNhits && hHitsElectrons && hHitsRadius && histHitsPrimPerCm && histHitsElectronsPerCm)) // hit hists
 //     return -0.5; // fatal
-  
+
   if (hDigits) {
-    if(hDigits->GetEntries()==0) 
+    if(hDigits->GetEntries()==0)
       return 0.25; // error
   }
 
-  if (hHitsNhits && hHitsElectrons && hHitsRadius && 
+  if (hHitsNhits && hHitsElectrons && hHitsRadius &&
       histHitsPrimPerCm && histHitsElectronsPerCm) {
     if (hHitsNhits->GetEntries()==0 || hHitsElectrons->GetEntries()==0 ||
 	hHitsRadius->GetEntries()==0 || histHitsPrimPerCm->GetEntries()==0 ||
-	histHitsElectronsPerCm->GetEntries()==0) 
+	histHitsElectronsPerCm->GetEntries()==0)
       return 0.25; // error
   }
 
@@ -204,39 +208,40 @@ Double_t AliTPCQAChecker::CheckSIM(Int_t specie, TObjArray* list)
 //______________________________________________________________________________
 Double_t AliTPCQAChecker::CheckREC(Int_t specie, TObjArray* list)
 {
-  // This method checks the QA histograms associated with reconstruction
-  //
-  // For TPC this is:
-  // DigitsR : 
-  // The digit histogram gives the ADC distribution for all sigbnals
-  // above threshold. The check is just that there are digits.
-  // RecPoints : 
-  // The cluster histograms are meant to give an idea about the gain
-  // from the cluster charge and to indicate iof there are rows with
-  // noise clusters, i.e., they are very visual.
-  //
-  // The check methods are simple:
-  // If there are no histogram at all (set fatal)
-  // If digit histogram is there, but there are no digits (set error)
-  // If cluster histogram is there but there are less than 1000 
-  //    clusters (set warning)
-  // If there are more than 1000 clusters but no clusters for either short, 
-  // medium, or long pads (set error)
+  /// This method checks the QA histograms associated with reconstruction
+  ///
+  /// For TPC this is:
+  /// DigitsR :
+  /// The digit histogram gives the ADC distribution for all sigbnals
+  /// above threshold. The check is just that there are digits.
+  /// RecPoints :
+  /// The cluster histograms are meant to give an idea about the gain
+  /// from the cluster charge and to indicate iof there are rows with
+  /// noise clusters, i.e., they are very visual.
+  ///
+  /// The check methods are simple:
+  /// If there are no histogram at all (set fatal)
+  /// If digit histogram is there, but there are no digits (set error)
+  /// If cluster histogram is there but there are less than 1000
+  ///    clusters (set warning)
+  /// If there are more than 1000 clusters but no clusters for either short,
+  /// medium, or long pads (set error)
+
   if(fDebug>0)
     AliInfo("In AliTPCQAChecker::CheckREC");
-  
+
   if(fDebug>2)
     list->Print();
 
   TH1* hDigits = static_cast<TH1*>
     (list->FindObject(Form("%s_hDigitsADC",AliRecoParam::GetEventSpecieName(specie))));
-  TH1* hNclustersVsRow = static_cast<TH1*> 
+  TH1* hNclustersVsRow = static_cast<TH1*>
     (list->FindObject(Form("%s_hRecPointsRow",AliRecoParam::GetEventSpecieName(specie))));
-  TH1* hQshort         = static_cast<TH1*> 
+  TH1* hQshort         = static_cast<TH1*>
     (list->FindObject(Form("%s_hRecPointsQShort",AliRecoParam::GetEventSpecieName(specie))));
-  TH1* hQmedium        = static_cast<TH1*> 
+  TH1* hQmedium        = static_cast<TH1*>
     (list->FindObject(Form("%s_hRecPointsQMedium",AliRecoParam::GetEventSpecieName(specie))));
-  TH1* hQlong          = static_cast<TH1*> 
+  TH1* hQlong          = static_cast<TH1*>
     (list->FindObject(Form("%s_hRecPointsQLong",AliRecoParam::GetEventSpecieName(specie))));
   // The Qmax histograms are for now ignored
 
@@ -244,16 +249,16 @@ Double_t AliTPCQAChecker::CheckREC(Int_t specie, TObjArray* list)
       (!hNclustersVsRow || !hQshort || !hQmedium || !hQlong)) // 1 recpoint hist missing
     return -0.5; // fatal
 
-  if (hDigits && hDigits->GetEntries()==0) 
+  if (hDigits && hDigits->GetEntries()==0)
     return 0.25; // error
-  
+
   if (hNclustersVsRow && hNclustersVsRow->GetEntries() < 1000) {
     return 0.75; // warning
-  } else { 
+  } else {
     if (!hQshort || !hQlong || !hQlong)
       return -0.5;// fatal - they should be there if the cluster vs row hist is there
     if (hQshort->GetEntries()==0 || hQmedium->GetEntries()==0 ||
-	hQlong->GetEntries()==0) 
+	hQlong->GetEntries()==0)
       return 0.25; // error
   }
   return 1; // ok
@@ -262,14 +267,14 @@ Double_t AliTPCQAChecker::CheckREC(Int_t specie, TObjArray* list)
 //______________________________________________________________________________
 Double_t AliTPCQAChecker::CheckESD(Int_t specie, TObjArray* list)
 {
-  // This method checks the QA histograms associated with ESDs
-  // (Note that there is aslo a globalQA which is running on all
-  //  the ESD information so for now this is just a few basic
-  //  histograms)
-  //
-  // The check methods are simple:
-  // If there are no histogram at all (set fatal)
-  // 
+  /// This method checks the QA histograms associated with ESDs
+  /// (Note that there is aslo a globalQA which is running on all
+  ///  the ESD information so for now this is just a few basic
+  ///  histograms)
+  ///
+  /// The check methods are simple:
+  /// If there are no histogram at all (set fatal)
+
   if(fDebug>0)
     AliInfo("In AliTPCQAChecker::CheckESD");
 
@@ -282,36 +287,37 @@ Double_t AliTPCQAChecker::CheckESD(Int_t specie, TObjArray* list)
     (list->FindObject(Form("%s_hESDratio",AliRecoParam::GetEventSpecieName(specie))));
   TH1* hESDpt = static_cast<TH1*>
     (list->FindObject(Form("%s_hESDpt",AliRecoParam::GetEventSpecieName(specie))));
-  
-  if (!hESDclusters || !hESDratio || !hESDpt) 
+
+  if (!hESDclusters || !hESDratio || !hESDpt)
     return -0.5; // fatal
 
   return 1.0; // ok
 }
 
 //______________________________________________________________________________
-void AliTPCQAChecker::Init(const AliQAv1::DETECTORINDEX_t det) 
+void AliTPCQAChecker::Init(const AliQAv1::DETECTORINDEX_t det)
 {
   /// intialises QA and QA checker settings
+
   if(fDebug>0)
     AliInfo("In AliTPCQAChecker::Init");
-  AliQAv1::Instance(det) ; 
-  Float_t hiValue[AliQAv1::kNBIT] ; 
+  AliQAv1::Instance(det) ;
+  Float_t hiValue[AliQAv1::kNBIT] ;
   Float_t lowValue[AliQAv1::kNBIT] ;
-  hiValue[AliQAv1::kINFO]       = 1.00; 
-  lowValue[AliQAv1::kINFO]      = 0.99; 
-  hiValue[AliQAv1::kWARNING]    = 0.99; 
-  lowValue[AliQAv1::kWARNING]   = 0.50; 
-  hiValue[AliQAv1::kERROR]      = 0.50; 
-  lowValue[AliQAv1::kERROR]     = 0.00; 
-  hiValue[AliQAv1::kFATAL]      = 0.00; 
-  lowValue[AliQAv1::kFATAL]     =-1.00; 
-  //  SetHiLo(&hiValue[0], &lowValue[0]) ; 
-  SetHiLo(hiValue, lowValue) ; 
+  hiValue[AliQAv1::kINFO]       = 1.00;
+  lowValue[AliQAv1::kINFO]      = 0.99;
+  hiValue[AliQAv1::kWARNING]    = 0.99;
+  lowValue[AliQAv1::kWARNING]   = 0.50;
+  hiValue[AliQAv1::kERROR]      = 0.50;
+  lowValue[AliQAv1::kERROR]     = 0.00;
+  hiValue[AliQAv1::kFATAL]      = 0.00;
+  lowValue[AliQAv1::kFATAL]     =-1.00;
+  //  SetHiLo(&hiValue[0], &lowValue[0]) ;
+  SetHiLo(hiValue, lowValue) ;
 }
 
 //______________________________________________________________________________
-void 
+void
 AliTPCQAChecker::SetQA(AliQAv1::ALITASK_t index, Double_t * value) const
 {
   /// sets the QA according the return value of the Check
@@ -320,50 +326,50 @@ AliTPCQAChecker::SetQA(AliQAv1::ALITASK_t index, Double_t * value) const
     AliInfo("In AliTPCQAChecker::SetQA");
 
   AliQAv1 * qa = AliQAv1::Instance(index);
-  
+
   for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
 
     if (value==NULL) { // No checker is implemented, set all QA to Fatal
-      
+
       if(fDebug>1)
-	AliInfo(Form("Fatal QA. Task: %s. Specie: %s", 
-		     AliQAv1::GetAliTaskName(index), 
+	AliInfo(Form("Fatal QA. Task: %s. Specie: %s",
+		     AliQAv1::GetAliTaskName(index),
 		     AliRecoParam::GetEventSpecieName(specie)));
-      qa->Set(AliQAv1::kFATAL, specie) ; 
+      qa->Set(AliQAv1::kFATAL, specie) ;
     } else {
-      
-      if ( value[specie] >= fLowTestValue[AliQAv1::kFATAL] && 
+
+      if ( value[specie] >= fLowTestValue[AliQAv1::kFATAL] &&
 	   value[specie] < fUpTestValue[AliQAv1::kFATAL] ) {
-	
+
 	if(fDebug>1)
-	  AliInfo(Form("QA-Fatal. Task: %s. Specie: %s", 
-		       AliQAv1::GetAliTaskName(index), 
+	  AliInfo(Form("QA-Fatal. Task: %s. Specie: %s",
+		       AliQAv1::GetAliTaskName(index),
 		       AliRecoParam::GetEventSpecieName(specie)));
-        qa->Set(AliQAv1::kFATAL, specie) ; 
-      } else if ( value[specie] > fLowTestValue[AliQAv1::kERROR] && 
+        qa->Set(AliQAv1::kFATAL, specie) ;
+      } else if ( value[specie] > fLowTestValue[AliQAv1::kERROR] &&
 		  value[specie] <= fUpTestValue[AliQAv1::kERROR]  ) {
-	
+
 	if(fDebug>1)
-	  AliInfo(Form("QA-Error. Task: %s. Specie: %s", 
-		       AliQAv1::GetAliTaskName(index), 
+	  AliInfo(Form("QA-Error. Task: %s. Specie: %s",
+		       AliQAv1::GetAliTaskName(index),
 		       AliRecoParam::GetEventSpecieName(specie)));
-        qa->Set(AliQAv1::kERROR, specie) ; 
-      } else if (value[specie] > fLowTestValue[AliQAv1::kWARNING] && 
+        qa->Set(AliQAv1::kERROR, specie) ;
+      } else if (value[specie] > fLowTestValue[AliQAv1::kWARNING] &&
 		 value[specie] <= fUpTestValue[AliQAv1::kWARNING]) {
-	
+
 	if(fDebug>1)
-	  AliInfo(Form("QA-Warning. Task: %s. Specie: %s", 
-		       AliQAv1::GetAliTaskName(index), 
+	  AliInfo(Form("QA-Warning. Task: %s. Specie: %s",
+		       AliQAv1::GetAliTaskName(index),
 		       AliRecoParam::GetEventSpecieName(specie)));
 	qa->Set(AliQAv1::kWARNING, specie) ;
-      } else if (value[specie] > fLowTestValue[AliQAv1::kINFO] && 
-		 value[specie] <= fUpTestValue[AliQAv1::kINFO] ) { 
-	
+      } else if (value[specie] > fLowTestValue[AliQAv1::kINFO] &&
+		 value[specie] <= fUpTestValue[AliQAv1::kINFO] ) {
+
 	if(fDebug>1)
-	  AliInfo(Form("QA-Info. Task: %s. Specie: %s", 
-		       AliQAv1::GetAliTaskName(index), 
+	  AliInfo(Form("QA-Info. Task: %s. Specie: %s",
+		       AliQAv1::GetAliTaskName(index),
 		       AliRecoParam::GetEventSpecieName(specie)));
-	qa->Set(AliQAv1::kINFO, specie) ; 	
+	qa->Set(AliQAv1::kINFO, specie) ;
       }
     }
   }
diff --git a/TPC/TPCbase/AliTPCQAChecker.h b/TPC/TPCbase/AliTPCQAChecker.h
index 8cf5374ae02..de4089ec023 100644
--- a/TPC/TPCbase/AliTPCQAChecker.h
+++ b/TPC/TPCbase/AliTPCQAChecker.h
@@ -3,14 +3,13 @@
 /* Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-
-/* $Id: $ */
-
-/*
-  Checks implemented a la AliMUONQAChecker.
-  Checks the quality assurance by very simple checks on histogram content.
-  P. Christiansen, Lund, September 2009.
-*/
+/// \class AliTPCQAChecker
+/// \brief Checks implemented a la AliMUONQAChecker.
+///
+/// Checks the quality assurance by very simple checks on histogram content.
+///
+/// \author P. Christiansen, Lund
+/// \date September 2009.
 
 // --- ROOT header files ---
 #include <TObjArray.h>
@@ -20,30 +19,32 @@
 #include "AliDetectorRecoParam.h"
 
 class AliTPCQAChecker: public AliQACheckerBase {
-  
+
  public:
  AliTPCQAChecker() : AliQACheckerBase("TPC","TPC Quality Assurance Checker"), fDebug(0) {;}          // ctor
- AliTPCQAChecker(const AliTPCQAChecker& qac) : AliQACheckerBase(qac.GetName(), qac.GetTitle()), fDebug(qac.GetDebugLevel()) {;} // cpy ctor   
+ AliTPCQAChecker(const AliTPCQAChecker& qac) : AliQACheckerBase(qac.GetName(), qac.GetTitle()), fDebug(qac.GetDebugLevel()) {;} // cpy ctor
   AliTPCQAChecker& operator = (const AliTPCQAChecker &checker); // assignment
   virtual ~AliTPCQAChecker() {;} // dtor
-  
-  virtual void Check(Double_t *  test, AliQAv1::ALITASK_t, TObjArray **, const AliDetectorRecoParam * recoParam); 
-  void Init(const AliQAv1::DETECTORINDEX_t det); 
+
+  virtual void Check(Double_t *  test, AliQAv1::ALITASK_t, TObjArray **, const AliDetectorRecoParam * recoParam);
+  void Init(const AliQAv1::DETECTORINDEX_t det);
   void SetQA(AliQAv1::ALITASK_t index, Double_t * value) const;
 
   Int_t GetDebugLevel() const {return fDebug;}
   void  SetDebugLevel(Int_t value) {fDebug = value;}
-  
+
 private:
-  
+
   Double_t CheckRAW(Int_t specie, TObjArray* list);
   Double_t CheckSIM(Int_t specie, TObjArray* list);
   Double_t CheckREC(Int_t specie, TObjArray* list);
   Double_t CheckESD(Int_t specie, TObjArray* list);
 
   Int_t fDebug;
-  
+
+  /// \cond CLASSIMP
   ClassDef(AliTPCQAChecker,2)  // TPC Quality Assurance Checker
+  /// \endcond
 
 };
 
diff --git a/TPC/TPCbase/AliTPCQADataMakerRec.cxx b/TPC/TPCbase/AliTPCQADataMakerRec.cxx
index 80b27416094..14078dd23e3 100644
--- a/TPC/TPCbase/AliTPCQADataMakerRec.cxx
+++ b/TPC/TPCbase/AliTPCQADataMakerRec.cxx
@@ -13,62 +13,61 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-
-/* $Id: $ */
-
-/*
-  Based on AliPHOSQADataMaker
-  Produces the data needed to calculate the quality assurance. 
-  All data must be mergeable objects.
-  P. Christiansen, Lund, January 2008
-
-  Updated July 2011:
-  ==================
-
-  Major changes to accomodate updates of general DQM/QA changes to have per
-  trigger histograms (for a given event specie).
-
-  1) One instance of AliTPCdataQA only. (This also solves some old wishes by
-  offline team to use less memory because event the 2d arrays for this object
-  is not used). This now has a new flag for only keeping DQM info event by
-  event! For this reason there is no need for a special DQM reset any more
-  between runs!
-
-  2) Fill the histogram for each event. The histograms are no longer filled
-  from the AliTPCdataQA but per event.
-
-  3) Use profiles for the RAW info. By adding the profiles event by event we
-  get the correct event averages WITHOUT having to normalize in the end!
-  Results should therefore also be directly mergable when that feature will
-  come. (none of the other histograms are merged).
-
-  This means that from the DQM/QA point of view the TPC DQM is now fully
-  standard and should ease future developments.
-
-  Updated June 2010:
-  ==================
-
-  The "beautification" of the online DQM histograms have been moved to
-  an amore macro.  
-
-  The per event RAW histograms have been modified in AliTPCdataQA and
-  the copies have therefore also been modified here.
-
-  The AliTPCdataQA can now be configured a bit from here: time bin
-  range (extended default range to 1-1000, event range at start:
-  0-100000, 1000 events per bin). (At least the parameters are not
-  hardcoded:-)
-
-  Implementation:
-  ===============
-
-  For the QA of the RAW data we use the class, AliTPCdataQA, from the
-  existing TPC Calibration framework (which is more advanced than the
-  standard QA framework) and extract the histograms at the end. The
-  Analyse method of the AliTPCdataQA class is called in the method,
-  EndOfDetectorCycle, and there also: 1d histogram(s) are projected
-  and added to the QA list.
-*/
+/// \class AliTPCQADataMakerRec
+/// \brief Produces the data needed to calculate the quality assurance.
+///
+/// Based on AliPHOSQADataMaker
+/// All data must be mergeable objects.
+///
+/// Updated July 2011:
+/// ==================
+///
+/// Major changes to accomodate updates of general DQM/QA changes to have per
+/// trigger histograms (for a given event specie).
+///
+/// 1) One instance of AliTPCdataQA only. (This also solves some old wishes by
+/// offline team to use less memory because event the 2d arrays for this object
+/// is not used). This now has a new flag for only keeping DQM info event by
+/// event! For this reason there is no need for a special DQM reset any more
+/// between runs!
+///
+/// 2) Fill the histogram for each event. The histograms are no longer filled
+/// from the AliTPCdataQA but per event.
+///
+/// 3) Use profiles for the RAW info. By adding the profiles event by event we
+/// get the correct event averages WITHOUT having to normalize in the end!
+/// Results should therefore also be directly mergable when that feature will
+/// come. (none of the other histograms are merged).
+///
+/// This means that from the DQM/QA point of view the TPC DQM is now fully
+/// standard and should ease future developments.
+///
+/// Updated June 2010:
+/// ==================
+///
+/// The "beautification" of the online DQM histograms have been moved to
+/// an amore macro.
+///
+/// The per event RAW histograms have been modified in AliTPCdataQA and
+/// the copies have therefore also been modified here.
+///
+/// The AliTPCdataQA can now be configured a bit from here: time bin
+/// range (extended default range to 1-1000, event range at start:
+/// 0-100000, 1000 events per bin). (At least the parameters are not
+/// hardcoded:-)
+///
+/// Implementation:
+/// ===============
+///
+/// For the QA of the RAW data we use the class, AliTPCdataQA, from the
+/// existing TPC Calibration framework (which is more advanced than the
+/// standard QA framework) and extract the histograms at the end. The
+/// Analyse method of the AliTPCdataQA class is called in the method,
+/// EndOfDetectorCycle, and there also: 1d histogram(s) are projected
+/// and added to the QA list.
+///
+/// \author P. Christiansen, Lund
+/// \date January 2008
 
 #include "AliTPCQADataMakerRec.h"
 
@@ -79,9 +78,9 @@
 #include <TBox.h>
 #include <TLine.h>
 #include <TAxis.h>
-#include <TH1.h> 
-#include <TProfile.h> 
-#include <TProfile2D.h> 
+#include <TH1.h>
+#include <TProfile.h>
+#include <TProfile2D.h>
 
 // --- Standard library ---
 
@@ -98,34 +97,37 @@
 #include <AliDetectorRecoParam.h>
 
 
+/// \cond CLASSIMP
 ClassImp(AliTPCQADataMakerRec)
+/// \endcond
 
-//____________________________________________________________________________ 
-AliTPCQADataMakerRec::AliTPCQADataMakerRec() : 
-AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kTPC), 
+//____________________________________________________________________________
+AliTPCQADataMakerRec::AliTPCQADataMakerRec() :
+AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kTPC),
 		  "TPC Rec Quality Assurance Data Maker"),
 fTPCdataQA(NULL),
 fRawFirstTimeBin(1),
 fRawLastTimeBin(1000)
 {
   // ctor
-  
+
   for(Int_t i = 0; i < 6; i++)
     fMapping[i] = 0;
 }
 
-//____________________________________________________________________________ 
+//____________________________________________________________________________
 AliTPCQADataMakerRec::AliTPCQADataMakerRec(const AliTPCQADataMakerRec& qadm) :
   AliQADataMakerRec(),
   fTPCdataQA(NULL),
   fRawFirstTimeBin(qadm.GetRawFirstTimeBin()),
   fRawLastTimeBin(qadm.GetRawLastTimeBin())
 {
-  //copy ctor 
-  // Does not copy the calibration object, instead InitRaws have to be
-  // called again
-  SetName((const char*)qadm.GetName()) ; 
-  SetTitle((const char*)qadm.GetTitle()); 
+  /// copy ctor
+  /// Does not copy the calibration object, instead InitRaws have to be
+  /// called again
+
+  SetName((const char*)qadm.GetName()) ;
+  SetTitle((const char*)qadm.GetTitle());
 
   for(Int_t i = 0; i < 6; i++)
     fMapping[i] = 0;
@@ -134,7 +136,8 @@ AliTPCQADataMakerRec::AliTPCQADataMakerRec(const AliTPCQADataMakerRec& qadm) :
 //__________________________________________________________________
 AliTPCQADataMakerRec& AliTPCQADataMakerRec::operator = (const AliTPCQADataMakerRec& qadm )
 {
-  // Equal operator.
+  /// Equal operator.
+
   this->~AliTPCQADataMakerRec();
   new(this) AliTPCQADataMakerRec(qadm);
   return *this;
@@ -143,43 +146,46 @@ AliTPCQADataMakerRec& AliTPCQADataMakerRec::operator = (const AliTPCQADataMakerR
 //__________________________________________________________________
 AliTPCQADataMakerRec::~AliTPCQADataMakerRec()
 {
-  // Destructor
-  delete fTPCdataQA; 
+  /// Destructor
 
-  for(Int_t i = 0; i < 6; i++) 
+  delete fTPCdataQA;
+
+  for(Int_t i = 0; i < 6; i++)
     delete fMapping[i];
 }
- 
-//____________________________________________________________________________ 
+
+//____________________________________________________________________________
 void AliTPCQADataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list)
 {
-  //Detector specific actions at end of cycle
+  /// Detector specific actions at end of cycle
+
   ResetEventTrigClasses();
 
-  AliQAChecker::Instance()->Run(AliQAv1::kTPC, task, list) ;  
+  AliQAChecker::Instance()->Run(AliQAv1::kTPC, task, list) ;
 }
 
 
-//____________________________________________________________________________ 
+//____________________________________________________________________________
 void AliTPCQADataMakerRec::InitESDs()
 {
-  //create ESDs histograms in ESDs subdir  
-  const Bool_t expert   = kTRUE ; 
-  const Bool_t image    = kTRUE ; 
-  
-  TH1F * histESDclusters = 
+  /// create ESDs histograms in ESDs subdir
+
+  const Bool_t expert   = kTRUE ;
+  const Bool_t image    = kTRUE ;
+
+  TH1F * histESDclusters =
     new TH1F("hESDclusters", "N TPC clusters per track; N clusters; Counts",
 	     160, 0, 160);
   histESDclusters->Sumw2();
   Add2ESDsList(histESDclusters, kClusters, !expert, image);
 
-  TH1F * histESDratio = 
+  TH1F * histESDratio =
     new TH1F("hESDratio", "Ratio: TPC clusters / findable; Ratio: cluster/findable; Counts",
 	     100, 0, 1);
   histESDratio->Sumw2();
   Add2ESDsList(histESDratio, kRatio, !expert, image);
-  
-  TH1F * histESDpt = 
+
+  TH1F * histESDpt =
     new TH1F("hESDpt", "P_{T} distribution; p_{T} [GeV/c]; Counts",
 	     50, 0, 5);
   histESDpt->Sumw2();
@@ -188,32 +194,30 @@ void AliTPCQADataMakerRec::InitESDs()
   ClonePerTrigClass(AliQAv1::kESDS); // this should be the last line
 }
 
-//____________________________________________________________________________ 
+//____________________________________________________________________________
 void AliTPCQADataMakerRec::InitRaws()
 {
-  //
-  // Adding the raw 
-  //  
+  /// Adding the raw
 
   // Modified: 7/7 - 2008
   // Laurent Aphecetche pointed out that the mapping was read from file
-  // for each event, so now we read in the map here and set if for 
+  // for each event, so now we read in the map here and set if for
   // the raw data qa
-  const Bool_t expert   = kTRUE ; 
-  const Bool_t saveCorr = kTRUE ; 
-  const Bool_t image    = kTRUE ; 
-  
+  const Bool_t expert   = kTRUE ;
+  const Bool_t saveCorr = kTRUE ;
+  const Bool_t image    = kTRUE ;
+
   // It might happen that we will be in this method a few times
   // (we create the dataQA at the first call to this method)
   if(!fTPCdataQA) {
     fTPCdataQA = new AliTPCdataQA();
     LoadMaps(); // Load Altro maps
     fTPCdataQA->SetAltroMapping(fMapping); // set Altro mapping
-    fTPCdataQA->SetRangeTime(fRawFirstTimeBin, fRawLastTimeBin); // set time bin interval 
+    fTPCdataQA->SetRangeTime(fRawFirstTimeBin, fRawLastTimeBin); // set time bin interval
     fTPCdataQA->SetIsDQM(kTRUE);
   }
 
-  TProfile * histRawsOccupancyVsSector = 
+  TProfile * histRawsOccupancyVsSector =
     new TProfile("hRawsOccupancyVsSector", "Occupancy vs sector; Sector; Occupancy",
 	     72, 0, 72);
   histRawsOccupancyVsSector->SetMarkerStyle(20);
@@ -223,13 +227,13 @@ void AliTPCQADataMakerRec::InitRaws()
     Add2RawsList(histRawsOccupancyVsSector, kRawsOccupancyVsSector, expert, image, !saveCorr);
   else
     Add2RawsList(histRawsOccupancyVsSector, kRawsOccupancyVsSector, !expert, image, !saveCorr);
-    
-  TProfile * histRawsQVsSector = 
+
+  TProfile * histRawsQVsSector =
     new TProfile("hRawsQVsSector", "<Q> vs sector; Sector; <Q>",
 	     72, 0, 72);
   Add2RawsList(histRawsQVsSector, kRawsQVsSector, expert, !image, !saveCorr);
 
-  TProfile * histRawsQmaxVsSector = 
+  TProfile * histRawsQmaxVsSector =
     new TProfile("hRawsQmaxVsSector", "<Qmax> vs sector; Sector; <Qmax>",
 	     72, 0, 72);
   histRawsQmaxVsSector->SetMarkerStyle(20);
@@ -240,7 +244,7 @@ void AliTPCQADataMakerRec::InitRaws()
   else
     Add2RawsList(histRawsQmaxVsSector, kRawsQmaxVsSector, !expert, image, !saveCorr);
 
-  TProfile2D * histRawsOccupancy2dVsSector = 
+  TProfile2D * histRawsOccupancy2dVsSector =
     new TProfile2D("hRawsOccupancy2dVsSector", "Occupancy vs sector; Sector; Patch",
 		   72, 0, 36, 6, 0, 6);
   histRawsOccupancy2dVsSector->SetOption("COLZ");
@@ -249,17 +253,17 @@ void AliTPCQADataMakerRec::InitRaws()
     Add2RawsList(histRawsOccupancy2dVsSector, kRawsOccupancy2dVsSector, expert, image, !saveCorr);
   else
     Add2RawsList(histRawsOccupancy2dVsSector, kRawsOccupancy2dVsSector, !expert, image, !saveCorr);
-    
+
   //
   ClonePerTrigClass(AliQAv1::kRAWS); // this should be the last line
 }
 
-//____________________________________________________________________________ 
+//____________________________________________________________________________
 void AliTPCQADataMakerRec::InitDigits()
 {
-  const Bool_t expert   = kTRUE ; 
-  const Bool_t image    = kTRUE ; 
-  TH1F * histDigitsADC = 
+  const Bool_t expert   = kTRUE ;
+  const Bool_t image    = kTRUE ;
+  TH1F * histDigitsADC =
     new TH1F("hDigitsADC", "Digit ADC distribution; ADC; Counts",
              1000, 0, 1000);
   histDigitsADC->Sumw2();
@@ -268,49 +272,49 @@ void AliTPCQADataMakerRec::InitDigits()
   ClonePerTrigClass(AliQAv1::kDIGITS); // this should be the last line
 }
 
-//____________________________________________________________________________ 
+//____________________________________________________________________________
 void AliTPCQADataMakerRec::InitRecPoints()
 {
-  const Bool_t expert   = kTRUE ; 
-  const Bool_t image    = kTRUE ; 
-  
-  TH1F * histRecPointsQmaxShort = 
+  const Bool_t expert   = kTRUE ;
+  const Bool_t image    = kTRUE ;
+
+  TH1F * histRecPointsQmaxShort =
     new TH1F("hRecPointsQmaxShort", "Qmax distrbution (short pads); Qmax; Counts",
 	     100, 0, 300);
   histRecPointsQmaxShort->Sumw2();
   Add2RecPointsList(histRecPointsQmaxShort, kQmaxShort, !expert, image);
 
-  TH1F * histRecPointsQmaxMedium = 
+  TH1F * histRecPointsQmaxMedium =
     new TH1F("hRecPointsQmaxMedium", "Qmax distrbution (medium pads); Qmax; Counts",
 	     100, 0, 300);
   histRecPointsQmaxMedium->Sumw2();
   Add2RecPointsList(histRecPointsQmaxMedium, kQmaxMedium, !expert, image);
 
-  TH1F * histRecPointsQmaxLong = 
+  TH1F * histRecPointsQmaxLong =
     new TH1F("hRecPointsQmaxLong", "Qmax distrbution (long pads); Qmax; Counts",
 	     100, 0, 300);
   histRecPointsQmaxLong->Sumw2();
   Add2RecPointsList(histRecPointsQmaxLong, kQmaxLong, !expert, image);
 
-  TH1F * histRecPointsQShort = 
+  TH1F * histRecPointsQShort =
     new TH1F("hRecPointsQShort", "Q distrbution (short pads); Q; Counts",
 	     100, 0, 2000);
   histRecPointsQShort->Sumw2();
   Add2RecPointsList(histRecPointsQShort, kQShort, !expert, image);
 
-  TH1F * histRecPointsQMedium = 
+  TH1F * histRecPointsQMedium =
     new TH1F("hRecPointsQMedium", "Q distrbution (medium pads); Q; Counts",
 	     100, 0, 2000);
   histRecPointsQMedium->Sumw2();
   Add2RecPointsList(histRecPointsQMedium, kQMedium, !expert, image);
 
-  TH1F * histRecPointsQLong = 
+  TH1F * histRecPointsQLong =
     new TH1F("hRecPointsQLong", "Q distrbution (long pads); Q; Counts",
 	     100, 0, 2000);
   histRecPointsQLong->Sumw2();
   Add2RecPointsList(histRecPointsQLong, kQLong, !expert, image);
 
-  TH1F * histRecPointsRow = 
+  TH1F * histRecPointsRow =
     new TH1F("hRecPointsRow", "Clusters per row; Row; Counts",
 	     159, 0, 159);
   histRecPointsRow->Sumw2();
@@ -322,25 +326,25 @@ void AliTPCQADataMakerRec::InitRecPoints()
 //____________________________________________________________________________
 void AliTPCQADataMakerRec::MakeESDs(AliESDEvent * esd)
 {
-  // make QA data from ESDs
- 
+  /// make QA data from ESDs
+
   const Int_t nESDTracks = esd->GetNumberOfTracks();
-  Int_t nTPCtracks = 0; 
+  Int_t nTPCtracks = 0;
   for(Int_t i = 0; i < nESDTracks; i++) {
-    
+
     AliESDtrack * track = esd->GetTrack(i);
-    
+
     if ((track->GetStatus() & AliESDtrack::kTPCrefit)==0)
       continue;
-    
+
     nTPCtracks++;
-    
+
     Int_t nTPCclusters         = track->GetTPCNcls();
     Int_t nTPCclustersFindable = track->GetTPCNclsF();
     if ( nTPCclustersFindable<=0) continue;
     FillESDsData(kClusters,nTPCclusters);
     FillESDsData(kRatio,Float_t(nTPCclusters)/Float_t(nTPCclustersFindable));
-    FillESDsData(kPt,track->Pt()); 
+    FillESDsData(kPt,track->Pt());
   }
   //
   IncEvCountCycleESDs();
@@ -351,29 +355,27 @@ void AliTPCQADataMakerRec::MakeESDs(AliESDEvent * esd)
 //____________________________________________________________________________
 void AliTPCQADataMakerRec::MakeRaws(AliRawReader* rawReader)
 {
-  //
-  // To make QA for the RAW data we use the TPC Calibration framework 
-  // to handle the data and then in the end extract the data
-  //
-  
+  /// To make QA for the RAW data we use the TPC Calibration framework
+  /// to handle the data and then in the end extract the data
+
   GetRawsData(0); // dummy call to init raw data
-  rawReader->Reset() ; 
+  rawReader->Reset() ;
   if (! fTPCdataQA ) {
 
-    AliError("No TPC data QA (no call to InitRaws?)!!!!") ; 
-  } else {  
+    AliError("No TPC data QA (no call to InitRaws?)!!!!") ;
+  } else {
 
     if(fTPCdataQA->GetIsDQM() == kFALSE)
-      AliError("Data QA has to be initialized as DQM!!!!") ; 
+      AliError("Data QA has to be initialized as DQM!!!!") ;
 
     // Fill profile data
     fTPCdataQA->ResetProfiles();
-    
-    if(fTPCdataQA->ProcessEvent(rawReader)) { // means that TPC data was processed  
+
+    if(fTPCdataQA->ProcessEvent(rawReader)) { // means that TPC data was processed
 
       fTPCdataQA->FillOccupancyProfile();
-      
-      // Fill histograms    
+
+      // Fill histograms
       TObjArray *arrRW = GetMatchingRawsData(kRawsOccupancyVsSector); // all kRawsOccupancyVsSector clones matching to triggers
       for (int ih=arrRW->GetEntriesFast();ih--;) {
 	TProfile* hRawsOccupancyVsSector = dynamic_cast<TProfile*>(arrRW->At(ih));
@@ -405,23 +407,23 @@ void AliTPCQADataMakerRec::MakeRaws(AliRawReader* rawReader)
 //____________________________________________________________________________
 void AliTPCQADataMakerRec::MakeDigits(TTree* digitTree)
 {
- 
+
   TBranch* branch = digitTree->GetBranch("Segment");
   AliSimDigits* digArray = 0;
   branch->SetAddress(&digArray);
-  
+
   Int_t nEntries = Int_t(digitTree->GetEntries());
-  
+
   for (Int_t n = 0; n < nEntries; n++) {
-    
+
     digitTree->GetEvent(n);
-    
+
     if (digArray->First())
       do {
         Float_t dig = digArray->CurrentDigit();
-        
+
         FillDigitsData(kDigitsADC,dig);
-      } while (digArray->Next());    
+      } while (digArray->Next());
   }
   //
   IncEvCountCycleDigits();
@@ -432,15 +434,15 @@ void AliTPCQADataMakerRec::MakeDigits(TTree* digitTree)
 //____________________________________________________________________________
 void AliTPCQADataMakerRec::MakeRecPoints(TTree* recTree)
 {
-  
+
   AliTPCClustersRow* clrow = 0x0;
-  TBranch* branch = recTree->GetBranch("Segment");  
+  TBranch* branch = recTree->GetBranch("Segment");
   branch->SetAddress(&clrow);
   TClonesArray * clarray = 0x0;
 
   const Int_t nEntries = Int_t(recTree->GetEntries());
   for (Int_t i = 0; i < nEntries; i++) {
-    
+
     branch->GetEntry(i);
 
     clarray = clrow->GetArray();
@@ -449,10 +451,10 @@ void AliTPCQADataMakerRec::MakeRecPoints(TTree* recTree)
 
     const Int_t nClusters = clarray->GetEntriesFast();
     for (Int_t icl=0; icl < nClusters; icl++){
-      
-      AliTPCclusterMI* cluster = 
+
+      AliTPCclusterMI* cluster =
 	(AliTPCclusterMI*)clarray->At(icl);
-      
+
       Float_t Qmax = cluster->GetMax();
       Float_t Q    = cluster->GetQ();
       Int_t   row  = cluster->GetRow();
@@ -473,7 +475,7 @@ void AliTPCQADataMakerRec::MakeRecPoints(TTree* recTree)
 	  FillRecPointsData(kQLong,Q);
 	}
       }
-      
+
       FillRecPointsData(kRow,row);
     } // end loop over clusters
   } // end loop over tree
diff --git a/TPC/TPCbase/AliTPCQADataMakerRec.h b/TPC/TPCbase/AliTPCQADataMakerRec.h
index 56a5f7129eb..005da1ceb76 100644
--- a/TPC/TPCbase/AliTPCQADataMakerRec.h
+++ b/TPC/TPCbase/AliTPCQADataMakerRec.h
@@ -3,16 +3,12 @@
 /* Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-
-/* $Id: $ */
-
-/*
-  Based on AliPHOSQADataMaker
-  Produces the data needed to calculate the quality assurance. 
-  All data must be mergeable objects.
-  P. Christiansen, Lund, January 2008
-*/
-
+/// \class AliTPCQADataMakerRec
+/// \brief Based on AliPHOSQADataMaker: produces the data needed to calculate the quality assurance.
+///
+/// All data must be mergeable objects.
+/// \author P. Christiansen, Lund,
+/// \date January 2008
 
 // --- ROOT system ---
 
@@ -28,51 +24,53 @@
 class AliTPCQADataMakerRec: public AliQADataMakerRec {
 
 public:
-  enum HRawsType_t         {kRawsOccupancyVsSector=0, kRawsQVsSector, kRawsQmaxVsSector, kRawsOccupancy2dVsSector} ; 
-  enum HDigitType_t        {kDigitsADC=0} ; 
-  enum HRECPOINTsType_t    {kClusters=0, kRatio, kPt} ; 
-  enum HESDsType_t         {kQmaxShort=0, kQmaxMedium, kQmaxLong, kQShort, kQMedium, kQLong, kRow} ; 
+  enum HRawsType_t         {kRawsOccupancyVsSector=0, kRawsQVsSector, kRawsQmaxVsSector, kRawsOccupancy2dVsSector} ;
+  enum HDigitType_t        {kDigitsADC=0} ;
+  enum HRECPOINTsType_t    {kClusters=0, kRatio, kPt} ;
+  enum HESDsType_t         {kQmaxShort=0, kQmaxMedium, kQmaxLong, kQShort, kQMedium, kQLong, kRow} ;
 
   AliTPCQADataMakerRec() ;          // ctor
-  AliTPCQADataMakerRec(const AliTPCQADataMakerRec& qadm) ;   
+  AliTPCQADataMakerRec(const AliTPCQADataMakerRec& qadm) ;
   AliTPCQADataMakerRec& operator = (const AliTPCQADataMakerRec& qadm) ;
-  virtual ~AliTPCQADataMakerRec(); 
-  
+  virtual ~AliTPCQADataMakerRec();
+
   Int_t  GetRawFirstTimeBin() const { return fRawFirstTimeBin; }
   Int_t  GetRawLastTimeBin()  const { return fRawLastTimeBin;  }
-  
+
   void  SetRawRangeTime(Int_t tMin, Int_t tMax){ fRawFirstTimeBin=tMin; fRawLastTimeBin=tMax;}
-  
+
  private:
-  virtual void   StartOfDetectorCycle() {}; // empty 
+  virtual void   StartOfDetectorCycle() {}; // empty
   virtual void   EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray** list) ;
-  
+
   // ESD QA
-  virtual void   InitESDs() ; 
+  virtual void   InitESDs() ;
   virtual void   MakeESDs(AliESDEvent *esd) ;
-  
+
   // Raw QA
   virtual void   InitRaws();
   virtual void   MakeRaws(AliRawReader* rawReader);
-  
+
   // Digits QA
   virtual void   InitDigits();
   virtual void   MakeDigits()  {return;}
   virtual void   MakeDigits(TTree *digTree);
-  
+
   // RecPoints QA
   virtual void   InitRecPoints();
   virtual void   MakeRecPoints(TTree *recTree);
-  
+
   virtual void LoadMaps();
-  
-  AliTPCAltroMapping *fMapping[6]; //! Pointers to ALTRO mapping
-  AliTPCdataQA*  fTPCdataQA;//! TPC calibration object for making raw data QA
-  
-  Int_t fRawFirstTimeBin;   //! First Time bin needed for RAW QA
-  Int_t fRawLastTimeBin;    //! Last Time bin needed for RAW QA
-  
-  ClassDef(AliTPCQADataMakerRec,1)  // TPC Rec Quality Assurance Data Maker 
+
+  AliTPCAltroMapping *fMapping[6]; //!< Pointers to ALTRO mapping
+  AliTPCdataQA*  fTPCdataQA;//!< TPC calibration object for making raw data QA
+
+  Int_t fRawFirstTimeBin;   //!< First Time bin needed for RAW QA
+  Int_t fRawLastTimeBin;    //!< Last Time bin needed for RAW QA
+
+  /// \cond CLASSIMP
+  ClassDef(AliTPCQADataMakerRec,1)  // TPC Rec Quality Assurance Data Maker
+  /// \endcond
     };
 
 #endif // ALITPCQADATAMAKERREC_H
diff --git a/TPC/TPCbase/AliTPCRF1D.cxx b/TPC/TPCbase/AliTPCRF1D.cxx
index 4e0243191bd..570082fb3be 100644
--- a/TPC/TPCbase/AliTPCRF1D.cxx
+++ b/TPC/TPCbase/AliTPCRF1D.cxx
@@ -13,20 +13,12 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/* $Id$ */
 
 
-//-----------------------------------------------------------------------------
-//
-//
-//
-//  Origin:   Marian Ivanov, Uni. of Bratislava, ivanov@fmph.uniba.sk
-//
-//  Declaration of class AliTPCRF1D
-//
-//-----------------------------------------------------------------------------
-
-//
+/// \class AliTPCRF1D
+/// \brief Declaration of class AliTPCRF1D
+///
+/// \author Marian Ivanov, Uni. of Bratislava, ivanov@fmph.uniba.sk
 
 #include <RVersion.h>
 #include <Riostream.h>
@@ -41,26 +33,29 @@
 
 #include "AliTPCRF1D.h"
 
-extern TStyle * gStyle; 
+extern TStyle * gStyle;
 
-Int_t   AliTPCRF1D::fgNRF=100;  //default  number of interpolation points
-Float_t AliTPCRF1D::fgRFDSTEP=0.01; //default step in cm
+Int_t   AliTPCRF1D::fgNRF=100;  ///< default  number of interpolation points
+Float_t AliTPCRF1D::fgRFDSTEP=0.01; ///< default step in cm
 
 static Double_t funGauss(Double_t *x, Double_t * par)
 {
-  //Gauss function  -needde by the generic function object 
+  /// Gauss function  -needde by the generic function object
+
   return TMath::Exp(-(x[0]*x[0])/(2*par[0]*par[0]));
 }
 
 static Double_t funCosh(Double_t *x, Double_t * par)
 {
-  //Cosh function  -needde by the generic function object 
-  return 1/TMath::CosH(3.14159*x[0]/(2*par[0]));  
-}    
+  /// Cosh function  -needde by the generic function object
+
+  return 1/TMath::CosH(3.14159*x[0]/(2*par[0]));
+}
 
 static Double_t funGati(Double_t *x, Double_t * par)
 {
-  //Gati function  -needde by the generic function object 
+  /// Gati function  -needde by the generic function object
+
   Float_t k3=par[1];
   Float_t k3R=TMath::Sqrt(k3);
   Float_t k2=(TMath::Pi()/2)*(1-k3R/2.);
@@ -68,14 +63,16 @@ static Double_t funGati(Double_t *x, Double_t * par)
   Float_t l=x[0]/par[0];
   Float_t tan2=TMath::TanH(k2*l);
   tan2*=tan2;
-  Float_t res = k1*(1-tan2)/(1+k3*tan2);  
-  return res;  
-}    
+  Float_t res = k1*(1-tan2)/(1+k3*tan2);
+  return res;
+}
 
 ///////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////
 
+/// \cond CLASSIMP
 ClassImp(AliTPCRF1D)
+/// \endcond
 
 
 AliTPCRF1D::AliTPCRF1D(Bool_t direct,Int_t np,Float_t step)
@@ -104,7 +101,7 @@ AliTPCRF1D::AliTPCRF1D(Bool_t direct,Int_t np,Float_t step)
     funParam[i]=0.;
     fType[i]=0;
   }
-  
+
 }
 
 AliTPCRF1D::AliTPCRF1D(const AliTPCRF1D &prf)
@@ -176,28 +173,28 @@ AliTPCRF1D::~AliTPCRF1D()
 Float_t AliTPCRF1D::GetRF(Float_t xin)
 {
   //function which return response
-  //for the charge in distance xin 
+  //for the charge in distance xin
   //return linear aproximation of RF
   Float_t x = (xin-fOffset)*fDSTEPM1+fNRF/2;
   Int_t i1=Int_t(x);
   if (x<0) i1-=1;
   Float_t res=0;
   if (i1+1<fNRF &&i1>0)
-    res = fcharge[i1]*(Float_t(i1+1)-x)+fcharge[i1+1]*(x-Float_t(i1));    
+    res = fcharge[i1]*(Float_t(i1+1)-x)+fcharge[i1+1]*(x-Float_t(i1));
   return res;
 }
 
 Float_t  AliTPCRF1D::GetGRF(Float_t xin)
-{  
+{
   //function which returnoriginal charge distribution
   //this function is just normalised for fKnorm
-  if (fGRF != 0 ) 
+  if (fGRF != 0 )
     return fkNorm*fGRF->Eval(xin)/fInteg;
       else
     return 0.;
 }
 
-   
+
 void AliTPCRF1D::SetParam( TF1 * GRF,Float_t padwidth,
 		       Float_t kNorm, Float_t sigma)
 {
@@ -208,17 +205,17 @@ void AliTPCRF1D::SetParam( TF1 * GRF,Float_t padwidth,
    fkNorm = kNorm;
    if (sigma==0) sigma= fpadWidth/TMath::Sqrt(12.);
    forigsigma=sigma;
-   fDSTEPM1 = 10/TMath::Sqrt(sigma*sigma+fpadWidth*fpadWidth/12); 
+   fDSTEPM1 = 10/TMath::Sqrt(sigma*sigma+fpadWidth*fpadWidth/12);
    //sprintf(fType,"User");
    snprintf(fType,5,"User");
-   //   Update();   
+   //   Update();
 }
-  
+
 
 void AliTPCRF1D::SetGauss(Float_t sigma, Float_t padWidth,
 		      Float_t kNorm)
 {
-  // 
+  //
   // set parameters for Gauss generic charge distribution
   //
   fpadWidth = padWidth;
@@ -228,8 +225,8 @@ void AliTPCRF1D::SetGauss(Float_t sigma, Float_t padWidth,
   funParam[0]=sigma;
   forigsigma=sigma;
   fGRF->SetParameters(funParam);
-   fDSTEPM1 = 10./TMath::Sqrt(sigma*sigma+fpadWidth*fpadWidth/12); 
-  //by default I set the step as one tenth of sigma  
+   fDSTEPM1 = 10./TMath::Sqrt(sigma*sigma+fpadWidth*fpadWidth/12);
+  //by default I set the step as one tenth of sigma
   //sprintf(fType,"Gauss");
    snprintf(fType,5,"Gauss");
 }
@@ -237,17 +234,17 @@ void AliTPCRF1D::SetGauss(Float_t sigma, Float_t padWidth,
 void AliTPCRF1D::SetCosh(Float_t sigma, Float_t padWidth,
 		     Float_t kNorm)
 {
-  // 
+  //
   // set parameters for Cosh generic charge distribution
   //
   fpadWidth = padWidth;
   fkNorm = kNorm;
   if (fGRF !=0 ) fGRF->Delete();
-  fGRF = new TF1("funCosh",	funCosh, -5.,5.,2);   
+  fGRF = new TF1("funCosh",	funCosh, -5.,5.,2);
   funParam[0]=sigma;
   fGRF->SetParameters(funParam);
   forigsigma=sigma;
-  fDSTEPM1 = 10./TMath::Sqrt(sigma*sigma+fpadWidth*fpadWidth/12); 
+  fDSTEPM1 = 10./TMath::Sqrt(sigma*sigma+fpadWidth*fpadWidth/12);
   //by default I set the step as one tenth of sigma
   //sprintf(fType,"Cosh");
   snprintf(fType,5,"Cosh");
@@ -256,18 +253,18 @@ void AliTPCRF1D::SetCosh(Float_t sigma, Float_t padWidth,
 void AliTPCRF1D::SetGati(Float_t K3, Float_t padDistance, Float_t padWidth,
 		     Float_t kNorm)
 {
-  // 
+  //
   // set parameters for Gati generic charge distribution
   //
   fpadWidth = padWidth;
   fkNorm = kNorm;
   if (fGRF !=0 ) fGRF->Delete();
-  fGRF = new TF1("funGati",	funGati, -5.,5.,2);   
+  fGRF = new TF1("funGati",	funGati, -5.,5.,2);
   funParam[0]=padDistance;
-  funParam[1]=K3;  
+  funParam[1]=K3;
   fGRF->SetParameters(funParam);
   forigsigma=padDistance;
-  fDSTEPM1 = 10./TMath::Sqrt(padDistance*padDistance+fpadWidth*fpadWidth/12); 
+  fDSTEPM1 = 10./TMath::Sqrt(padDistance*padDistance+fpadWidth*fpadWidth/12);
   //by default I set the step as one tenth of sigma
   //sprintf(fType,"Gati");
   snprintf(fType,5,"Gati");
@@ -276,7 +273,7 @@ void AliTPCRF1D::SetGati(Float_t K3, Float_t padDistance, Float_t padWidth,
 
 
 void AliTPCRF1D::DrawRF(Float_t x1,Float_t x2,Int_t N)
-{ 
+{
   //
   //Draw prf in selected region <x1,x2> with nuber of diviision = n
   //
@@ -289,13 +286,13 @@ void AliTPCRF1D::DrawRF(Float_t x1,Float_t x2,Int_t N)
   pad2->Draw();
 
   //sprintf(s,"RF response function for %1.2f cm pad width",
-  //	  fpadWidth); 
-  snprintf(s,60,"RF response function for %1.2f cm pad width",fpadWidth); 
+  //	  fpadWidth);
+  snprintf(s,60,"RF response function for %1.2f cm pad width",fpadWidth);
   pad1->cd();
   TH1F * hRFo = new TH1F("hRFo","Original charge distribution",N+1,x1,x2);
   pad2->cd();
    gStyle->SetOptFit(1);
-   gStyle->SetOptStat(0); 
+   gStyle->SetOptStat(0);
   TH1F * hRFc = new TH1F("hRFc",s,N+1,x1,x2);
   Float_t x=x1;
   Float_t y1;
@@ -307,7 +304,7 @@ void AliTPCRF1D::DrawRF(Float_t x1,Float_t x2,Int_t N)
       y1 = GetRF(x);
       hRFc->Fill(x,y1);
       y2 = GetGRF(x);
-      hRFo->Fill(x,y2);      
+      hRFo->Fill(x,y2);
     };
   pad1->cd();
   hRFo->Fit("gaus");
@@ -324,7 +321,7 @@ void AliTPCRF1D::Update()
   //at the begining initialize to 0
   for (Int_t i =0; i<fNRF;i++)  fcharge[i] = 0;
   if ( fGRF == 0 ) return;
-  // This form is no longer available 
+  // This form is no longer available
 #if ROOT_VERSION_CODE < ROOT_VERSION(5,99,0)
   fInteg  = fGRF->Integral(-5*forigsigma,5*forigsigma,funParam,0.00001);
 #else
@@ -332,7 +329,7 @@ void AliTPCRF1D::Update()
   fGRF->SetParameters(funParam);
   fInteg  = fGRF->Integral(-5*forigsigma,5*forigsigma,0.00001);
 #endif
-  if ( fInteg == 0 ) fInteg = 1; 
+  if ( fInteg == 0 ) fInteg = 1;
   if (fDirect==kFALSE){
   //integrate charge over pad for different distance of pad
   for (Int_t i =0; i<fNRF;i++)
@@ -345,30 +342,30 @@ void AliTPCRF1D::Update()
 #else
       fcharge[i] = fkNorm*fGRF->Integral(x1,x2,0.0001)/fInteg;
 #endif
-    };   
+    };
   }
   else{
     for (Int_t i =0; i<fNRF;i++)
       {      //x in cm fpadWidth in cm
 	Float_t x = (Float_t)(i-fNRF/2)/fDSTEPM1;
 	fcharge[i] = fkNorm*fGRF->Eval(x);
-      };   
-  }  
-  fSigma = 0; 
+      };
+  }
+  fSigma = 0;
   Float_t sum =0;
   Float_t mean=0;
   for (Float_t  x =-fNRF/fDSTEPM1; x<fNRF/fDSTEPM1;x+=1/fDSTEPM1)
     {      //x in cm fpadWidth in cm
       Float_t weight = GetRF(x+fOffset);
-      fSigma+=x*x*weight; 
+      fSigma+=x*x*weight;
       mean+=x*weight;
       sum+=weight;
-    };  
+    };
   if (sum>0){
     mean/=sum;
-    fSigma = TMath::Sqrt(fSigma/sum-mean*mean);   
+    fSigma = TMath::Sqrt(fSigma/sum-mean*mean);
   }
-  else fSigma=0; 
+  else fSigma=0;
 #if ROOT_VERSION_CODE >= ROOT_VERSION(5,99,0)
   fGRF->SetParameters(savParam.GetArray());
 #endif
@@ -380,11 +377,11 @@ void AliTPCRF1D::Streamer(TBuffer &R__b)
    if (R__b.IsReading()) {
       AliTPCRF1D::Class()->ReadBuffer(R__b, this);
       //read functions
- 
+
       if (strncmp(fType,"Gauss",3)==0) {delete fGRF; fGRF = new TF1("funGauss",funGauss,-5.,5.,4);}
       if (strncmp(fType,"Cosh",3)==0)  {delete fGRF; fGRF = new TF1("funCosh",funCosh,-5.,5.,4);}
-      if (strncmp(fType,"Gati",3)==0)  {delete fGRF; fGRF = new TF1("funGati",funGati,-5.,5.,4);}  
-      if (fGRF) fGRF->SetParameters(funParam);     
+      if (strncmp(fType,"Gati",3)==0)  {delete fGRF; fGRF = new TF1("funGati",funGati,-5.,5.,4);}
+      if (fGRF) fGRF->SetParameters(funParam);
 
    } else {
       AliTPCRF1D::Class()->WriteBuffer(R__b, this);
@@ -401,4 +398,4 @@ Double_t  AliTPCRF1D::Gamma4(Double_t x, Double_t p0, Double_t p1){
   Double_t g2 = TMath::Power(x/p1,4);
   return p0*g1*g2;
 }
- 
+
diff --git a/TPC/TPCbase/AliTPCRF1D.h b/TPC/TPCbase/AliTPCRF1D.h
index b09a591b7a9..33ea045f55e 100644
--- a/TPC/TPCbase/AliTPCRF1D.h
+++ b/TPC/TPCbase/AliTPCRF1D.h
@@ -3,12 +3,10 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-/* $Id$ */
 
-////////////////////////////////////////////////
-//  Manager class for AliTPCRF1D              //
-//////////////////////////////////////////////// 
-  
+/// \class AliTPCRF1D
+/// \brief Manager class for AliTPCRF1D
+
 
 // include files and class forward declarations
 
@@ -19,62 +17,65 @@ class TF1;
 
 
 class AliTPCRF1D : public TObject {
-public : 
-  AliTPCRF1D(Bool_t direct=kFALSE,Int_t np=0,Float_t step=0 ); 
+public :
+  AliTPCRF1D(Bool_t direct=kFALSE,Int_t np=0,Float_t step=0 );
   AliTPCRF1D(const AliTPCRF1D &prf);
   AliTPCRF1D & operator = (const AliTPCRF1D &prf);
-  ~AliTPCRF1D();  
+  ~AliTPCRF1D();
   Float_t GetRF(Float_t xin); //return RF in point xin
   Float_t GetGRF(Float_t xin); //return generic response function  in xin
   void SetGauss(Float_t sigma,Float_t padWidth, Float_t kNorm);
-  //adjust RF with GAUSIAN as generic GRF 
+  //adjust RF with GAUSIAN as generic GRF
   //if  direct = kTRUE then it does't convolute distribution
   void SetCosh(Float_t sigma,Float_t padWidth, Float_t kNorm);
   void SetGati(Float_t K3, Float_t padDistance, Float_t padWidth,
 	       Float_t kNorm);
   //adjust RF with 1/Cosh  as generic GRF
-  void SetParam(TF1 * GRF,Float_t padwidth,Float_t kNorm, 
+  void SetParam(TF1 * GRF,Float_t padwidth,Float_t kNorm,
 		Float_t sigma=0);
-  //adjust RF with general function 
+  //adjust RF with general function
   void SetOffset(Float_t xoff) {fOffset=xoff;}
-  //set offset value 
+  //set offset value
   Float_t GetOffset(){return fOffset;}
-  Float_t GetPadWidth(){ return fpadWidth;};       
-  //return  pad width 
+  Float_t GetPadWidth(){ return fpadWidth;};
+  //return  pad width
   Float_t  GetSigma(){return fSigma;}
   //return estimated sigma of RF
   void DrawRF(Float_t x1=-3 ,Float_t x2 =3.,Int_t N = 200);
   //draw RF it don't delete histograms after drawing
   /// it's on user !!!!
-  void Update();  
+  void Update();
   static Double_t Gamma4(Double_t x, Double_t p0, Double_t p1);
-private: 
-  Double_t funParam[5];//parameters of used charge function
-  Int_t  fNRF;      //number of interpolations point
-  Float_t fDSTEPM1;    //element step for point
-  Float_t* fcharge; //[fNPRF] field with RF
-  Float_t  forigsigma;//sigma of original distribution;
-  Float_t fpadWidth;  //width of pad
-  Float_t fkNorm;     //normalisation factor of the charge integral
-  Float_t fInteg;     //integral of GRF on +- infinity
-  TF1 *  fGRF;        //charge distribution function
-  Float_t fSigma;     //sigma of PAD response function
-
-  Float_t fOffset;    //offset of response function (for time reponse we 
+private:
+  Double_t funParam[5];///< parameters of used charge function
+  Int_t  fNRF;      ///< number of interpolations point
+  Float_t fDSTEPM1;    ///< element step for point
+  /// field with RF
+  Float_t* fcharge; //[fNPRF]
+  Float_t  forigsigma;///< sigma of original distribution;
+  Float_t fpadWidth;  ///< width of pad
+  Float_t fkNorm;     ///< normalisation factor of the charge integral
+  Float_t fInteg;     ///< integral of GRF on +- infinity
+  TF1 *  fGRF;        ///< charge distribution function
+  Float_t fSigma;     ///< sigma of PAD response function
+
+  Float_t fOffset;    ///< offset of response function (for time reponse we
   //have for expample shifted gauss)
   //calculated during update
- 
-  Bool_t fDirect;     //tell us if we use directly generalfunction
-  
-  Float_t fPadDistance;   //pad to wire distance
-  char  fType[5];     //type of the parametrisation
-  static Int_t   fgNRF;//default  number of interpolation points
-  static Float_t fgRFDSTEP;//default step in cm
+
+  Bool_t fDirect;     ///< tell us if we use directly generalfunction
+
+  Float_t fPadDistance;   ///< pad to wire distance
+  char  fType[5];     ///< type of the parametrisation
+  static Int_t   fgNRF;///< default  number of interpolation points
+  static Float_t fgRFDSTEP;///< default step in cm
+  /// \cond CLASSIMP
   ClassDef(AliTPCRF1D,2)
-}; 
+  /// \endcond
+};
 
 
 
 
 #endif /* ALITPCRF1D_H */
-  
+
diff --git a/TPC/TPCbase/AliTPCROC.cxx b/TPC/TPCbase/AliTPCROC.cxx
index 40fb279f42e..cedcc5922f6 100644
--- a/TPC/TPCbase/AliTPCROC.cxx
+++ b/TPC/TPCbase/AliTPCROC.cxx
@@ -14,16 +14,15 @@
  **************************************************************************/
 
 
-///////////////////////////////////////////////////////////////////////////////
-//                                                                           //
-//  Geometry        class for a single ROC                                   //
-//                                                                           //
-//                                                                           //
-///////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCROC
+/// \brief Geometry class for a single ROC
+
 #include "AliTPCROC.h"
 #include "TMath.h"
 
+/// \cond CLASSIMP
 ClassImp(AliTPCROC)
+/// \endcond
 
 
 AliTPCROC* AliTPCROC::fgInstance = 0;
@@ -34,13 +33,12 @@ AliTPCROC* AliTPCROC::fgInstance = 0;
 //_ singleton implementation __________________________________________________
 AliTPCROC* AliTPCROC::Instance()
 {
-  //
-  // Singleton implementation
-  // Returns an instance of this class, it is created if neccessary
-  //
+  /// Singleton implementation
+  /// Returns an instance of this class, it is created if neccessary
+
   if (fgInstance == 0){
     fgInstance = new AliTPCROC();
-    fgInstance->Init();    
+    fgInstance->Init();
   }
   return fgInstance;
 }
@@ -49,9 +47,8 @@ AliTPCROC* AliTPCROC::Instance()
 
 
 void AliTPCROC::Init(){
-  //
-  // initialize static variables
-  //
+  /// initialize static variables
+
   if (AliTPCROC::fNSectorsAll>0) return;
   fNSectorsAll =72;
   fNSectors[0] =36;
@@ -62,7 +59,7 @@ void AliTPCROC::Init(){
   //
   // number of pads in padrow
   fNPads[0] = new UInt_t[fNRows[0]];
-  fNPads[1] = new UInt_t[fNRows[1]];  
+  fNPads[1] = new UInt_t[fNRows[1]];
   //
   // padrow index in array
   //
@@ -83,8 +80,8 @@ void AliTPCROC::Init(){
   index =0;
   Double_t k1 = 10.*TMath::Tan(10*TMath::DegToRad())/6.;
   Double_t k2 = 15.*TMath::Tan(10*TMath::DegToRad())/6.;
-  for (UInt_t irow=0; irow<fNRows[1];irow++){    
-    UInt_t npads = (irow<64) ? 
+  for (UInt_t irow=0; irow<fNRows[1];irow++){
+    UInt_t npads = (irow<64) ?
       2*Int_t(k1*Double_t(irow)+37.75):
       2*Int_t(k2*Double_t(irow-64)+56.66);
     fNPads[1][irow] = npads;
@@ -100,9 +97,8 @@ void AliTPCROC::Init(){
 
 void AliTPCROC::SetGeometry()
 {
-  //
-  //set ROC geometry parameters
-  //
+  /// set ROC geometry parameters
+
   const  Float_t kInnerRadiusLow = 83.65;
   const  Float_t kInnerRadiusUp  = 133.3;
   const  Float_t kOuterRadiusLow = 133.5;
@@ -120,7 +116,7 @@ void AliTPCROC::SetGeometry()
   const  Float_t kOuterAngle = 20; // 20 degrees
   //
   //  pad     parameters
-  // 
+  //
   const Float_t  kInnerPadPitchLength = 0.75;
   const Float_t  kInnerPadPitchWidth = 0.40;
   const Float_t  kInnerPadLength = 0.75;
@@ -130,7 +126,7 @@ void AliTPCROC::SetGeometry()
   const Float_t  kOuter1PadLength = 1.0;
   const Float_t  kOuterPadWidth = 0.6;
   const Float_t  kOuter2PadPitchLength = 1.5;
-  const Float_t  kOuter2PadLength = 1.5;  
+  const Float_t  kOuter2PadLength = 1.5;
 
   //
   //wires default parameters
@@ -143,7 +139,7 @@ void AliTPCROC::SetGeometry()
 //   const Float_t  kInnerOffWire = 0.5;
 //   const UInt_t    kNOuter1WiresPerPad = 4;
 //   const UInt_t    kNOuter2WiresPerPad = 6;
-//   const Float_t  kOuterWWPitch = 0.25;  
+//   const Float_t  kOuterWWPitch = 0.25;
 //   const Float_t  kROuterFirstWire = 134.225;
 //   const Float_t  kROuterLastWire = 246.975;
 //   const UInt_t    kOuterDummyWire = 2;
@@ -154,7 +150,7 @@ void AliTPCROC::SetGeometry()
   fInnerRadiusLow = kInnerRadiusLow;
   fOuterRadiusLow = kOuterRadiusLow;
   fInnerRadiusUp  = kInnerRadiusUp;
-  fOuterRadiusUp  = kOuterRadiusUp;  
+  fOuterRadiusUp  = kOuterRadiusUp;
   fInnerFrameSpace = kInnerFrameSpace;
   fOuterFrameSpace = kOuterFrameSpace;
   fInnerWireMount  = kInnerWireMount;
@@ -174,12 +170,12 @@ void AliTPCROC::SetGeometry()
   fInnerPadPitchWidth  = kInnerPadPitchWidth;
   fInnerPadLength      = kInnerPadLength;
   fInnerPadWidth       = kInnerPadWidth;
-  fOuter1PadPitchLength = kOuter1PadPitchLength; 
+  fOuter1PadPitchLength = kOuter1PadPitchLength;
   fOuter2PadPitchLength = kOuter2PadPitchLength;
   fOuterPadPitchWidth   = kOuterPadPitchWidth;
   fOuter1PadLength      = kOuter1PadLength;
   fOuter2PadLength      = kOuter2PadLength;
-  fOuterPadWidth        = kOuterPadWidth; 
+  fOuterPadWidth        = kOuterPadWidth;
 
   //
   //set wire parameters
@@ -196,28 +192,28 @@ void AliTPCROC::SetGeometry()
   //   SetRInnerLastWire(kRInnerLastWire);
   //   SetOuterWWPitch(kOuterWWPitch);
   //   SetROuterFirstWire(kROuterFirstWire);
-  //   SetROuterLastWire(kROuterLastWire);  
+  //   SetROuterLastWire(kROuterLastWire);
 
   UInt_t i=0;
-  Float_t firstrow = fInnerRadiusLow + 1.575;   
+  Float_t firstrow = fInnerRadiusLow + 1.575;
   for( i= 0;i<fNRowLow;i++)
     {
-      Float_t x = firstrow + fInnerPadPitchLength*(Float_t)i;  
+      Float_t x = firstrow + fInnerPadPitchLength*(Float_t)i;
       fPadRowLow[i]=x;
       fYInner[i+1]  = x*TMath::Tan(fInnerAngle/2.)-fInnerWireMount;
-      fNPadsLow[i] = GetNPads(0,i) ;     // ROC implement     
+      fNPadsLow[i] = GetNPads(0,i) ;     // ROC implement
     }
   // cross talk rows
   fYInner[0]=(fPadRowLow[0]-fInnerPadPitchLength)*TMath::Tan(fInnerAngle/2.)-fInnerWireMount;
-  fYInner[fNRowLow+1]=(fPadRowLow[fNRowLow-1]+fInnerPadPitchLength)*TMath::Tan(fInnerAngle/2.)-fInnerWireMount; 
+  fYInner[fNRowLow+1]=(fPadRowLow[fNRowLow-1]+fInnerPadPitchLength)*TMath::Tan(fInnerAngle/2.)-fInnerWireMount;
   firstrow = fOuterRadiusLow + 1.6;
   for(i=0;i<fNRowUp;i++)
     {
       if(i<fNRowUp1){
-	Float_t x = firstrow + fOuter1PadPitchLength*(Float_t)i; 
+	Float_t x = firstrow + fOuter1PadPitchLength*(Float_t)i;
 	fPadRowUp[i]=x;
 	fYOuter[i+1]= x*TMath::Tan(fOuterAngle/2.)-fOuterWireMount;
-	fNPadsUp[i] =  GetNPads(36,i) ;     // ROC implement      
+	fNPadsUp[i] =  GetNPads(36,i) ;     // ROC implement
 	if(i==fNRowUp1-1) {
 	  fLastWireUp1=fPadRowUp[i] +0.625;
 	  firstrow = fPadRowUp[i] + 0.5*(fOuter1PadPitchLength+fOuter2PadPitchLength);
@@ -231,17 +227,17 @@ void AliTPCROC::SetGeometry()
 	}
       fYOuter[i+1]  = fPadRowUp[i]*TMath::Tan(fOuterAngle/2.)-fOuterWireMount;
     }
-  
 
 
-} 
+
+}
 
 
 
 
 //_____________________________________________________________________________
 AliTPCROC::AliTPCROC()
-          :TObject(), 
+          :TObject(),
            fNSectorsAll(0),
 	   fInnerRadiusLow(0.),
 	   fInnerRadiusUp(0.),
@@ -284,8 +280,8 @@ AliTPCROC::AliTPCROC()
 	   fNRowUp(0),
 	   fNtRows(0)
 {
-  //
-  // Default constructor
+  /// Default constructor
+
   for (UInt_t i=0;i<2;i++){
     fNSectors[i]  = 0;
     fNRows[i]     = 0;
@@ -293,7 +289,7 @@ AliTPCROC::AliTPCROC()
     fNPads[i]     = 0;
     fRowPosIndex[i]= 0;
   }
-  
+
   for (UInt_t i=0;i<100;++i){
     fPadRowLow[i]=0.;
     fPadRowUp[i]=0.;
@@ -351,9 +347,8 @@ AliTPCROC::AliTPCROC(const AliTPCROC &roc)
 	   fNtRows(0)
 
 {
-  //
-  // AliTPCROC copy constructor
-  //
+  /// AliTPCROC copy constructor
+
   fNSectorsAll = roc.fNSectorsAll;
   fNSectors[0] = roc.fNSectors[0];
   fNSectors[1] = roc.fNSectors[1];
@@ -364,7 +359,7 @@ AliTPCROC::AliTPCROC(const AliTPCROC &roc)
   //
   // number of pads in padrow
   fNPads[0] = new UInt_t[fNRows[0]];
-  fNPads[1] = new UInt_t[fNRows[1]];  
+  fNPads[1] = new UInt_t[fNRows[1]];
   //
   // padrow index in array
   //
@@ -379,7 +374,7 @@ AliTPCROC::AliTPCROC(const AliTPCROC &roc)
     fNPads[1][irow]       = roc.fNPads[1][irow];
     fRowPosIndex[1][irow] = roc.fRowPosIndex[1][irow];
   }
-  
+
   for (UInt_t i=0;i<100;++i){
     fPadRowLow[i]=roc.fPadRowLow[i];
     fPadRowUp[i]=roc.fPadRowUp[i];
@@ -393,9 +388,8 @@ AliTPCROC::AliTPCROC(const AliTPCROC &roc)
 //____________________________________________________________________________
 AliTPCROC & AliTPCROC::operator =(const AliTPCROC & roc)
 {
-  //
-  // assignment operator - dummy
-  //
+  /// assignment operator - dummy
+
   if (this == &roc) return (*this);
 
   fZLength = roc.fZLength;
@@ -404,31 +398,29 @@ AliTPCROC & AliTPCROC::operator =(const AliTPCROC & roc)
 //_____________________________________________________________________________
 AliTPCROC::~AliTPCROC()
 {
-  //
-  // AliTPCROC destructor
-  //
+  /// AliTPCROC destructor
+
   delete [] fNPads[0];
   delete [] fNPads[1];
   delete [] fRowPosIndex[0];
   delete [] fRowPosIndex[1];
   fgInstance = 0x0;
-  
+
 }
 
 
 
 
 void AliTPCROC::GetPositionLocal(UInt_t sector, UInt_t row, UInt_t pad, Float_t *pos){
-  //
-  // get position of center of pad - ideal frame used
-  //
+  /// get position of center of pad - ideal frame used
+
   pos[2]=fZLength;
   if (sector<36){
    pos[0] = fPadRowLow[row];
    pos[1] = fInnerPadPitchWidth*(Int_t(pad)+0.5-Int_t(fNPads[0][row])/2);
   }else{
     pos[0] = fPadRowUp[row];
-    pos[1] = fOuterPadPitchWidth*(Int_t(pad)+0.5-Int_t(fNPads[1][row])/2);    
+    pos[1] = fOuterPadPitchWidth*(Int_t(pad)+0.5-Int_t(fNPads[1][row])/2);
   }
   if ((sector%36)>=18){
     pos[2] *= -1.;
@@ -438,9 +430,8 @@ void AliTPCROC::GetPositionLocal(UInt_t sector, UInt_t row, UInt_t pad, Float_t
 
 
 void AliTPCROC::GetPositionGlobal(UInt_t sector, UInt_t row, UInt_t pad, Float_t *pos){
-  //
-  // get position of center of pad - ideal frame used 
-  //
+  /// get position of center of pad - ideal frame used
+
   GetPositionLocal(sector,row,pad,pos);
   Double_t alpha = TMath::DegToRad()*(10.+20.*(sector%18));
   Float_t gx = pos[0]*TMath::Cos(alpha)-pos[1]*TMath::Sin(alpha);
diff --git a/TPC/TPCbase/AliTPCROC.h b/TPC/TPCbase/AliTPCROC.h
index adcbcc7990c..e1d2747d3d7 100644
--- a/TPC/TPCbase/AliTPCROC.h
+++ b/TPC/TPCbase/AliTPCROC.h
@@ -5,11 +5,8 @@
 
 /* $Id: AliTPCROC.h,v */
 
-//////////////////////////////////////////////////
-//                                              //
-//  TPC geometry class for   ROC                //
-//                                              //
-//////////////////////////////////////////////////
+/// \class AliTPCROC
+/// \brief TPC geometry class for ROC
 
 #include <TObject.h>
 
@@ -20,7 +17,7 @@ class AliTPCROC : public TObject {
   AliTPCROC();
   AliTPCROC(const AliTPCROC &roc);
   AliTPCROC &operator = (const AliTPCROC & roc); //assignment operator
-  void Init(); 
+  void Init();
   virtual           ~AliTPCROC();
   void GetPositionLocal(UInt_t sector, UInt_t row, UInt_t pad, Float_t *pos);
   void GetPositionGlobal(UInt_t sector, UInt_t row, UInt_t pad, Float_t *pos);
@@ -29,17 +26,17 @@ class AliTPCROC : public TObject {
   UInt_t GetNSectors() const          { return fNSectorsAll;}
   UInt_t GetNRows(UInt_t sector) const { return (sector<fNSectors[1]) ? fNRows[0]:fNRows[1];}
   UInt_t GetNChannels(UInt_t sector) const { return (sector<fNSectors[1]) ? fNChannels[0]:fNChannels[1];}
-  UInt_t GetNPads(UInt_t sector,UInt_t row) const { 
+  UInt_t GetNPads(UInt_t sector,UInt_t row) const {
     UInt_t irow=(row<GetNRows(sector))?row:(GetNRows(sector)-1);
     return (sector<fNSectors[1]) ? fNPads[0][irow]:fNPads[1][irow];}
-  const UInt_t * GetRowIndexes(UInt_t sector) const {return (sector<fNSectors[1]) ? fRowPosIndex[0]:fRowPosIndex[1];}  
+  const UInt_t * GetRowIndexes(UInt_t sector) const {return (sector<fNSectors[1]) ? fRowPosIndex[0]:fRowPosIndex[1];}
   //
   //get sector parameters
   //
   Float_t  GetInnerRadiusLow() const {return fInnerRadiusLow;}
-  Float_t  GetInnerRadiusUp() const {return fInnerRadiusUp;} 
-  Float_t  GetOuterRadiusLow() const {return fOuterRadiusLow;} 
-  Float_t  GetOuterRadiusUp() const {return fOuterRadiusUp;} 
+  Float_t  GetInnerRadiusUp() const {return fInnerRadiusUp;}
+  Float_t  GetOuterRadiusLow() const {return fOuterRadiusLow;}
+  Float_t  GetOuterRadiusUp() const {return fOuterRadiusUp;}
   Float_t  GetInnerFrameSpace() const {return fInnerFrameSpace;}
   Float_t  GetOuterFrameSpace() const {return fOuterFrameSpace;}
   Float_t  GetInnerWireMount() const {return fInnerWireMount;}
@@ -54,84 +51,86 @@ class AliTPCROC : public TObject {
   // get pad row parameters
   //
   Float_t GetPadRowRadiiLow(UInt_t irow) const {return ( irow<fNRowLow ) ? fPadRowLow[irow]: 0;} //get the pad row (irow) radii
-  Float_t GetPadRowRadiiUp(UInt_t irow) const {return ( irow<fNRowUp ) ? fPadRowUp[irow]: 0;}   //get the pad row (irow) radii   
+  Float_t GetPadRowRadiiUp(UInt_t irow) const {return ( irow<fNRowUp ) ? fPadRowUp[irow]: 0;}   //get the pad row (irow) radii
   Float_t GetPadRowRadii(UInt_t isec, UInt_t irow) const {
     return ( (isec < fNSectors[0]) ?GetPadRowRadiiLow(irow):GetPadRowRadiiUp(irow));}
   //
-  static UInt_t GetTPCUniqueID(UInt_t sector, UInt_t row, UInt_t pad){UInt_t uid=pad+row*140+sector*140*159; return uid; }  // unique Id can be used for absolute adressing of the TPC element 
+  static UInt_t GetTPCUniqueID(UInt_t sector, UInt_t row, UInt_t pad){UInt_t uid=pad+row*140+sector*140*159; return uid; }  // unique Id can be used for absolute adressing of the TPC element
 protected:
   //
   //     number of pads
   //
   void   SetGeometry();    // set geometry parameters
-  UInt_t  fNSectorsAll;     // number of sectors
-  UInt_t  fNSectors[2];     // number of sectors - inner outer
-  UInt_t  fNRows[2];        // number of row     - inner outer
-  UInt_t  fNChannels[2];    // total number of pads   - inner sector - outer sector
-  UInt_t *fNPads[2];        // number of pads in row  - inner - outer      
-  UInt_t *fRowPosIndex[2];  // index array            - inner - outer
+  UInt_t  fNSectorsAll;     ///< number of sectors
+  UInt_t  fNSectors[2];     ///< number of sectors - inner outer
+  UInt_t  fNRows[2];        ///< number of row     - inner outer
+  UInt_t  fNChannels[2];    ///< total number of pads   - inner sector - outer sector
+  UInt_t *fNPads[2];        ///< number of pads in row  - inner - outer
+  UInt_t *fRowPosIndex[2];  ///< index array            - inner - outer
   //
   //
   //---------------------------------------------------------------------
   //   ALICE TPC sector geometry
-  //--------------------------------------------------------------------  
-  Float_t fInnerRadiusLow;    // lower radius of inner sector-IP
-  Float_t fInnerRadiusUp;     // upper radius of inner  sector-IP
-  Float_t fOuterRadiusUp;     // upper radius of outer  sector-IP
-  Float_t fOuterRadiusLow;    // lower radius of outer sector-IP
-  Float_t fInnerFrameSpace;   //space for inner frame in the phi direction 
-  Float_t fOuterFrameSpace;   //space for outer frame in the phi direction 
-  Float_t fInnerWireMount;    //space for wire mount, inner sector
-  Float_t fOuterWireMount;    //space for wire mount, outer sector
-  Float_t fZLength;           //length of the drift region of the TPC
-  Float_t fInnerAngle;        //angular coverage
-  Float_t fOuterAngle;        //angular coverage
+  //--------------------------------------------------------------------
+  Float_t fInnerRadiusLow;    ///< lower radius of inner sector-IP
+  Float_t fInnerRadiusUp;     ///< upper radius of inner  sector-IP
+  Float_t fOuterRadiusUp;     ///< upper radius of outer  sector-IP
+  Float_t fOuterRadiusLow;    ///< lower radius of outer sector-IP
+  Float_t fInnerFrameSpace;   ///< space for inner frame in the phi direction
+  Float_t fOuterFrameSpace;   ///< space for outer frame in the phi direction
+  Float_t fInnerWireMount;    ///< space for wire mount, inner sector
+  Float_t fOuterWireMount;    ///< space for wire mount, outer sector
+  Float_t fZLength;           ///< length of the drift region of the TPC
+  Float_t fInnerAngle;        ///< angular coverage
+  Float_t fOuterAngle;        ///< angular coverage
   //
   //---------------------------------------------------------------------
-  //   ALICE TPC wires  geometry - for GEM we can consider that it is gating  
+  //   ALICE TPC wires  geometry - for GEM we can consider that it is gating
   //--------------------------------------------------------------------
-  UInt_t   fNInnerWiresPerPad; //Number of wires per pad
-  Float_t fInnerWWPitch;      //pitch between wires  in inner sector     - calculated
-  UInt_t   fInnerDummyWire;    //number of wires without pad readout
-  Float_t fInnerOffWire;      //oofset of first wire to the begining of the sector
-  Float_t fRInnerFirstWire;   //position of the first wire                -calculated
-  Float_t fRInnerLastWire;    //position of the last wire                 -calculated
-  Float_t fLastWireUp1;     //position of the last wire in outer1 sector
-  UInt_t   fNOuter1WiresPerPad; //Number of wires per pad
-  UInt_t   fNOuter2WiresPerPad; // Number of wires per pad
-  Float_t fOuterWWPitch;      //pitch between wires in outer sector      -calculated
-  UInt_t   fOuterDummyWire;    //number of wires without pad readout
-  Float_t fOuterOffWire;      //oofset of first wire to the begining of the sector
-  Float_t fROuterFirstWire;   //position of the first wire                -calulated
-  Float_t fROuterLastWire;    //position of the last wire                 -calculated 
+  UInt_t   fNInnerWiresPerPad; ///< Number of wires per pad
+  Float_t fInnerWWPitch;      ///< pitch between wires  in inner sector     - calculated
+  UInt_t   fInnerDummyWire;    ///< number of wires without pad readout
+  Float_t fInnerOffWire;      ///< oofset of first wire to the begining of the sector
+  Float_t fRInnerFirstWire;   ///< position of the first wire                -calculated
+  Float_t fRInnerLastWire;    ///< position of the last wire                 -calculated
+  Float_t fLastWireUp1;     ///< position of the last wire in outer1 sector
+  UInt_t   fNOuter1WiresPerPad; ///< Number of wires per pad
+  UInt_t   fNOuter2WiresPerPad; ///< Number of wires per pad
+  Float_t fOuterWWPitch;      ///< pitch between wires in outer sector      -calculated
+  UInt_t   fOuterDummyWire;    ///< number of wires without pad readout
+  Float_t fOuterOffWire;      ///< oofset of first wire to the begining of the sector
+  Float_t fROuterFirstWire;   ///< position of the first wire                -calulated
+  Float_t fROuterLastWire;    ///< position of the last wire                 -calculated
   //---------------------------------------------------------------------
   //   ALICE TPC pad parameters
   //--------------------------------------------------------------------
-  Float_t   fInnerPadPitchLength;    //Inner pad pitch length
-  Float_t   fInnerPadPitchWidth;     //Inner pad pitch width
-  Float_t   fInnerPadLength;         //Inner pad  length
-  Float_t   fInnerPadWidth;          //Inner pad  width
-  Float_t   fOuter1PadPitchLength;    //Outer pad pitch length
-  Float_t   fOuter2PadPitchLength;    //Outer pad pitch length
-  Float_t   fOuterPadPitchWidth;     //Outer pad pitch width
-  Float_t   fOuter1PadLength;         //Outer pad  length
-  Float_t   fOuter2PadLength;         //Outer pad length
-  Float_t   fOuterPadWidth;          //Outer pad  width
-  // 
-  UInt_t     fNRowLow;           //number of pad rows per low sector        -set
-  UInt_t     fNRowUp1;            //number of short pad rows per sector up  -set
-  UInt_t     fNRowUp2;            //number of long pad rows per sector up   -set
-  UInt_t     fNRowUp;            //number of pad rows per sector up     -calculated
-  UInt_t     fNtRows;            //total number of rows in TPC          -calculated
-  Float_t   fPadRowLow[100]; //Lower sector, pad row radii          -calculated
-  Float_t   fPadRowUp[100];  //Upper sector, pad row radii          -calculated 
-  UInt_t     fNPadsLow[100];  //Lower sector, number of pads per row -calculated
-  UInt_t     fNPadsUp[100];   //Upper sector, number of pads per row -calculated
-  Float_t   fYInner[100];     //Inner sector, wire-length
-  Float_t   fYOuter[100];     //Outer sector, wire-length   
+  Float_t   fInnerPadPitchLength;    ///< Inner pad pitch length
+  Float_t   fInnerPadPitchWidth;     ///< Inner pad pitch width
+  Float_t   fInnerPadLength;         ///< Inner pad  length
+  Float_t   fInnerPadWidth;          ///< Inner pad  width
+  Float_t   fOuter1PadPitchLength;    ///< Outer pad pitch length
+  Float_t   fOuter2PadPitchLength;    ///< Outer pad pitch length
+  Float_t   fOuterPadPitchWidth;     ///< Outer pad pitch width
+  Float_t   fOuter1PadLength;         ///< Outer pad  length
+  Float_t   fOuter2PadLength;         ///< Outer pad length
+  Float_t   fOuterPadWidth;          ///< Outer pad  width
+  //
+  UInt_t     fNRowLow;           ///< number of pad rows per low sector        -set
+  UInt_t     fNRowUp1;            ///< number of short pad rows per sector up  -set
+  UInt_t     fNRowUp2;            ///< number of long pad rows per sector up   -set
+  UInt_t     fNRowUp;            ///< number of pad rows per sector up     -calculated
+  UInt_t     fNtRows;            ///< total number of rows in TPC          -calculated
+  Float_t   fPadRowLow[100]; ///< Lower sector, pad row radii          -calculated
+  Float_t   fPadRowUp[100];  ///< Upper sector, pad row radii          -calculated
+  UInt_t     fNPadsLow[100];  ///< Lower sector, number of pads per row -calculated
+  UInt_t     fNPadsUp[100];   ///< Upper sector, number of pads per row -calculated
+  Float_t   fYInner[100];     ///< Inner sector, wire-length
+  Float_t   fYOuter[100];     ///< Outer sector, wire-length
  protected:
-  static AliTPCROC*   fgInstance; //! Instance of this class (singleton implementation)
+  static AliTPCROC*   fgInstance; //!< Instance of this class (singleton implementation)
+  /// \cond CLASSIMP
   ClassDef(AliTPCROC,0)    //  TPC ROC class
+  /// \endcond
 };
 
 #endif
diff --git a/TPC/TPCbase/AliTPCROCVoltError3D.cxx b/TPC/TPCbase/AliTPCROCVoltError3D.cxx
index e9e1b420e63..beb81df52ab 100644
--- a/TPC/TPCbase/AliTPCROCVoltError3D.cxx
+++ b/TPC/TPCbase/AliTPCROCVoltError3D.cxx
@@ -13,62 +13,42 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-// _________________________________________________________________
-//
-// Begin_Html
-//   <h2> AliTPCROCVoltError3D class   </h2>    
-//   The class calculates the space point distortions due to z offsets of the 
-//   ROCs via the residual voltage technique (Poisson relaxation) in 3D. 
-//   Since the GG (part of the ROCs) represents the closure of the FC in z direction,
-//   every misalignment in z produces not only dz distortions but also electrical 
-//   field inhomogeneities throughout the volume, which produces additional dr and rd$\phi$ distortions.
-//   <p>
-//   Each ROC can be misaligned (in z direction) in three ways. A general z0 offset, 
-//   an inclination along the x and an inclination along the y axis. The z-misalignment's
-//   can be set via the function SetROCData(TMatrixD *mat) for each single chamber (ROC). 
-//   The array size has to be (72,3) representing the 72 chambers according to the 
-//   offline numbering scheme (IROC: roc$<$36; OROC: roc$\geq$36) and the three misalignment's
-//   (see the source code for further details).
-//   <p>
-//   Internally, these z offsets (unit is cm)  are recalculated into residual voltage 
-//   equivalents in order to make use of the relaxation technique. 
-//   <p>
-//   One has two possibilities when calculating the $dz$ distortions. The resulting 
-//   distortions are purely due to the change of the drift velocity (along with the 
-//   change of the drift field) when the SetROCDisplacement is FALSE. <br>
-//   For this class, this is a rather unphysical setting and should be avoided. <br>
-//   When the flag is set to TRUE, the corresponding offset in z is added to the dz 
-//   calculation of the outer ROCs. <br>
-//   For the Alice TPC gas, both effects are of similar magnitude. This means, if the 
-//   drift length is sufficiently large, a z-offset of a chamber appears to have (approx.) 
-//   twice the magnitude when one looks at the actual dz distortions.
-//   <p>
-//   In addition, this class allows a correction regarding the different arrival times 
-//   of the electrons due to the geometrical difference of the inner and outer chambers.
-//   The impact was simulated via Garfield. If the flag is set via the 
-//   function SetElectronArrivalCorrection, the electron-arrival correction is added to the dz calculation.
-// End_Html
-//
-// Begin_Macro(source)
-//   {
-//   gROOT->SetStyle("Plain"); gStyle->SetPalette(1);
-//   TCanvas *c2 = new TCanvas("cAliTPCROCVoltError3D","cAliTPCROCVoltError3D",500,400); 
-//   AliTPCROCVoltError3D roc; 
-//   roc.SetROCDataFileName("$ALICE_ROOT/TPC/Calib/maps/TPCROCdzSurvey.root");
-//   roc.SetElectronArrivalCorrection(kFALSE);  // Correction for electron arrival offset, IROC vs OROC
-//   roc.SetROCDisplacement(kTRUE);   // include the chamber offset in z when calculating the dz 
-//   roc.SetOmegaTauT1T2(0,1,1); // B=0
-//   roc.CreateHistoDZinXY(1.,300,300)->Draw("colz"); 
-//   return c2;
-//   } 
-// End_Macro
-//
-// Begin_Html
-//   <p>
-//   Date: 08/08/2010    <br>                                                 
-//   Authors: Jim Thomas, Stefan Rossegger                                
-// End_Html 
-// _________________________________________________________________
+/// \class AliTPCROCVoltError3D
+/// \brief The class calculates the space point distortions due to z offsets of the
+///
+/// ROCs via the residual voltage technique (Poisson relaxation) in 3D.
+/// Since the GG (part of the ROCs) represents the closure of the FC in z direction,
+/// every misalignment in z produces not only dz distortions but also electrical
+/// field inhomogeneities throughout the volume, which produces additional dr and rd$\phi$ distortions.
+///
+/// Each ROC can be misaligned (in z direction) in three ways. A general z0 offset,
+/// an inclination along the x and an inclination along the y axis. The z-misalignment's
+/// can be set via the function SetROCData(TMatrixD *mat) for each single chamber (ROC).
+/// The array size has to be (72,3) representing the 72 chambers according to the
+/// offline numbering scheme (IROC: roc$<$36; OROC: roc$\geq$36) and the three misalignment's
+/// (see the source code for further details).
+///
+/// Internally, these z offsets (unit is cm)  are recalculated into residual voltage
+/// equivalents in order to make use of the relaxation technique.
+///
+/// One has two possibilities when calculating the $dz$ distortions. The resulting
+/// distortions are purely due to the change of the drift velocity (along with the
+/// change of the drift field) when the SetROCDisplacement is FALSE.
+/// For this class, this is a rather unphysical setting and should be avoided.
+/// When the flag is set to TRUE, the corresponding offset in z is added to the dz
+/// calculation of the outer ROCs.
+/// For the Alice TPC gas, both effects are of similar magnitude. This means, if the
+/// drift length is sufficiently large, a z-offset of a chamber appears to have (approx.)
+/// twice the magnitude when one looks at the actual dz distortions.
+///
+/// In addition, this class allows a correction regarding the different arrival times
+/// of the electrons due to the geometrical difference of the inner and outer chambers.
+/// The impact was simulated via Garfield. If the flag is set via the
+/// function SetElectronArrivalCorrection, the electron-arrival correction is added to the dz calculation.
+/// ![Picture from ROOT macro](AliTPCROCVoltError3D_cxx_99b6733.png)
+///
+/// \author Jim Thomas, Stefan Rossegger
+/// \date 08/08/2010
 
 
 #include "AliMagF.h"
@@ -83,7 +63,9 @@
 #include "AliTPCROC.h"
 #include "AliTPCROCVoltError3D.h"
 
+/// \cond CLASSIMP
 ClassImp(AliTPCROCVoltError3D)
+/// \endcond
 
 AliTPCROCVoltError3D::AliTPCROCVoltError3D()
   : AliTPCCorrection("ROCVoltErrors","ROC z alignment Errors"),
@@ -91,7 +73,7 @@ AliTPCROCVoltError3D::AliTPCROCVoltError3D()
     fROCdisplacement(kTRUE),
     fElectronArrivalCorrection(kTRUE),
     fInitLookUp(kFALSE),
-    fROCDataFileName(""),  
+    fROCDataFileName(""),
     fdzDataLinFit(0)
 {
   //
@@ -102,9 +84,9 @@ AliTPCROCVoltError3D::AliTPCROCVoltError3D()
   // main input: z alignment of the Read Out chambers
   // see InitROCVoltError3D() function
   for ( Int_t k = 0 ; k < kNPhi ; k++ ) {
-    fLookUpErOverEz[k]   =  new TMatrixF(kNR,kNZ);  
+    fLookUpErOverEz[k]   =  new TMatrixF(kNR,kNZ);
     fLookUpEphiOverEz[k] =  new TMatrixF(kNR,kNZ);
-    fLookUpDeltaEz[k]    =  new TMatrixF(kNR,kNZ);   
+    fLookUpDeltaEz[k]    =  new TMatrixF(kNR,kNZ);
   }
   //  fROCDataFileName="$ALICE_ROOT/TPC/Calib/maps/TPCROCdzSurvey.root";
   //  SetROCDataFileName(fROCDataFileName.Data()); // initialization of fdzDataLinFit is included
@@ -112,10 +94,8 @@ AliTPCROCVoltError3D::AliTPCROCVoltError3D()
 }
 
 AliTPCROCVoltError3D::~AliTPCROCVoltError3D() {
-  //
-  // destructor
-  //
-  
+  /// destructor
+
   for ( Int_t k = 0 ; k < kNPhi ; k++ ) {
     delete fLookUpErOverEz[k];
     delete fLookUpEphiOverEz[k];
@@ -128,15 +108,15 @@ AliTPCROCVoltError3D::~AliTPCROCVoltError3D() {
 
 
 Bool_t AliTPCROCVoltError3D::AddCorrectionCompact(AliTPCCorrection* corr, Double_t weight){
-  //
-  // Add correction  and make them compact
-  // Assumptions:
-  //  - origin of distortion/correction are additive
-  //  - only correction ot the same type supported ()
+  /// Add correction  and make them compact
+  /// Assumptions:
+  ///  - origin of distortion/correction are additive
+  ///  - only correction ot the same type supported ()
+
   if (corr==NULL) {
     AliError("Zerro pointer - correction");
     return kFALSE;
-  }  
+  }
   AliTPCROCVoltError3D * corrC = dynamic_cast<AliTPCROCVoltError3D *>(corr);
   if (corrC == NULL) {
     AliError(TString::Format("Inconsistent class types: %s\%s",IsA()->GetName(),corr->IsA()->GetName()).Data());
@@ -161,20 +141,17 @@ Bool_t AliTPCROCVoltError3D::AddCorrectionCompact(AliTPCCorrection* corr, Double
 
 
 void AliTPCROCVoltError3D::SetROCData(TMatrixD * matrix){
-  //
-  // Set a z alignment map of the chambers not via a file, but
-  // directly via a TMatrix(72,3), where dz = p0 + p1*(lx-133.4) + p2*ly (all in cm)
-  //
+  /// Set a z alignment map of the chambers not via a file, but
+  /// directly via a TMatrix(72,3), where dz = p0 + p1*(lx-133.4) + p2*ly (all in cm)
+
   if (!fdzDataLinFit) fdzDataLinFit=new TMatrixD(*matrix);
   else *fdzDataLinFit = *matrix;
 }
 
 
 void AliTPCROCVoltError3D::Init() {
-  //
-  // Initialization funtion
-  //
-  
+  /// Initialization funtion
+
   AliMagF* magF= (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
   if (!magF) AliError("Magneticd field - not initialized");
   Double_t bzField = magF->SolenoidField()/10.; //field in T
@@ -182,7 +159,7 @@ void AliTPCROCVoltError3D::Init() {
   if (!param) AliError("Parameters - not initialized");
   Double_t vdrift = param->GetDriftV()/1000000.; // [cm/us]   // From dataBase: to be updated: per second (ideally)
   Double_t ezField = 400; // [V/cm]   // to be updated: never (hopefully)
-  Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ; 
+  Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ;
   // Correction Terms for effective omegaTau; obtained by a laser calibration run
   SetOmegaTauT1T2(wt,fT1,fT2);
 
@@ -190,9 +167,8 @@ void AliTPCROCVoltError3D::Init() {
 }
 
 void AliTPCROCVoltError3D::Update(const TTimeStamp &/*timeStamp*/) {
-  //
-  // Update function 
-  //
+  /// Update function
+
   AliMagF* magF= (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
   if (!magF) AliError("Magneticd field - not initialized");
   Double_t bzField = magF->SolenoidField()/10.; //field in T
@@ -200,19 +176,17 @@ void AliTPCROCVoltError3D::Update(const TTimeStamp &/*timeStamp*/) {
   if (!param) AliError("Parameters - not initialized");
   Double_t vdrift = param->GetDriftV()/1000000.; // [cm/us]  // From dataBase: to be updated: per second (ideally)
   Double_t ezField = 400; // [V/cm]   // to be updated: never (hopefully)
-  Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ; 
+  Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ;
   // Correction Terms for effective omegaTau; obtained by a laser calibration run
   SetOmegaTauT1T2(wt,fT1,fT2);
 
 }
 
 void  AliTPCROCVoltError3D::SetROCDataFileName(const char * fname) {
-  //
-  // Set / load the ROC data (linear fit of ROC misalignments)
-  //
+  /// Set / load the ROC data (linear fit of ROC misalignments)
 
   fROCDataFileName = fname;
-  
+
   TFile f(fROCDataFileName.Data(),"READ");
   TMatrixD *m = (TMatrixD*) f.Get("dzSurveyLinFitData");
   TMatrixD &mf = *m;
@@ -222,7 +196,7 @@ void  AliTPCROCVoltError3D::SetROCDataFileName(const char * fname) {
   if (fdzDataLinFit) delete fdzDataLinFit;
   fdzDataLinFit = new TMatrixD(72,3);
   TMatrixD &dataIntern = *fdzDataLinFit;
-  
+
   for (Int_t iroc=0;iroc<72;iroc++) {
     dataIntern(iroc,0) = mf(iroc,0);  // z0 offset
     dataIntern(iroc,1) = mf(iroc,1);  // slope in x
@@ -236,9 +210,8 @@ void  AliTPCROCVoltError3D::SetROCDataFileName(const char * fname) {
 }
 
 void AliTPCROCVoltError3D::GetCorrection(const Float_t x[],const Short_t roc,Float_t dx[]) {
-  //
-  // Calculates the correction due e.g. residual voltage errors on the TPC boundaries
-  //   
+  /// Calculates the correction due e.g. residual voltage errors on the TPC boundaries
+
   const Double_t kEpsilon=Double_t(FLT_MIN);
   if (!fInitLookUp) {
     AliInfo("Lookup table was not initialized! Perform the inizialisation now ...");
@@ -252,8 +225,8 @@ void AliTPCROCVoltError3D::GetCorrection(const Float_t x[],const Short_t roc,Flo
     forceInit=kFALSE;
   }
 
-  
-  Int_t   order     = 1 ;    // FIXME: hardcoded? Linear interpolation = 1, Quadratic = 2         
+
+  Int_t   order     = 1 ;    // FIXME: hardcoded? Linear interpolation = 1, Quadratic = 2
 
   Float_t intEr, intEphi, intDeltaEz;
   Double_t r, phi, z ;
@@ -269,34 +242,34 @@ void AliTPCROCVoltError3D::GetCorrection(const Float_t x[],const Short_t roc,Flo
   } else {
     sign = -1;       // (TPC C side)
   }
-  
+
   if ( sign==1  && z <  fgkZOffSet ) z =  fgkZOffSet;    // Protect against discontinuity at CE
   if ( sign==-1 && z > -fgkZOffSet ) z = -fgkZOffSet;    // Protect against discontinuity at CE
-  
+
 
   if ( (sign==1 && z<0) || (sign==-1 && z>0) ) // just a consistency check
     AliError("ROC number does not correspond to z coordinate! Calculation of distortions is most likely wrong!");
 
-  // Get the Er and Ephi field integrals plus the integral over DeltaEz 
-  intEr      = Interpolate3DTable(order, r, z, phi, kNR, kNZ, kNPhi, 
+  // Get the Er and Ephi field integrals plus the integral over DeltaEz
+  intEr      = Interpolate3DTable(order, r, z, phi, kNR, kNZ, kNPhi,
 				  fgkRList, fgkZList, fgkPhiList, fLookUpErOverEz  );
-  intEphi    = Interpolate3DTable(order, r, z, phi, kNR, kNZ, kNPhi, 
+  intEphi    = Interpolate3DTable(order, r, z, phi, kNR, kNZ, kNPhi,
 				  fgkRList, fgkZList, fgkPhiList, fLookUpEphiOverEz);
-  intDeltaEz = Interpolate3DTable(order, r, z, phi, kNR, kNZ, kNPhi, 
+  intDeltaEz = Interpolate3DTable(order, r, z, phi, kNR, kNZ, kNPhi,
 				  fgkRList, fgkZList, fgkPhiList, fLookUpDeltaEz   );
 
   //  printf("%lf %lf %lf\n",intEr,intEphi,intDeltaEz);
 
   // Calculate distorted position
   if ( r > 0.0 ) {
-    phi =  phi + ( fC0*intEphi - fC1*intEr ) / r;      
-    r   =  r   + ( fC0*intEr   + fC1*intEphi );  
+    phi =  phi + ( fC0*intEphi - fC1*intEr ) / r;
+    r   =  r   + ( fC0*intEr   + fC1*intEphi );
   }
-  
+
   // Calculate correction in cartesian coordinates
   dx[0] = r * TMath::Cos(phi) - x[0];
-  dx[1] = r * TMath::Sin(phi) - x[1]; 
-  dx[2] = intDeltaEz;  // z distortion - (internally scaled with driftvelocity dependency 
+  dx[1] = r * TMath::Sin(phi) - x[1];
+  dx[2] = intDeltaEz;  // z distortion - (internally scaled with driftvelocity dependency
                        // on the Ez field plus the actual ROC misalignment (if set TRUE)
 
 
@@ -306,37 +279,35 @@ void AliTPCROCVoltError3D::GetCorrection(const Float_t x[],const Short_t roc,Flo
     // due to different position of the anode wires) -> vd*dt -> 2.64*0.014 = 0.0369 cm
     // FIXME: correction are token from Magboltz simulations
     //        should be loaded from a database
- 
+
     AliTPCROC * rocInfo = AliTPCROC::Instance();
     Double_t rCrossingROC  =  (rocInfo->GetPadRowRadii(0,62)+rocInfo->GetPadRowRadii(36,0))/2;
-  
+
     if (r>rCrossingROC) {
       if (sign==1)
 	dx[2] += 0.0369; // A side - negative correction
       else
 	dx[2] -= 0.0369; // C side - positive correction
     }
-    
+
   }
 
 }
 
 void AliTPCROCVoltError3D::InitROCVoltError3D() {
-  //
-  // Initialization of the Lookup table which contains the solutions of the 
-  // Dirichlet boundary problem
-  // Calculation of the single 3D-Poisson solver is done just if needed
-  // (see basic lookup tables in header file)
-  //
+  /// Initialization of the Lookup table which contains the solutions of the
+  /// Dirichlet boundary problem
+  /// Calculation of the single 3D-Poisson solver is done just if needed
+  /// (see basic lookup tables in header file)
 
-  const Int_t   order       =    1  ;  // Linear interpolation = 1, Quadratic = 2  
+  const Int_t   order       =    1  ;  // Linear interpolation = 1, Quadratic = 2
   const Float_t gridSizeR   =  (fgkOFCRadius-fgkIFCRadius) / (kRows-1) ;
   const Float_t gridSizeZ   =  fgkTPCZ0 / (kColumns-1) ;
   const Float_t gridSizePhi =  TMath::TwoPi() / ( 18.0 * kPhiSlicesPerSector);
 
   // temporary arrays to create the boundary conditions
-  TMatrixD *arrayofArrayV[kPhiSlices], *arrayofCharge[kPhiSlices] ; 
-  TMatrixD *arrayofEroverEz[kPhiSlices], *arrayofEphioverEz[kPhiSlices], *arrayofDeltaEz[kPhiSlices] ; 
+  TMatrixD *arrayofArrayV[kPhiSlices], *arrayofCharge[kPhiSlices] ;
+  TMatrixD *arrayofEroverEz[kPhiSlices], *arrayofEphioverEz[kPhiSlices], *arrayofDeltaEz[kPhiSlices] ;
 
   for ( Int_t k = 0 ; k < kPhiSlices ; k++ ) {
     arrayofArrayV[k]     =   new TMatrixD(kRows,kColumns) ;
@@ -345,7 +316,7 @@ void AliTPCROCVoltError3D::InitROCVoltError3D() {
     arrayofEphioverEz[k] =   new TMatrixD(kRows,kColumns) ;
     arrayofDeltaEz[k]    =   new TMatrixD(kRows,kColumns) ;
   }
-  
+
   // list of point as used in the poisson relation and the interpolation (during sum up)
   Double_t  rlist[kRows], zedlist[kColumns] , philist[kPhiSlices];
   for ( Int_t k = 0 ; k < kPhiSlices ; k++ ) {
@@ -361,30 +332,30 @@ void AliTPCROCVoltError3D::InitROCVoltError3D() {
   // ==========================================================================
   // Solve Poisson's equation in 3D cylindrical coordinates by relaxation technique
   // Allow for different size grid spacing in R and Z directions
-  
+
   const Int_t   symmetry = 0;
- 
+
   // Set bondaries and solve Poisson's equation --------------------------
-  
+
   if ( !fInitLookUp ) {
-    
+
     AliInfo(Form("Solving the poisson equation (~ %d sec)",2*10*(int)(kPhiSlices/10)));
-    
+
     for ( Int_t side = 0 ; side < 2 ; side++ ) {  // Solve Poisson3D twice; once for +Z and once for -Z
-      
+
       for ( Int_t k = 0 ; k < kPhiSlices ; k++ )  {
 	TMatrixD &arrayV    =  *arrayofArrayV[k] ;
 	TMatrixD &charge    =  *arrayofCharge[k] ;
-	
+
 	//Fill arrays with initial conditions.  V on the boundary and Charge in the volume.
 	for ( Int_t i = 0 ; i < kRows ; i++ ) {
 	  for ( Int_t j = 0 ; j < kColumns ; j++ ) {  // Fill Vmatrix with Boundary Conditions
-	    arrayV(i,j) = 0.0 ; 
+	    arrayV(i,j) = 0.0 ;
 	    charge(i,j) = 0.0 ;
 
 	    Float_t radius0 = rlist[i] ;
 	    Float_t phi0    = gridSizePhi * k ;
-	    
+
 	    // To avoid problems at sector boundaries, use an average of +- 1 degree from actual phi location
 	    if ( j == (kColumns-1) ) {
 	      arrayV(i,j) = 0.5*  ( GetROCVoltOffset( side, radius0, phi0+0.02 ) + GetROCVoltOffset( side, radius0, phi0-0.02 ) ) ;
@@ -393,45 +364,45 @@ void AliTPCROCVoltError3D::InitROCVoltError3D() {
 		arrayV(i,j) = -arrayV(i,j); // minus sign on the C side to allow a consistent usage of global z when setting the boundaries
 	    }
 	  }
-	}      
-	
-	for ( Int_t i = 1 ; i < kRows-1 ; i++ ) { 
+	}
+
+	for ( Int_t i = 1 ; i < kRows-1 ; i++ ) {
 	  for ( Int_t j = 1 ; j < kColumns-1 ; j++ ) {
 	    charge(i,j)  =  0.0 ;
 	  }
 	}
-      }      
-      
+      }
+
       // Solve Poisson's equation in 3D cylindrical coordinates by relaxation technique
       // Allow for different size grid spacing in R and Z directions
-      
-      PoissonRelaxation3D( arrayofArrayV, arrayofCharge, 
+
+      PoissonRelaxation3D( arrayofArrayV, arrayofCharge,
 			   arrayofEroverEz, arrayofEphioverEz, arrayofDeltaEz,
-			   kRows, kColumns, kPhiSlices, gridSizePhi, kIterations, 
+			   kRows, kColumns, kPhiSlices, gridSizePhi, kIterations,
 			   symmetry, fROCdisplacement) ;
-      
-      
+
+
       //Interpolate results onto a custom grid which is used just for these calculations.
       Double_t  r, phi, z ;
       for ( Int_t k = 0 ; k < kNPhi ; k++ ) {
 	phi = fgkPhiList[k] ;
-	
+
 	TMatrixF &erOverEz   =  *fLookUpErOverEz[k]  ;
 	TMatrixF &ephiOverEz =  *fLookUpEphiOverEz[k];
 	TMatrixF &deltaEz    =  *fLookUpDeltaEz[k]   ;
-	
+
 	for ( Int_t j = 0 ; j < kNZ ; j++ ) {
 
 	  z = TMath::Abs(fgkZList[j]) ;  // Symmetric solution in Z that depends only on ABS(Z)
-  
+
 	  if ( side == 0 &&  fgkZList[j] < 0 ) continue; // Skip rest of this loop if on the wrong side
 	  if ( side == 1 &&  fgkZList[j] > 0 ) continue; // Skip rest of this loop if on the wrong side
-	  
-	  for ( Int_t i = 0 ; i < kNR ; i++ ) { 
+
+	  for ( Int_t i = 0 ; i < kNR ; i++ ) {
 	    r = fgkRList[i] ;
 
 	    // Interpolate basicLookup tables; once for each rod, then sum the results
-	    erOverEz(i,j)   = Interpolate3DTable(order, r, z, phi, kRows, kColumns, kPhiSlices, 
+	    erOverEz(i,j)   = Interpolate3DTable(order, r, z, phi, kRows, kColumns, kPhiSlices,
 						 rlist, zedlist, philist, arrayofEroverEz  );
 	    ephiOverEz(i,j) = Interpolate3DTable(order, r, z, phi, kRows, kColumns, kPhiSlices,
 						 rlist, zedlist, philist, arrayofEphioverEz);
@@ -448,16 +419,16 @@ void AliTPCROCVoltError3D::InitROCVoltError3D() {
       if ( side == 1 ) AliInfo(" C side done");
     } // end side loop
   }
-  
+
   // clear the temporary arrays lists
   for ( Int_t k = 0 ; k < kPhiSlices ; k++ )  {
     delete arrayofArrayV[k];
     delete arrayofCharge[k];
-    delete arrayofEroverEz[k];  
+    delete arrayofEroverEz[k];
     delete arrayofEphioverEz[k];
     delete arrayofDeltaEz[k];
   }
- 
+
 
   fInitLookUp = kTRUE;
 
@@ -465,48 +436,45 @@ void AliTPCROCVoltError3D::InitROCVoltError3D() {
 
 
 Float_t AliTPCROCVoltError3D::GetROCVoltOffset(Int_t side, Float_t r0, Float_t phi0) {
-  // 
-  // Returns the dz alignment data (in voltage equivalents) at 
-  // the given position
-  //
+  /// Returns the dz alignment data (in voltage equivalents) at
+  /// the given position
 
   Float_t xp = r0*TMath::Cos(phi0);
   Float_t yp = r0*TMath::Sin(phi0);
-  
-  // phi0 should be between 0 and 2pi 
+
+  // phi0 should be between 0 and 2pi
   if (phi0<0) phi0+=TMath::TwoPi();
   Int_t roc = (Int_t)TMath::Floor((TMath::RadToDeg()*phi0)/20);
   if (side==1) roc+=18; // C side
-  if (r0>132) roc+=36;  // OROC 
-  
+  if (r0>132) roc+=36;  // OROC
+
   // linear-plane data:  z = z0 + kx*lx + ky*ly (rotation in local coordinates)
   TMatrixD &fitData = *fdzDataLinFit;
 
-  // local coordinates                                                          
+  // local coordinates
   Double_t secAlpha = TMath::DegToRad()*(10.+20.*(((Int_t)roc)%18));
   Float_t lx = xp*TMath::Cos(secAlpha)+yp*TMath::Sin(secAlpha);
   Float_t ly = yp*TMath::Cos(secAlpha)-xp*TMath::Sin(secAlpha);
 
   // reference of rotation in lx is at the intersection between OROC and IROC
   // necessary, since the Fitprozedure is otherwise useless
-  
+
   AliTPCROC * rocInfo = AliTPCROC::Instance();
   Double_t lxRef  = (rocInfo->GetPadRowRadii(0,62)+rocInfo->GetPadRowRadii(36,0))/2;
-  
+
   Float_t dz = fitData(roc,0)+fitData(roc,1)*(lx-lxRef) + fitData(roc,2)*ly; // value in cm
 
   // aproximated Voltage-offset-aquivalent to the z misalignment
   // (linearly scaled with the z position)
-  Double_t ezField = (fgkCathodeV-fgkGG)/fgkTPCZ0; // = ALICE Electric Field (V/cm) Magnitude ~ -400 V/cm; 
+  Double_t ezField = (fgkCathodeV-fgkGG)/fgkTPCZ0; // = ALICE Electric Field (V/cm) Magnitude ~ -400 V/cm;
   Float_t voltOff = dz*ezField;            // values in "Volt equivalents"
 
   return voltOff;
 }
 
 TH2F * AliTPCROCVoltError3D::CreateHistoOfZAlignment(Int_t side, Int_t nx, Int_t ny) {
-  //
-  // return a simple histogramm containing the input to the poisson solver
-  // (z positions of the Read-out chambers, linearly interpolated)
+  /// return a simple histogramm containing the input to the poisson solver
+  /// (z positions of the Read-out chambers, linearly interpolated)
 
   char hname[100];
   if (side==0) snprintf(hname,100,"survey_dz_Aside");
@@ -518,23 +486,23 @@ TH2F * AliTPCROCVoltError3D::CreateHistoOfZAlignment(Int_t side, Int_t nx, Int_t
     Double_t yp = h->GetYaxis()->GetBinCenter(iy);
     for (Int_t ix=1;ix<=nx;++ix) {
       Double_t xp = h->GetXaxis()->GetBinCenter(ix);
-    
+
       Float_t r0 = TMath::Sqrt(xp*xp+yp*yp);
-      Float_t phi0 = TMath::ATan2(yp,xp); 
-   
+      Float_t phi0 = TMath::ATan2(yp,xp);
+
       Float_t dz = GetROCVoltOffset(side,r0,phi0); // in [volt]
 
-      Double_t ezField = (fgkCathodeV-fgkGG)/fgkTPCZ0; // = ALICE Electric Field (V/cm) Magnitude ~ -400 V/cm; 
+      Double_t ezField = (fgkCathodeV-fgkGG)/fgkTPCZ0; // = ALICE Electric Field (V/cm) Magnitude ~ -400 V/cm;
       dz = dz/ezField;    // in [cm]
 
       if (85.<=r0 && r0<=245.) {
-	h->SetBinContent(ix,iy,dz); 
+	h->SetBinContent(ix,iy,dz);
       } else {
 	h->SetBinContent(ix,iy,0.);
       }
     }
   }
-  
+
   h->GetXaxis()->SetTitle("x [cm]");
   h->GetYaxis()->SetTitle("y [cm]");
   h->GetZaxis()->SetTitle("dz [cm]");
@@ -542,13 +510,11 @@ TH2F * AliTPCROCVoltError3D::CreateHistoOfZAlignment(Int_t side, Int_t nx, Int_t
   //  h->DrawCopy("colz");
 
   return h;
-} 
+}
 
 void AliTPCROCVoltError3D::Print(const Option_t* option) const {
-  //
-  // Print function to check the settings of the Rod shifts and the rotated clips
-  // option=="a" prints the C0 and C1 coefficents for calibration purposes
-  //
+  /// Print function to check the settings of the Rod shifts and the rotated clips
+  /// option=="a" prints the C0 and C1 coefficents for calibration purposes
 
   TString opt = option; opt.ToLower();
   printf("%s\n",GetTitle());
@@ -561,16 +527,16 @@ void AliTPCROCVoltError3D::Print(const Option_t* option) const {
   if (opt.Contains("a")) { // Print all details
     TMatrixD &fitData = *fdzDataLinFit;
     printf(" A side:  IROC   ROCX=(z0,kx,ky): \n");
-    for (Int_t roc = 0; roc<18; roc++) 
+    for (Int_t roc = 0; roc<18; roc++)
       printf("ROC%d:(%.2e,%.2e,%.2e) ",roc,fitData(roc,0),fitData(roc,1),fitData(roc,2));
     printf("\n A side:  OROC   ROCX=(z0,kx,ky): \n");
-    for (Int_t roc = 36; roc<54; roc++) 
+    for (Int_t roc = 36; roc<54; roc++)
       printf("ROC%d:(%.2e,%.2e,%.2e) ",roc,fitData(roc,0),fitData(roc,1),fitData(roc,2));
     printf("\n C side:  IROC   ROCX=(z0,kx,ky): \n");
-    for (Int_t roc = 18; roc<36; roc++) 
+    for (Int_t roc = 18; roc<36; roc++)
       printf("ROC%d:(%.2e,%.2e,%.2e) ",roc,fitData(roc,0),fitData(roc,1),fitData(roc,2));
     printf("\n C side:  OROC   ROCX=(z0,kx,ky): \n");
-    for (Int_t roc = 54; roc<72; roc++) 
+    for (Int_t roc = 54; roc<72; roc++)
       printf("ROC%d:(%.2e,%.2e,%.2e) ",roc,fitData(roc,0),fitData(roc,1),fitData(roc,2));
     printf("\n\n");
     printf(" - T1: %1.4f, T2: %1.4f \n",fT1,fT2);
diff --git a/TPC/TPCbase/AliTPCROCVoltError3D.h b/TPC/TPCbase/AliTPCROCVoltError3D.h
index 93a6c9efb32..8051e604540 100644
--- a/TPC/TPCbase/AliTPCROCVoltError3D.h
+++ b/TPC/TPCbase/AliTPCROCVoltError3D.h
@@ -4,10 +4,8 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-////////////////////////////////////////////////////////////////////////////
-// AliTPCROCVoltError3D class                                             //
-// Authors: Jim Thomas, Stefan Rossegger                                  //
-////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCROCVoltError3D
+/// \author Jim Thomas, Stefan Rossegger
 
 #include "AliTPCCorrection.h"
 #include "TH2F.h"
@@ -32,33 +30,33 @@ public:
   Float_t GetC0() const {return fC0;}
   Float_t GetC1() const {return fC1;}
   void SetROCData(TMatrixD * matrix);
-  // setters and getters 
+  // setters and getters
   void SetROCDataFileName(const char * fname);
   const Char_t* GetROCDataFileName() const {return fROCDataFileName.Data();}
 
-  // flag to wheter or not include the z aligment in the dz calculation 
+  // flag to wheter or not include the z aligment in the dz calculation
   // if FALSE, the dz offset is purely due to the electric field change
-  void SetROCDisplacement(Bool_t flag) { 
+  void SetROCDisplacement(Bool_t flag) {
     if (flag!=fROCdisplacement) { fROCdisplacement = flag; fInitLookUp=kFALSE; }
   }
   Bool_t GetROCDisplacement() const { return fROCdisplacement; }
-  
+
   // flag on wheter to consider the difference in the electron arrival between IROC and OROC
   // due to the different position of the Anode wires
-  void SetElectronArrivalCorrection(Bool_t flag) { 
+  void SetElectronArrivalCorrection(Bool_t flag) {
     if (flag!=fElectronArrivalCorrection) { fElectronArrivalCorrection = flag; fInitLookUp=kFALSE; }
   }
   Bool_t GetElectronArrivalCorrection() const { return fElectronArrivalCorrection; }
 
 
   void InitROCVoltError3D(); // Fill the lookup tables
-  void ForceInitROCVoltError3D() { fInitLookUp=kFALSE; InitROCVoltError3D(); }; 
+  void ForceInitROCVoltError3D() { fInitLookUp=kFALSE; InitROCVoltError3D(); };
 
   Float_t GetROCVoltOffset(Int_t side, Float_t r0, Float_t phi0);
   TH2F* CreateHistoOfZAlignment(Int_t side, Int_t nx=250, Int_t ny=250);
 
   virtual void Print(const Option_t* option="") const;
-  TMatrixD *GetMatrix() const {return fdzDataLinFit;}  // Linear fits of dz survey points (each sector=72) (z0,slopeX,slopeY)         
+  TMatrixD *GetMatrix() const {return fdzDataLinFit;}  // Linear fits of dz survey points (each sector=72) (z0,slopeX,slopeY)
 
 protected:
   virtual void GetCorrection(const Float_t x[],const Short_t roc,Float_t dx[]);
@@ -68,32 +66,34 @@ private:
   AliTPCROCVoltError3D(const AliTPCROCVoltError3D &);               // not implemented
   AliTPCROCVoltError3D &operator=(const AliTPCROCVoltError3D &);    // not implemented
 
-  Float_t fC0; // coefficient C0           (compare Jim Thomas's notes for definitions)
-  Float_t fC1; // coefficient C1           (compare Jim Thomas's notes for definitions)
+  Float_t fC0; ///< coefficient C0           (compare Jim Thomas's notes for definitions)
+  Float_t fC1; ///< coefficient C1           (compare Jim Thomas's notes for definitions)
 
-  Bool_t fROCdisplacement;      // flag on wheter to consider the ROC displacement 
+  Bool_t fROCdisplacement;      ///< flag on wheter to consider the ROC displacement
                                 // when calculating the z distortions
-  Bool_t fElectronArrivalCorrection; // flag on wheter to consider the difference 
+  Bool_t fElectronArrivalCorrection; ///< flag on wheter to consider the difference
                                       // in the electron arrival between IROC and OROC
                                       // due to the different position of the Anode wires
 
-  Bool_t fInitLookUp;           // flag to check it the Look Up table was created (SUM)
+  Bool_t fInitLookUp;           ///< flag to check it the Look Up table was created (SUM)
 
-  TMatrixF *fLookUpErOverEz[kNPhi];   // Array to store electric field integral (int Er/Ez)
-  TMatrixF *fLookUpEphiOverEz[kNPhi]; // Array to store electric field integral (int Er/Ez)
-  TMatrixF *fLookUpDeltaEz[kNPhi];    // Array to store electric field integral (int Er/Ez)
+  TMatrixF *fLookUpErOverEz[kNPhi];   ///< Array to store electric field integral (int Er/Ez)
+  TMatrixF *fLookUpEphiOverEz[kNPhi]; ///< Array to store electric field integral (int Er/Ez)
+  TMatrixF *fLookUpDeltaEz[kNPhi];    ///< Array to store electric field integral (int Er/Ez)
 
-  TString  fROCDataFileName;         // filename of the survey data containing the lin Fit values
-  TMatrixD *fdzDataLinFit;  // Linear fits of dz survey points (each sector=72) (z0,slopeX,slopeY)         
+  TString  fROCDataFileName;         ///< filename of the survey data containing the lin Fit values
+  TMatrixD *fdzDataLinFit;  ///< Linear fits of dz survey points (each sector=72) (z0,slopeX,slopeY)
 
   // basic numbers for the poisson relaxation //can be set individually in each class
   enum {kRows   =257}; // grid size in r direction used in the poisson relaxation // ( 2**n + 1 ) eg. 65, 129, 257 etc.
   enum {kColumns=129}; // grid size in z direction used in the poisson relaxation // ( 2**m + 1 ) eg. 65, 129, 257 etc.
   enum {kPhiSlicesPerSector=10};  // phi slices per sector
   enum {kPhiSlices = 18*kPhiSlicesPerSector };    // number of points in phi for the basic lookup tables
-  enum {kIterations=100}; // Number of iterations within the poisson relaxation 
+  enum {kIterations=100}; // Number of iterations within the poisson relaxation
 
-  ClassDef(AliTPCROCVoltError3D,2); 
+  /// \cond CLASSIMP
+  ClassDef(AliTPCROCVoltError3D,2);
+  /// \endcond
 };
 
 #endif
diff --git a/TPC/TPCbase/AliTPCRawStreamV3.cxx b/TPC/TPCbase/AliTPCRawStreamV3.cxx
index 2181c6fd576..25557eef25c 100644
--- a/TPC/TPCbase/AliTPCRawStreamV3.cxx
+++ b/TPC/TPCbase/AliTPCRawStreamV3.cxx
@@ -13,17 +13,13 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/* $Id: AliTPCRawStreamV3.cxx 22777 2007-12-05 17:37:33Z marian $ */
 
-///////////////////////////////////////////////////////////////////////////////
-///
-/// This class provides access to TPC digits in raw data.
+/// \class AliTPCRawStreamV3
+/// \brief This class provides access to TPC digits in raw data.
 ///
 /// It loops over all TPC digits in the raw data given by the AliRawReader.
 /// The NextChannel method loads the data for the next pad. If there is no pad left
 /// it returns kFALSE.
-///
-///////////////////////////////////////////////////////////////////////////////
 
 #include <TSystem.h>
 
@@ -32,7 +28,9 @@
 #include "AliLog.h"
 #include "AliTPCAltroMapping.h"
 
+/// \cond CLASSIMP
 ClassImp(AliTPCRawStreamV3)
+/// \endcond
 
 //_____________________________________________________________________________
 AliTPCRawStreamV3::AliTPCRawStreamV3(AliRawReader* rawReader, AliAltroMapping **mapping) :
@@ -107,7 +105,7 @@ Bool_t AliTPCRawStreamV3::NextChannel()
   else
     return kFALSE;
   */
-  
+
   fPrevRow = fRow;
   fPrevPad = fPad;
   fRow = -1;
@@ -131,7 +129,7 @@ Bool_t AliTPCRawStreamV3::NextDDL()
   fPrevSector = fSector;
   fSector     = -1;
   if (!AliAltroRawStreamV3::NextDDL()) return kFALSE;
-  
+
   Int_t ddlNumber = GetDDLNumber();
   if (ddlNumber < 72) {
     fSector = ddlNumber / 2;
@@ -156,11 +154,11 @@ void AliTPCRawStreamV3::ApplyAltroMapping()
     fSector = (ddlNumber - 72) / 4 + 36;
     patchIndex = (ddlNumber - 72) % 4 + 2;
   }
-  
+
   Short_t hwAddress = GetHWAddress();
   fRow = fMapping[patchIndex]->GetPadRow(hwAddress);
   fPad = fMapping[patchIndex]->GetPad(hwAddress);
-  
+
 
 //  if ((fRow < 0) || (fPad < 0))
 //    AddMappingErrorLog(Form("hw=%d",hwAddress));
diff --git a/TPC/TPCbase/AliTPCRawStreamV3.h b/TPC/TPCbase/AliTPCRawStreamV3.h
index c9ebdcd10c0..ab4b4b8a301 100644
--- a/TPC/TPCbase/AliTPCRawStreamV3.h
+++ b/TPC/TPCbase/AliTPCRawStreamV3.h
@@ -3,11 +3,8 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-///////////////////////////////////////////////////////////////////////////////
-///
-/// This class provides access to TPC digits in raw data.
-///
-///////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCRawStreamV3
+/// \brief This class provides access to TPC digits in raw data.
 
 #include "AliAltroRawStreamV3.h"
 
@@ -22,7 +19,7 @@ class AliTPCRawStreamV3: public AliAltroRawStreamV3 {
     virtual void             Reset();
     virtual Bool_t           NextChannel();
     virtual Bool_t           NextDDL();
-  
+
     inline Int_t GetSector()     const { return fSector; }     // Provide index of current sector
     inline Int_t GetPrevSector() const { return fPrevSector; } // Provide index of previous sector
     inline Bool_t  IsNewSector() const {return fSector != fPrevSector;};
@@ -41,18 +38,20 @@ class AliTPCRawStreamV3: public AliAltroRawStreamV3 {
 
     virtual void ApplyAltroMapping();
 
-    Int_t            fSector;       // index of current sector
-    Int_t            fPrevSector;   // index of previous sector
-    Int_t            fRow;          // index of current row
-    Int_t            fPrevRow;      // index of previous row
-    Int_t            fPad;          // index of current pad
-    Int_t            fPrevPad;      // index of previous pad
-    Int_t            fPatchIndex;   // current patch
+    Int_t            fSector;       ///< index of current sector
+    Int_t            fPrevSector;   ///< index of previous sector
+    Int_t            fRow;          ///< index of current row
+    Int_t            fPrevRow;      ///< index of previous row
+    Int_t            fPad;          ///< index of current pad
+    Int_t            fPrevPad;      ///< index of previous pad
+    Int_t            fPatchIndex;   ///< current patch
 
-    AliAltroMapping *fMapping[6];   // Pointers to ALTRO mapping
-    Bool_t           fIsMapOwner;   // does object own its mappings?
+    AliAltroMapping *fMapping[6];   ///< Pointers to ALTRO mapping
+    Bool_t           fIsMapOwner;   ///< does object own its mappings?
 
+    /// \cond CLASSIMP
     ClassDef(AliTPCRawStreamV3, 0)    // base class for reading TPC raw digits using the fast algorithm
+    /// \endcond
 };
 
 #endif
diff --git a/TPC/TPCbase/AliTPCRecoParam.cxx b/TPC/TPCbase/AliTPCRecoParam.cxx
index 073ec5d8665..3cbc0627106 100644
--- a/TPC/TPCbase/AliTPCRecoParam.cxx
+++ b/TPC/TPCbase/AliTPCRecoParam.cxx
@@ -14,44 +14,40 @@
  **************************************************************************/
 
 
-///////////////////////////////////////////////////////////////////////////////
-//                                                                           //
-// Class with TPC reconstruction parameters                                  //
-//                                                                           //  
-//
-/*
-  The reconstruction parameters are used in the AliTPCclusterer and AliTPCtracker
-  
-  They are retrieved:
-  0. User speciefied it in reconstruction macro
-  1. if (not 0) from OCDB  - AliTPCcalibDB::GetRecoParam(eventtype)
-  2. if (not 0 or 1) default parameter - High flux enevironment used  
-
-
-  // Setting for systematic errors addition
-  [0] - systematic RMSY
-  [1] - systematic RMSZ
-  [2] - systematic RMSSNP
-  [3] - systematic RMSTheta
-  [4] - systematic RMSCuravture -  systematic error in 1/cm not in 1/pt
-  //
-  //  How to add it example - 3 mm systematic error y, 3 cm systematic error z (drift)
-  Double_t sysError[5]={0.3,3, 0.3/150., 3./150.,0.3/(150*150.)}
-  param->SetSystematicError(sysError);
-
-*/
-                                                                           //
-///////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCRecoParam
+/// \brief Class with TPC reconstruction parameters
+///
+/// The reconstruction parameters are used in the AliTPCclusterer and AliTPCtracker
+///
+/// They are retrieved:
+/// 0. User speciefied it in reconstruction macro
+/// 1. if (not 0) from OCDB  - AliTPCcalibDB::GetRecoParam(eventtype)
+/// 2. if (not 0 or 1) default parameter - High flux enevironment used
+///
+/// Setting for systematic errors addition:
+/// [0] - systematic RMSY
+/// [1] - systematic RMSZ
+/// [2] - systematic RMSSNP
+/// [3] - systematic RMSTheta
+/// [4] - systematic RMSCuravture -  systematic error in 1/cm not in 1/pt
+///
+/// How to add it example - 3 mm systematic error y, 3 cm systematic error z (drift)
+/// ~~~{.cxx}
+/// Double_t sysError[5]={0.3,3, 0.3/150., 3./150.,0.3/(150*150.)}
+/// param->SetSystematicError(sysError);
+/// ~~~
 
 
 #include "AliTPCRecoParam.h"
 
+/// \cond CLASSIMP
 ClassImp(AliTPCRecoParam)
+/// \endcond
 
 
 Bool_t AliTPCRecoParam::fgUseTimeCalibration=kTRUE; // flag usage the time dependent calibration
                                       // to be switched off for pass 0 reconstruction
-                                      // Use static function, other option will be to use 
+                                      // Use static function, other option will be to use
                                       // additional specific storage ?
 
 //_____________________________________________________________________________
@@ -60,7 +56,7 @@ AliTPCRecoParam::AliTPCRecoParam():
   fUseHLTClusters(4),  // use HLTorRAW data
   fUseHLTPreSeeding(0), // no pre-seeding for now
   fBClusterSharing(kTRUE),
-  fCtgRange(1.05),       
+  fCtgRange(1.05),
   fMaxSnpTracker(0.95),
   fMaxSnpTrack(0.999),
   fUseOuterDetectors(kFALSE),
@@ -110,23 +106,22 @@ AliTPCRecoParam::AliTPCRecoParam():
   fMinFraction(0.01),           // truncated mean - lower threshold
   fMaxFaction(0.7),            // truncated mean - upper threshold
   fNeighborRowsDedx(2),           // neighbour rows for below threshold dEdx calculation
-  fGainCorrectionHVandPTMode(0), // switch for the usage of GainCorrectionHVandPT (see AliTPCcalibDB::GetGainCorrectionHVandPT   
+  fGainCorrectionHVandPTMode(0), // switch for the usage of GainCorrectionHVandPT (see AliTPCcalibDB::GetGainCorrectionHVandPT
   fSkipTimeBins(5),              // number of time bins to be skiiped (corrupted signal druing gating opening)
   fUseTOFCorrection(kTRUE),
   fUseSystematicCorrelation(kTRUE)
 {
-  //
-  // constructor
-  //
+  /// constructor
+
   SetName("TPC");
   SetTitle("TPC");
   for (Int_t i=0;i<5;i++) fSystematicErrors[i]=0;
   // systematic error parameterization at INNER wall of the TPC
   fSystematicErrorClusterInner[0]=0.5;   // 0.5 cm
-  fSystematicErrorClusterInner[1]=5;     // 5 cm slope  
+  fSystematicErrorClusterInner[1]=5;     // 5 cm slope
   //
   fSystematicErrorCluster[0]=0;   // sy cluster error
-  fSystematicErrorCluster[1]=0;   // sz cluster error  
+  fSystematicErrorCluster[1]=0;   // sz cluster error
 
   //
   fCutSharedClusters[0]=0.5; // maximal allowed fraction of shared clusters - shorter track
@@ -135,22 +130,20 @@ AliTPCRecoParam::AliTPCRecoParam():
   fClusterMaxRange[1]=1;     // z - time bin range
   fKinkAngleCutChi2[0]=9;    // angular cut for kink finder - to create a kink
                              // ~ about 5 % rate  for high pt kink finder
-  fKinkAngleCutChi2[1]=12;    // angular cut for kink finder - to use the partial track                             // form kink 
+  fKinkAngleCutChi2[1]=12;    // angular cut for kink finder - to use the partial track                             // form kink
                              // ~ about 2 % rate  for high pt kink finder
 }
 
 //_____________________________________________________________________________
-AliTPCRecoParam::~AliTPCRecoParam() 
+AliTPCRecoParam::~AliTPCRecoParam()
 {
-  //
-  // destructor
-  //  
+  /// destructor
+
 }
 
 void AliTPCRecoParam::Print(const Option_t* /*option*/) const{
-  //
-  //
-  //
+  ///
+
   AliTPCRecoParam::Dump();
   printf("Systematic errors:\n");
   const char * cherrs[5]={"sy=","sz=","ssnp=","stheta=","s1pt="};
@@ -161,9 +154,8 @@ void AliTPCRecoParam::Print(const Option_t* /*option*/) const{
 
 
 AliTPCRecoParam *AliTPCRecoParam::GetLowFluxParam(){
-  //
-  // make default reconstruction  parameters for low  flux env.
-  //
+  /// make default reconstruction  parameters for low  flux env.
+
   AliTPCRecoParam *param = new AliTPCRecoParam;
   param->fCtgRange = 10;
   param->fFirstBin = 0;
@@ -174,13 +166,12 @@ AliTPCRecoParam *AliTPCRecoParam::GetLowFluxParam(){
 }
 
 AliTPCRecoParam *AliTPCRecoParam::GetHighFluxParam(){
-  //
-  // make reco parameters for high flux env.
-  //
+  /// make reco parameters for high flux env.
+
   AliTPCRecoParam *param = new AliTPCRecoParam;
   param->fCtgRange = 1.05;
   param->fFirstBin = 0;
-  param->fLastBin  = 1000;  
+  param->fLastBin  = 1000;
   param->fUseTotCharge=kFALSE;
   param->SetName("High Flux");
   param->SetTitle("High Flux");
@@ -188,26 +179,24 @@ AliTPCRecoParam *AliTPCRecoParam::GetHighFluxParam(){
 }
 
 AliTPCRecoParam *AliTPCRecoParam::GetHLTParam(){
-  //
-  // make reco parameters for high flux env.
-  //
+  /// make reco parameters for high flux env.
+
   AliTPCRecoParam *param = new AliTPCRecoParam;
   param->fCtgRange = 1.05;
   param->fFirstBin = 80;
-  param->fLastBin  = 1000;  
-  param->fMaxSnpTracker = 0.9; 
-  param->fMaxC          = 0.06; 
+  param->fLastBin  = 1000;
+  param->fMaxSnpTracker = 0.9;
+  param->fMaxC          = 0.06;
   //
   param->SetName("Hlt Param");
-  param->SetTitle("Hlt Param"); 
+  param->SetTitle("Hlt Param");
   param->fBKinkFinder   = kFALSE;
   return param;
 }
 
 AliTPCRecoParam *AliTPCRecoParam::GetLaserTestParam(Bool_t bPedestal){
-  //
-  // special setting for laser
-  //
+  /// special setting for laser
+
   AliTPCRecoParam *param = new AliTPCRecoParam;
   param->fDumpSignal=kTRUE;
   param->fCtgRange = 10.05;
@@ -230,9 +219,8 @@ AliTPCRecoParam *AliTPCRecoParam::GetLaserTestParam(Bool_t bPedestal){
 }
 
 AliTPCRecoParam *AliTPCRecoParam::GetCosmicTestParam(Bool_t bPedestal){
-  //
-  // special setting for cosmic 
-  // 
+  /// special setting for cosmic
+
   AliTPCRecoParam *param = new AliTPCRecoParam;
   param->fDumpSignal=kTRUE;
   param->fCtgRange = 10.05;    // full TPC
@@ -251,16 +239,14 @@ AliTPCRecoParam *AliTPCRecoParam::GetCosmicTestParam(Bool_t bPedestal){
 }
 
 
-Bool_t  AliTPCRecoParam::GetUseTimeCalibration(){ 
-  //
-  // get
-  //
+Bool_t  AliTPCRecoParam::GetUseTimeCalibration(){
+  /// get
+
   return fgUseTimeCalibration;
 }
 void    AliTPCRecoParam::SetUseTimeCalibration(Bool_t useTimeCalibration) {
-  //
-  // set 
-  //
+  /// set
+
   fgUseTimeCalibration = useTimeCalibration;
 }
 
diff --git a/TPC/TPCbase/AliTPCRecoParam.h b/TPC/TPCbase/AliTPCRecoParam.h
index 863c09e293a..6cccf0e5954 100644
--- a/TPC/TPCbase/AliTPCRecoParam.h
+++ b/TPC/TPCbase/AliTPCRecoParam.h
@@ -3,18 +3,15 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-///////////////////////////////////////////////////////////////////////////////
-//                                                                           //
-// Class with TPC reconstruction parameters                                  //
-//                                                                           //
-///////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCRecoParam
+/// \brief Class with TPC reconstruction parameters
 
 
 #include "AliDetectorRecoParam.h"
 
 class AliTPCRecoParam : public AliDetectorRecoParam
 {
- public: 
+ public:
   AliTPCRecoParam();
   virtual ~AliTPCRecoParam();
   virtual void Print(const Option_t* option="") const;
@@ -55,43 +52,43 @@ class AliTPCRecoParam : public AliDetectorRecoParam
   Bool_t   GetDoUnfold()           const  { return fBDoUnfold;}
   void     SetDoUnfold(Bool_t unfold)     { fBDoUnfold = unfold;}
   Float_t  GetDumpAmplitudeMin()   const  { return fDumpAmplitudeMin;}
-  Float_t  GetMaxNoise()           const  { return fMaxNoise;}  
+  Float_t  GetMaxNoise()           const  { return fMaxNoise;}
   //
   Int_t    GetUseOnePadCluster()   const  { return fUseOnePadCluster;}
   Bool_t   GetUseHLTOnePadCluster()const  { return fUseHLTOnePadCluster;}
   Float_t  GetMinMaxCutAbs()       const  { return fMinMaxCutAbs; }
   Float_t  GetMinLeftRightCutAbs() const  { return fMinLeftRightCutAbs;}  // minimal amplitude left right - PRF
-  Float_t  GetMinUpDownCutAbs()    const  { return fMinUpDownCutAbs;}  // minimal amplitude up-down - TRF 
+  Float_t  GetMinUpDownCutAbs()    const  { return fMinUpDownCutAbs;}  // minimal amplitude up-down - TRF
   Float_t  GetMinMaxCutSigma()       const  { return fMinMaxCutSigma; }
   Float_t  GetMinLeftRightCutSigma() const  { return fMinLeftRightCutSigma;}  // minimal amplitude left right - PRF
-  Float_t  GetMinUpDownCutSigma()    const  { return fMinUpDownCutSigma;}  // minimal amplitude up-down - TRF 
+  Float_t  GetMinUpDownCutSigma()    const  { return fMinUpDownCutSigma;}  // minimal amplitude up-down - TRF
   //
   void SetUseOnePadCluster(Int_t use)      {   fUseOnePadCluster = use;}
   void SetUseHLTOnePadCluster(Bool_t use)  {   fUseHLTOnePadCluster = use;}
   void SetMinMaxCutAbs(Float_t th)         {   fMinMaxCutAbs=th; }
   void SetMinLeftRightCutAbs(Float_t th)   {   fMinLeftRightCutAbs=th;}  // minimal amplitude left right - PRF
-  void SetMinUpDownCutAbs(Float_t th)      {   fMinUpDownCutAbs=th;}  // minimal amplitude up-down - TRF 
+  void SetMinUpDownCutAbs(Float_t th)      {   fMinUpDownCutAbs=th;}  // minimal amplitude up-down - TRF
   void SetMinMaxCutSigma(Float_t th)       {   fMinMaxCutSigma=th; }
   void SetMinLeftRightCutSigma(Float_t th) {   fMinLeftRightCutSigma=th;}  // minimal amplitude left right - PRF
-  void SetMinUpDownCutSigma(Float_t th)    {   fMinUpDownCutSigma=th;}  // minimal amplitude up-down - TRF 
+  void SetMinUpDownCutSigma(Float_t th)    {   fMinUpDownCutSigma=th;}  // minimal amplitude up-down - TRF
   void  SetUseTotCharge(Bool_t flag) {fUseTotCharge = flag;}
   void  SetCtgRange(Double_t ctgRange) {fCtgRange = ctgRange;}
   void  SetUseMultiplicityCorrectionDedx(Bool_t flag) {fUseMultiplicityCorrectionDedx = flag;}
-  
+
   void  SetUseAlignmentTime(Bool_t flag) {fUseAlignmentTime = flag;}
   void  SetNeighborRowsDedx(Int_t nRows) {fNeighborRowsDedx = nRows;}
   void SetCorrectionHVandPTMode(Int_t value){ fGainCorrectionHVandPTMode =value;}
   void SetSkipTimeBins(Double_t value) {fSkipTimeBins=value;}
   //
-  Int_t    GetLastSeedRowSec()       const  { return fLastSeedRowSec;} 
-  Int_t    GetSeedGapPrim()        const  { return fSeedGapPrim;} 
-  Int_t    GetSeedGapSec()         const  { return fSeedGapSec;} 
+  Int_t    GetLastSeedRowSec()       const  { return fLastSeedRowSec;}
+  Int_t    GetSeedGapPrim()        const  { return fSeedGapPrim;}
+  Int_t    GetSeedGapSec()         const  { return fSeedGapSec;}
   void     SetDoKinks(Bool_t on)   { fBKinkFinder=on; }
   Bool_t   GetDoKinks() const      { return fBKinkFinder;}
   Double_t GetKinkAngleCutChi2(Int_t index) const {return fKinkAngleCutChi2[index];}
   void     SetKinkAngleCutChi2(Int_t index,Double_t value) {fKinkAngleCutChi2[index]=value;}
-  void     SetSeedGapPrim(Int_t seedGapPrim)         { fSeedGapPrim = seedGapPrim;} 
-  void     SetSeedGapSec(Int_t seedGapSec)          { fSeedGapSec  = seedGapSec;} 
+  void     SetSeedGapPrim(Int_t seedGapPrim)         { fSeedGapPrim = seedGapPrim;}
+  void     SetSeedGapSec(Int_t seedGapSec)          { fSeedGapSec  = seedGapSec;}
   Float_t  GetMaxC()    const      { return fMaxC;}
   Bool_t   GetSpecialSeeding() const { return fBSpecialSeeding;}
   //
@@ -139,7 +136,7 @@ class AliTPCRecoParam : public AliDetectorRecoParam
   Bool_t   GetUseTotCharge() const {return fUseTotCharge;}          // switch use total or max charge
   Float_t  GetMinFraction() const {return fMinFraction;}           // truncated mean - lower threshold
   Float_t  GetMaxFraction() const {return fMaxFaction;}            // truncated mean - upper threshold
-  Int_t    GetNeighborRowsDedx() const {return fNeighborRowsDedx;} 
+  Int_t    GetNeighborRowsDedx() const {return fNeighborRowsDedx;}
 
   //
   void     SetSystematicError(Double_t *systematic){ for (Int_t i=0; i<5;i++) fSystematicErrors[i]=systematic[i];}
@@ -152,99 +149,101 @@ class AliTPCRecoParam : public AliDetectorRecoParam
   Bool_t  GetUseSystematicCorrelation() const { return fUseSystematicCorrelation;}
 
   static   AliTPCRecoParam *GetLowFluxParam();        // make reco parameters for low  flux env.
-  static   AliTPCRecoParam *GetHighFluxParam();       // make reco parameters for high flux env. 
-  static   AliTPCRecoParam *GetHLTParam(); // special setting for HLT  
-  static   AliTPCRecoParam *GetLaserTestParam(Bool_t bPedestal);  // special setting for laser 
-  static   AliTPCRecoParam *GetCosmicTestParam(Bool_t bPedestal); // special setting for cosmic  
+  static   AliTPCRecoParam *GetHighFluxParam();       // make reco parameters for high flux env.
+  static   AliTPCRecoParam *GetHLTParam(); // special setting for HLT
+  static   AliTPCRecoParam *GetLaserTestParam(Bool_t bPedestal);  // special setting for laser
+  static   AliTPCRecoParam *GetCosmicTestParam(Bool_t bPedestal); // special setting for cosmic
   //
  protected:
 
-  Int_t    fUseHLTClusters;  // allows usage of HLT clusters instead of RAW data
-  Int_t    fUseHLTPreSeeding; // Usage of HLT pre-seeding 
-  Bool_t   fBClusterSharing; // allows or disable cluster sharing during tracking 
-  Double_t fCtgRange;        // +-fCtgRange is the ctg(Theta) window used for clusterization and tracking (MI) 
-  Double_t fMaxSnpTracker;   // max sin of local angle  - for TPC tracker
-  Double_t fMaxSnpTrack;     // max sin of local angle  - for track 
-  Bool_t   fUseOuterDetectors; // switch - to use the outer detectors
-  Double_t fMaxChi2TPCTRD;     // maximal allowed chi2 between the TRD in and TPC out to be accepted for refit
-  Double_t fMaxChi2TPCITS;     // maximal allowed chi2 between the ITS in and TPC out to be accepted for backpropagation
+  Int_t    fUseHLTClusters;  ///< allows usage of HLT clusters instead of RAW data
+  Int_t    fUseHLTPreSeeding; ///< Usage of HLT pre-seeding
+  Bool_t   fBClusterSharing; ///< allows or disable cluster sharing during tracking
+  Double_t fCtgRange;        ///< +-fCtgRange is the ctg(Theta) window used for clusterization and tracking (MI)
+  Double_t fMaxSnpTracker;   ///< max sin of local angle  - for TPC tracker
+  Double_t fMaxSnpTrack;     ///< max sin of local angle  - for track
+  Bool_t   fUseOuterDetectors; ///< switch - to use the outer detectors
+  Double_t fMaxChi2TPCTRD;     ///< maximal allowed chi2 between the TRD in and TPC out to be accepted for refit
+  Double_t fMaxChi2TPCITS;     ///< maximal allowed chi2 between the ITS in and TPC out to be accepted for backpropagation
   //
   // Outlier filtering configuration
   //
-  Int_t   fUseOulierClusterFilter;  // swith to use outlier cluster filter
+  Int_t   fUseOulierClusterFilter;  ///< swith to use outlier cluster filter
 
-  Double_t fCutSharedClusters[2]; // cut value - maximal amount  of shared clusters  
-  Int_t fClusterMaxRange[2];   // neighborhood  - to define local maxima for cluster  
+  Double_t fCutSharedClusters[2]; ///< cut value - maximal amount  of shared clusters
+  Int_t fClusterMaxRange[2];   ///< neighborhood  - to define local maxima for cluster
   //
   //   clusterer parameters
   //
-  Bool_t   fDumpSignal;      // Dump Signal information flag
-  Int_t    fFirstBin;        // first time bin used by cluster finder
-  Int_t    fLastBin;         // last time bin  used by cluster finder 
-  Bool_t   fBCalcPedestal;   // calculate Pedestal
-  Bool_t   fBDoUnfold;       // do unfolding of clusters
-  Float_t  fDumpAmplitudeMin; // minimal amplitude of signal to be dumped 
-  Float_t  fMaxNoise;        // maximal noise sigma on pad to be used in cluster finder
-  Int_t    fUseOnePadCluster; // flag - use one pad cluster -0 not use >0 use
-  Bool_t   fUseHLTOnePadCluster; // flag - use one HLT pad cluster for tracking
-  Float_t  fMinMaxCutAbs;    // minimal amplitude at cluster maxima
-  Float_t  fMinLeftRightCutAbs;  // minimal amplitude left right - PRF
-  Float_t  fMinUpDownCutAbs;  // minimal amplitude up-down - TRF 
-  Float_t  fMinMaxCutSigma;    // minimal amplitude at cluster maxima
-  Float_t  fMinLeftRightCutSigma;  // minimal amplitude left right - PRF
-  Float_t  fMinUpDownCutSigma;  // minimal amplitude up-down - TRF 
-  //
-  //
-  Float_t  fMaxC;            // maximal curvature for tracking
-  Bool_t   fBSpecialSeeding; // special seeding with big inclination angles allowed (for Cosmic and laser)
-  Bool_t   fBKinkFinder;       // do kink finder reconstruction
-  Double_t fKinkAngleCutChi2[2];   // angular cut for kinks
-  Int_t    fLastSeedRowSec;     // Most Inner Row to make seeding for secondaries
-  Int_t    fSeedGapPrim;   // seeding gap for primary tracks
-  Int_t    fSeedGapSec;   // seeding gap for secondary tracks
+  Bool_t   fDumpSignal;      ///< Dump Signal information flag
+  Int_t    fFirstBin;        ///< first time bin used by cluster finder
+  Int_t    fLastBin;         ///< last time bin  used by cluster finder
+  Bool_t   fBCalcPedestal;   ///< calculate Pedestal
+  Bool_t   fBDoUnfold;       ///< do unfolding of clusters
+  Float_t  fDumpAmplitudeMin; ///< minimal amplitude of signal to be dumped
+  Float_t  fMaxNoise;        ///< maximal noise sigma on pad to be used in cluster finder
+  Int_t    fUseOnePadCluster; ///< flag - use one pad cluster -0 not use >0 use
+  Bool_t   fUseHLTOnePadCluster; ///< flag - use one HLT pad cluster for tracking
+  Float_t  fMinMaxCutAbs;    ///< minimal amplitude at cluster maxima
+  Float_t  fMinLeftRightCutAbs;  ///< minimal amplitude left right - PRF
+  Float_t  fMinUpDownCutAbs;  ///< minimal amplitude up-down - TRF
+  Float_t  fMinMaxCutSigma;    ///< minimal amplitude at cluster maxima
+  Float_t  fMinLeftRightCutSigma;  ///< minimal amplitude left right - PRF
+  Float_t  fMinUpDownCutSigma;  ///< minimal amplitude up-down - TRF
+  //
+  //
+  Float_t  fMaxC;            ///< maximal curvature for tracking
+  Bool_t   fBSpecialSeeding; ///< special seeding with big inclination angles allowed (for Cosmic and laser)
+  Bool_t   fBKinkFinder;       ///< do kink finder reconstruction
+  Double_t fKinkAngleCutChi2[2];   ///< angular cut for kinks
+  Int_t    fLastSeedRowSec;     ///< Most Inner Row to make seeding for secondaries
+  Int_t    fSeedGapPrim;   ///< seeding gap for primary tracks
+  Int_t    fSeedGapSec;   ///< seeding gap for secondary tracks
 
   //
   // Correction switches
   //
-  Int_t fUseFieldCorrection;     // use field correction
-  Bool_t fUseComposedCorrection; // flag to use composed correction
-  Int_t fUseRPHICorrection;      // use rphi correction
-  Int_t fUseRadialCorrection;    // use radial correction
-  Int_t fUseQuadrantAlignment;   // use quadrant alignment
-  Int_t fUseSectorAlignment;     // use sector alignment
-  Int_t fUseDriftCorrectionTime; // use drift correction time
-  Int_t fUseDriftCorrectionGY;   // use drif correction global y
-  Int_t fUseGainCorrectionTime;  // use gain correction time
-  Int_t fUseExBCorrection;       // use ExB correction
-  Bool_t fUseMultiplicityCorrectionDedx; // use Dedx multiplicity correction
-  Bool_t fUseAlignmentTime;              // use time dependent alignment correction
-  Int_t fUseIonTailCorrection;   // use ion tail correction
-  Double_t fCrosstalkCorrection;   // crosstalk correction factor (fro each signal substracted by (mean signal in wite patch)xfCrosstalkCorrection) - Effect important only after removing oc capacitors in 2012
-  Double_t fCrosstalkCorrectionMissingCharge;   // crosstalk correction factor - missing charge factor (from each signal substracted by (mean signal in wite patch)xfCrosstalkCorrection) - Effect important only after removing  capacitors in 2012
+  Int_t fUseFieldCorrection;     ///< use field correction
+  Bool_t fUseComposedCorrection; ///< flag to use composed correction
+  Int_t fUseRPHICorrection;      ///< use rphi correction
+  Int_t fUseRadialCorrection;    ///< use radial correction
+  Int_t fUseQuadrantAlignment;   ///< use quadrant alignment
+  Int_t fUseSectorAlignment;     ///< use sector alignment
+  Int_t fUseDriftCorrectionTime; ///< use drift correction time
+  Int_t fUseDriftCorrectionGY;   ///< use drif correction global y
+  Int_t fUseGainCorrectionTime;  ///< use gain correction time
+  Int_t fUseExBCorrection;       ///< use ExB correction
+  Bool_t fUseMultiplicityCorrectionDedx; ///< use Dedx multiplicity correction
+  Bool_t fUseAlignmentTime;              ///< use time dependent alignment correction
+  Int_t fUseIonTailCorrection;   ///< use ion tail correction
+  Double_t fCrosstalkCorrection;   ///< crosstalk correction factor (fro each signal substracted by (mean signal in wite patch)xfCrosstalkCorrection) - Effect important only after removing oc capacitors in 2012
+  Double_t fCrosstalkCorrectionMissingCharge;   ///< crosstalk correction factor - missing charge factor (from each signal substracted by (mean signal in wite patch)xfCrosstalkCorrection) - Effect important only after removing  capacitors in 2012
  //
   // dEdx switches
   //
-  Bool_t   fUseTotCharge;          // switch use total or max charge
-  Float_t fMinFraction;           // truncated mean - lower threshold
-  Float_t fMaxFaction;            // truncated mean - upper threshold
-  Int_t   fNeighborRowsDedx;      // number of neighboring rows to identify cluster below thres in dEdx calculation 0 -> switch off
-  Int_t   fGainCorrectionHVandPTMode; // switch for the usage of GainCorrectionHVandPT (see AliTPCcalibDB::GetGainCorrectionHVandPT 
-  Double_t fSkipTimeBins;        // number of time bins to be skiiped (corrupted signal druing gating opening)
+  Bool_t   fUseTotCharge;          ///< switch use total or max charge
+  Float_t fMinFraction;           ///< truncated mean - lower threshold
+  Float_t fMaxFaction;            ///< truncated mean - upper threshold
+  Int_t   fNeighborRowsDedx;      ///< number of neighboring rows to identify cluster below thres in dEdx calculation 0 -> switch off
+  Int_t   fGainCorrectionHVandPTMode; ///< switch for the usage of GainCorrectionHVandPT (see AliTPCcalibDB::GetGainCorrectionHVandPT
+  Double_t fSkipTimeBins;        ///< number of time bins to be skiiped (corrupted signal druing gating opening)
 
-  Bool_t fUseTOFCorrection;  // switch - kTRUE use TOF correction kFALSE - do not use
+  Bool_t fUseTOFCorrection;  ///< switch - kTRUE use TOF correction kFALSE - do not use
   //
-  //  misscalibration 
+  //  misscalibration
   //
-  Double_t fSystematicErrors[5];  //systematic errors in the track parameters - to be added to TPC covariance matrix 
-  Double_t fSystematicErrorClusterInner[2];  // systematic error of the cluster - used to downscale the information
-  Double_t fSystematicErrorCluster[2];        // systematic error of the cluster - used e.g in OpenGG run to provide better cluster to track association efficiency
-  Bool_t fUseSystematicCorrelation;         // switch to use the correlation for the sys
-public:   
-  static Bool_t fgUseTimeCalibration; // flag usage the time dependent calibration
+  Double_t fSystematicErrors[5];  ///< systematic errors in the track parameters - to be added to TPC covariance matrix
+  Double_t fSystematicErrorClusterInner[2];  ///< systematic error of the cluster - used to downscale the information
+  Double_t fSystematicErrorCluster[2];        ///< systematic error of the cluster - used e.g in OpenGG run to provide better cluster to track association efficiency
+  Bool_t fUseSystematicCorrelation;         ///< switch to use the correlation for the sys
+public:
+  static Bool_t fgUseTimeCalibration; ///< flag usage the time dependent calibration
                                       // to be switched off for pass 0 reconstruction
-                                      // Use static function, other option will be to use 
+                                      // Use static function, other option will be to use
                                       // additional specific storage ?
+  /// \cond CLASSIMP
   ClassDef(AliTPCRecoParam, 21)
+  /// \endcond
 };
 
 
diff --git a/TPC/TPCbase/AliTPCSensorTemp.cxx b/TPC/TPCbase/AliTPCSensorTemp.cxx
index a634d439e5b..db5968224c2 100644
--- a/TPC/TPCbase/AliTPCSensorTemp.cxx
+++ b/TPC/TPCbase/AliTPCSensorTemp.cxx
@@ -14,12 +14,10 @@
  **************************************************************************/
 
 
-////////////////////////////////////////////////////////////////////////////////
-//                                                                            //
-// Class describing TPC temperature sensors (including pointers to graphs/fits//
-// Authors: Marian Ivanov, Haavard Helstrup and Martin Siska                  //
-//                                                                            //
-////////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCSensorTemp
+/// \brief Class describing TPC temperature sensors (including pointers to graphs/fits
+///
+/// \author Marian Ivanov, Haavard Helstrup and Martin Siska
 
 // Running instructions:
 /*
@@ -29,14 +27,16 @@
   tree->Branch("Temp",&arr);
   tree->Fill();
   tree->Write();
-  
+
 */
 
 //
 
 #include <strings.h>
 #include "AliTPCSensorTemp.h"
+/// \cond CLASSIMP
 ClassImp(AliTPCSensorTemp)
+/// \endcond
 
 
 
@@ -59,7 +59,7 @@ const Float_t kASideX[18][5]={
 	{ 64.99,   76.75,  104.97,  122,     139.1},
 	{ 87.56,  103.4,   141.42,  164.37,  187.41},
 	{ 99.56,  117.59,  160.82,  186.92,  213.11}};
-	
+
 const Float_t kASideY[18][5]={
         { 17.56,   20.73,   28.36,   32.96,   37.58},
 	{ 50.55,   59.7,    81.65,   94.9,   108.2},
@@ -78,8 +78,8 @@ const Float_t kASideY[18][5]={
         {-95.0, -112.2, -153.45, -178.35, -203.35},
 	{-77.45,  -91.47, -125.1, -145.4, -165.77},
 	{-50.55,  -59.7,  -81.65,  -94.9, -108.2},
-	{-17.56,  -20.73, -28.36,  -32.96, -37.58}};  
-	
+	{-17.56,  -20.73, -28.36,  -32.96, -37.58}};
+
 const Float_t kCSideX[18][5]={
         { 99.56,  117.59,  160.82,  186.92,  213.11},
 	{ 87.56,  103.4,   141.42,  164.37,  187.41},
@@ -118,12 +118,12 @@ const Float_t kCSideY[18][5]={
         {-95.0, -112.2, -153.45, -178.35, -203.35},
 	{-77.45,  -91.47, -125.1, -145.4, -165.77},
 	{-50.55,  -59.7,  -81.65,  -94.9, -108.2},
-	{-17.56,  -20.73, -28.36,  -32.96,  -37.58}};  
+	{-17.56,  -20.73, -28.36,  -32.96,  -37.58}};
 
 const Float_t kIFCrad[5] = {67.2, 64.4, 60.7, 64.4, 67.2};
 
-const Float_t kTSrad[4] =  {67.2, 61.5, 67.2, 61.5}; 
-const Float_t kTSz[4] =  {240.0, 90.0, 240.0, 90.0}; 
+const Float_t kTSrad[4] =  {67.2, 61.5, 67.2, 61.5};
+const Float_t kTSz[4] =  {240.0, 90.0, 240.0, 90.0};
 
 //______________________________________________________________________________________________
 
@@ -133,9 +133,8 @@ AliTPCSensorTemp::AliTPCSensorTemp(): AliDCSSensor(),
   fSector(0),
   fNum(0)
 {
-  //
-  //  Standard constructor
-  //
+  /// Standard constructor
+
 }
 //______________________________________________________________________________________________
 
@@ -153,33 +152,31 @@ AliTPCSensorTemp::AliTPCSensorTemp(const AliTPCSensorTemp& source) :
 //______________________________________________________________________________________________
 
 AliTPCSensorTemp& AliTPCSensorTemp::operator=(const AliTPCSensorTemp& source){
-//
-// assignment operator
-//
+/// assignment operator
+
   if (&source == this) return *this;
   new (this) AliTPCSensorTemp(source);
-  
-  return *this;  
+
+  return *this;
 }
 //______________________________________________________________________________________________
 
 TClonesArray * AliTPCSensorTemp::ReadList(const char *fname,
                                           const TString& amandaString) {
-  //
-  // read values from ascii file
-  //
+  /// read values from ascii file
+
   TTree * tree = new TTree("asci","asci");
   tree->ReadFile(fname,"");
   TClonesArray *arr = ReadTree(tree, amandaString);
   delete tree;
   return arr;
 }
-     
+
 //______________________________________________________________________________________________
 
-TClonesArray * AliTPCSensorTemp::ReadTree(TTree *tree, 
+TClonesArray * AliTPCSensorTemp::ReadTree(TTree *tree,
                                           const TString& amandaString) {
-  
+
   Int_t nentries = tree->GetEntries();
   Int_t sensor=0;
   Int_t sector=0;
@@ -221,7 +218,7 @@ TClonesArray * AliTPCSensorTemp::ReadTree(TTree *tree,
     if (bcmp(type,"ROC",3)==0) temp->SetType(0);
     if (bcmp(type,"OFC",3)==0) temp->SetType(1);
     if (bcmp(type,"IFC",3)==0) temp->SetType(2);
-    if (bcmp(type,"TPC",3)==0) temp->SetType(3); 
+    if (bcmp(type,"TPC",3)==0) temp->SetType(3);
     if (bcmp(type,"ELM",3)==0) temp->SetType(4);
     if (bcmp(type,"TS",2)==0)  temp->SetType(5);
     if (bcmp(type,"COOL",3)==0)temp->SetType(6);
@@ -233,7 +230,7 @@ TClonesArray * AliTPCSensorTemp::ReadTree(TTree *tree,
           temp->SetX(kCSideX[sector][num]);
       } else {
           temp->SetX(kASideX[sector][num]);
-      }      
+      }
     }
     if ((temp->GetType()==1) || (temp->GetType()==4)){
       temp->SetX(TMath::Cos((2*sector+1)*0.1745)*278);
@@ -247,14 +244,14 @@ TClonesArray * AliTPCSensorTemp::ReadTree(TTree *tree,
       } else {
         temp->SetX(TMath::Cos((2*sector+1)*0.1745)*241.8);
       }
-    } 
+    }
     if (temp->GetType()==5){
       temp->SetX(TMath::Cos(sector*0.524+(num+1)*0.131)*kTSrad[num]);
     }
     if (temp->GetType()==6){
       temp->SetX(0);
     }
-    
+
     //temp->SetY(y);
     if (temp->GetType()==0){
 //	  temp->SetY(TMath::Sin((2*sector+1)*0.1745)*(83+(num+1)*30));
@@ -262,7 +259,7 @@ TClonesArray * AliTPCSensorTemp::ReadTree(TTree *tree,
           temp->SetY(kCSideY[sector][num]);
       } else {
           temp->SetY(kASideY[sector][num]);
-      }      
+      }
     }
     if ((temp->GetType()==1) || (temp->GetType()==4)){
       temp->SetY(TMath::Sin((2*sector+1)*0.1745)*278);
@@ -276,7 +273,7 @@ TClonesArray * AliTPCSensorTemp::ReadTree(TTree *tree,
       } else {
         temp->SetY(TMath::Sin((2*sector+1)*0.1745)*241.8);
       }
-    } 
+    }
 
     if (temp->GetType()==5){
       temp->SetY(TMath::Sin(sector*0.524+(num+1)*0.131)*kTSrad[num]);
@@ -287,8 +284,8 @@ TClonesArray * AliTPCSensorTemp::ReadTree(TTree *tree,
     }
 
     //temp->SetZ(z);
-    if ((temp->GetType()==0 || 
-         temp->GetType()==4 || temp->GetType()==6) && 
+    if ((temp->GetType()==0 ||
+         temp->GetType()==4 || temp->GetType()==6) &&
 	 temp->GetSide()==0) {
              temp->SetZ(250);
       }
diff --git a/TPC/TPCbase/AliTPCSensorTemp.h b/TPC/TPCbase/AliTPCSensorTemp.h
index ea10cfc5c53..ae1a69b2843 100644
--- a/TPC/TPCbase/AliTPCSensorTemp.h
+++ b/TPC/TPCbase/AliTPCSensorTemp.h
@@ -4,9 +4,8 @@
  * See cxx source for full Copyright notice                               */
 
 
-////////////////////////////////////////////////////////////////////////////
-//              Container class for temperature sensor positions            
-////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCSensorTemp
+/// \brief Container class for temperature sensor positions
 
 
 #include "TMath.h"
@@ -37,7 +36,7 @@ public:
   AliTPCSensorTemp(const AliTPCSensorTemp& source);
   virtual ~AliTPCSensorTemp(){}
   AliTPCSensorTemp& operator=(const AliTPCSensorTemp& source);
-  
+
   Int_t       GetType()   const {return fType;   }
   Int_t       GetSide()   const {return fSide;	 }
   Int_t       GetSector() const {return fSector;	 }
@@ -51,24 +50,26 @@ public:
 
   static TClonesArray * ReadList(const char *fname,
                                  const TString& amandaString = kAmandaStringTPC);
-  static TClonesArray * ReadTree(TTree *tree, 
+  static TClonesArray * ReadTree(TTree *tree,
                                  const TString& amandaString = kAmandaStringTPC);
 
 protected:
-  Int_t fType;      // Position of sensors on fieldcage
+  Int_t fType;      ///< Position of sensors on fieldcage
                     //  (0=ROC,1=OFC,2=IFC,3=TPC,4=ELM,5=TS,6=COOL)
-  Int_t fSide;      // TPC side; 0:Shaft Side (A) -- 1:Muon Side (C)
-  Int_t fSector;    // Number of sector             (0-17)
-  Int_t fNum;       // Position depands from type of sensor.
+  Int_t fSide;      ///< TPC side; 0:Shaft Side (A) -- 1:Muon Side (C)
+  Int_t fSector;    ///< Number of sector             (0-17)
+  Int_t fNum;       ///< Position depands from type of sensor.
                     //    fType=0(0-4) from inside to outside
                     //    fType=1(0-5) fom A side to C side
                     //    fType=2(0-5) fom A side to C side
-                    //    fType=3(0)   one per sector 
+                    //    fType=3(0)   one per sector
                     //    fType=4()
                     //    fType=5()
                     //	fType=6(0-1) 0:input -- 1:output
 
 
+  /// \cond CLASSIMP
   ClassDef(AliTPCSensorTemp,1)
+  /// \endcond
 };
 #endif
diff --git a/TPC/TPCbase/AliTPCSensorTempArray.cxx b/TPC/TPCbase/AliTPCSensorTempArray.cxx
index fc854f3ccae..be711bf8c67 100644
--- a/TPC/TPCbase/AliTPCSensorTempArray.cxx
+++ b/TPC/TPCbase/AliTPCSensorTempArray.cxx
@@ -14,12 +14,10 @@
  **************************************************************************/
 
 
-///////////////////////////////////////////////////////////////////////////////
-//                                                                           //
-//  TPC calibration class for parameters which saved per pad                 //
-//  Authors: Marian Ivanov and Haavard Helstrup                              //
-//                                                                           //
-///////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCSensorTempArray
+/// \brief TPC calibration class for parameters which saved per pad
+///
+/// \author Marian Ivanov and Haavard Helstrup
 
 #include "AliTPCSensorTempArray.h"
 #include "TLinearFitter.h"
@@ -28,7 +26,9 @@
 
 
 
+/// \cond CLASSIMP
 ClassImp(AliTPCSensorTempArray)
+/// \endcond
 
 
 //_____________________________________________________________________________
@@ -37,18 +37,16 @@ AliTPCSensorTempArray::AliTPCSensorTempArray():AliDCSSensorArray()
   //
   // AliTPCSensorTempArray default constructor
   //
- 
+
 }
 //_____________________________________________________________________________
-AliTPCSensorTempArray::AliTPCSensorTempArray(Int_t run) : AliDCSSensorArray() 
+AliTPCSensorTempArray::AliTPCSensorTempArray(Int_t run) : AliDCSSensorArray()
 {
-  //
-  // Read configuration from OCDB
-  //
+  /// Read configuration from OCDB
+
 
-     
   AliCDBEntry *entry =
-            AliCDBManager::Instance()->Get("TPC/Config/Temperature",run); 
+            AliCDBManager::Instance()->Get("TPC/Config/Temperature",run);
   if (entry) {
     TTree *tree = (TTree*) entry->GetObject();
     fSensors = AliTPCSensorTemp::ReadTree(tree);
@@ -60,10 +58,9 @@ AliTPCSensorTempArray::AliTPCSensorTempArray(UInt_t startTime, UInt_t endTime,
                        TTree* confTree, const TString& amandaString)
              :AliDCSSensorArray()
 {
-  //
-  // AliTPCSensorTempArray constructor for Shuttle preprocessor 
-  //  (confTree read from OCDB)
-  //
+  /// AliTPCSensorTempArray constructor for Shuttle preprocessor
+  ///  (confTree read from OCDB)
+
   fSensors = AliTPCSensorTemp::ReadTree(confTree,amandaString);
   fSensors->BypassStreamer(kFALSE);
   fStartTime = TTimeStamp((time_t)startTime,0);
@@ -75,9 +72,8 @@ AliTPCSensorTempArray::AliTPCSensorTempArray(const char *fname,
                                           const TString& amandaString) :
                                                   AliDCSSensorArray()
 {
-  //
-  // AliTPCSensorTempArray constructor
-  //
+  /// AliTPCSensorTempArray constructor
+
   fSensors = AliTPCSensorTemp::ReadList(fname,amandaString);
   fSensors->BypassStreamer(kFALSE);
 }
@@ -87,26 +83,22 @@ AliTPCSensorTempArray::AliTPCSensorTempArray(const char *fname,
 AliTPCSensorTempArray::AliTPCSensorTempArray(const AliTPCSensorTempArray &c):
   AliDCSSensorArray(c)
 {
-  //
-  // AliTPCSensorTempArray copy constructor
-  //
+  /// AliTPCSensorTempArray copy constructor
 
 }
 
 ///_____________________________________________________________________________
 AliTPCSensorTempArray::~AliTPCSensorTempArray()
 {
-  //
-  // AliTPCSensorTempArray destructor
-  //
+  /// AliTPCSensorTempArray destructor
+
 }
 
 //_____________________________________________________________________________
 AliTPCSensorTempArray &AliTPCSensorTempArray::operator=(const AliTPCSensorTempArray &c)
 {
-  //
-  // Assignment operator
-  //
+  /// Assignment operator
+
   if (this != &c) {
      fSensors->Delete();
      new (this) AliTPCSensorTempArray(c);
@@ -119,25 +111,23 @@ AliTPCSensorTempArray &AliTPCSensorTempArray::operator=(const AliTPCSensorTempAr
 //_____________________________________________________________________________
 void AliTPCSensorTempArray::ReadSensors(const char *dbEntry)
 {
-  //
-  // Read list of temperature sensors from text file
-  //
+  /// Read list of temperature sensors from text file
+
   AliCDBEntry *entry = AliCDBManager::Instance()->Get(dbEntry);
   if (!entry) {
      AliWarning(Form("No OCDB entry  %s available\n",dbEntry));
      return;
-  }        
+  }
   TTree *tree = (TTree*) entry->GetObject();
   if (tree) fSensors = AliTPCSensorTemp::ReadTree(tree);
 
-}  
+}
 
 //_____________________________________________________________________________
-AliTPCSensorTemp* AliTPCSensorTempArray::GetSensor(Int_t type, Int_t side, Int_t sector, Int_t num) 
+AliTPCSensorTemp* AliTPCSensorTempArray::GetSensor(Int_t type, Int_t side, Int_t sector, Int_t num)
 {
- //
- //  Return sensor information for sensor specified by type, side, sector and num
- //
+ /// Return sensor information for sensor specified by type, side, sector and num
+
  Int_t nsensors = fSensors->GetEntries();
  for (Int_t isensor=0; isensor<nsensors; isensor++) {
    AliTPCSensorTemp *entry = (AliTPCSensorTemp*)fSensors->At(isensor);
@@ -161,15 +151,13 @@ AliTPCSensorTemp* AliTPCSensorTempArray::GetSensor(Double_t x, Double_t y, Doubl
 //_____________________________________________________________________________
 
 Double_t AliTPCSensorTempArray::GetTempGradientY(UInt_t timeSec, Int_t side){
- //
- // Extract Linear Vertical Temperature Gradient [K/cm] within the TPC on
- // Shaft Side(A): 0
- // Muon  Side(C): 1
- // Values based on TemperatureSensors within the TPC (type: 3(TPC))
- //
- // FIXME: Also return residual-distribution, covariance Matrix
- //        or simply chi2 for validity check?
- //
+ /// Extract Linear Vertical Temperature Gradient [K/cm] within the TPC on
+ /// Shaft Side(A): 0
+ /// Muon  Side(C): 1
+ /// Values based on TemperatureSensors within the TPC (type: 3(TPC))
+ ///
+ /// FIXME: Also return residual-distribution, covariance Matrix
+ ///        or simply chi2 for validity check?
 
  TLinearFitter fitter(3,"x0++x1++x2");
  TVectorD param(3);
diff --git a/TPC/TPCbase/AliTPCSensorTempArray.h b/TPC/TPCbase/AliTPCSensorTempArray.h
index 164d6d9a5ea..fe30ea9fb55 100644
--- a/TPC/TPCbase/AliTPCSensorTempArray.h
+++ b/TPC/TPCbase/AliTPCSensorTempArray.h
@@ -4,11 +4,8 @@
  * See cxx source for full Copyright notice                               */
 
 
-///////////////////////////////////////////////////////////////////////////////
-//                                                                           //
-//  TPC calibration class for temperature sensors                            //
-//                                                                           //
-///////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCSensorTempArray
+/// \brief TPC calibration class for temperature sensors
 
 #include "TSystem.h"
 
@@ -44,7 +41,9 @@ class AliTPCSensorTempArray : public AliDCSSensorArray {
 
  protected:
 
+  /// \cond CLASSIMP
   ClassDef(AliTPCSensorTempArray,1)       //  TPC calibration class for parameters which are saved per pad
+  /// \endcond
 
 };
 
diff --git a/TPC/TPCbase/AliTPCSpaceCharge.cxx b/TPC/TPCbase/AliTPCSpaceCharge.cxx
index ff697e5340f..c49f96206a4 100644
--- a/TPC/TPCbase/AliTPCSpaceCharge.cxx
+++ b/TPC/TPCbase/AliTPCSpaceCharge.cxx
@@ -13,49 +13,30 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-// _________________________________________________________________
-//
-// Begin_Html
-//   <h2> AliTPCSpaceCharge class  </h2>    
-//   The class calculates the space point distortions due to a rotational 
-//   symmetric space charge distribution with the TPC drift volume. 
-//   <p>
-//   The class uses the PoissonRelaxation2D to calculate the resulting 
-//   electrical field inhomogeneities in the (r,z)-plane. Then, the 
-//   Langevin-integral formalism is used to calculate the space point distortions. 
-//   <p>
-//   The class assumes, that the distortions scales linearly with the magnitude 
-//   of the space charge distribution $\rho(r,z)$. The in here assumed distribution is 
-//   $$\rho(r,z) = \frac{(A-B\,z)}{r^2} $$ wherein the factors A and B scale with the
-//   event multiplicity and the interaction rate.
-//   <p>
-//   The scaling factor can be set via the function SetCorrectionFactor. An example of 
-//   the shape of the distortions is given below.
-//
-//   MI modification - 22.05.2013
-//   As an optional input the Space charge histogram RZ is used in case it is provided 
-//     - using the SetInputSpaceCharge function
-//
-// End_Html
-//
-// Begin_Macro(source)
-//   {
-//   gROOT->SetStyle("Plain"); gStyle->SetPalette(1);
-//   TCanvas *c2 = new TCanvas("cAliTPCSpaceCharge","cAliTPCSpaceCharge",500,300); 
-//   AliTPCSpaceCharge sc;
-//   sc.SetOmegaTauT1T2(-0.32,1,1); // B=0.5 Tesla
-//   sc.SetCorrectionFactor(0.0015);
-//   sc.CreateHistoDRinZR(0.)->Draw("surf2");
-//   return c2;
-//   } 
-// End_Macro
-//
-// Begin_Html
-//   <p>
-//   Date: 23/08/2010 <br>
-// Authors: Jim Thomas, Stefan Rossegger 
-// End_Html 
-// _________________________________________________________________
+/// \class AliTPCSpaceCharge
+/// \brief The class calculates the space point distortions due to a rotational
+///
+/// symmetric space charge distribution with the TPC drift volume.
+///
+/// The class uses the PoissonRelaxation2D to calculate the resulting
+/// electrical field inhomogeneities in the (r,z)-plane. Then, the
+/// Langevin-integral formalism is used to calculate the space point distortions.
+///
+/// The class assumes, that the distortions scales linearly with the magnitude
+/// of the space charge distribution $\rho(r,z)$. The in here assumed distribution is
+/// $$\rho(r,z) = \frac{(A-B\,z)}{r^2} $$ wherein the factors A and B scale with the
+/// event multiplicity and the interaction rate.
+///
+/// The scaling factor can be set via the function SetCorrectionFactor. An example of
+/// the shape of the distortions is given below.
+///
+/// MI modification - 22.05.2013
+/// As an optional input the Space charge histogram RZ is used in case it is provided
+///  - using the SetInputSpaceCharge function
+/// ![Picture from ROOT macro](AliTPCSpaceCharge_cxx_82e9c78.png)
+///
+/// \author Jim Thomas, Stefan Rossegger
+/// \date 23/08/2010
 
 
 
@@ -71,7 +52,9 @@
 #include "AliTPCROC.h"
 #include "AliTPCSpaceCharge.h"
 
+/// \cond CLASSIMP
 ClassImp(AliTPCSpaceCharge)
+/// \endcond
 
 AliTPCSpaceCharge::AliTPCSpaceCharge()
   : AliTPCCorrection("SpaceCharge2D","Space Charge 2D"),
@@ -81,22 +64,19 @@ AliTPCSpaceCharge::AliTPCSpaceCharge()
   //
   // default constructor
   //
- 
+
 }
 
 AliTPCSpaceCharge::~AliTPCSpaceCharge() {
-  //
-  // default destructor
-  //
+  /// default destructor
+
 }
 
 
 
 void AliTPCSpaceCharge::Init() {
-  //
-  // Initialization funtion
-  //
-  
+  /// Initialization funtion
+
   AliMagF* magF= (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
   if (!magF) AliError("Magneticd field - not initialized");
   Double_t bzField = magF->SolenoidField()/10.; //field in T
@@ -104,7 +84,7 @@ void AliTPCSpaceCharge::Init() {
   if (!param) AliError("Parameters - not initialized");
   Double_t vdrift = param->GetDriftV()/1000000.; // [cm/us]   // From dataBase: to be updated: per second (ideally)
   Double_t ezField = 400; // [V/cm]   // to be updated: never (hopefully)
-  Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ; 
+  Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ;
   // Correction Terms for effective omegaTau; obtained by a laser calibration run
   SetOmegaTauT1T2(wt,fT1,fT2);
 
@@ -112,9 +92,8 @@ void AliTPCSpaceCharge::Init() {
 }
 
 void AliTPCSpaceCharge::Update(const TTimeStamp &/*timeStamp*/) {
-  //
-  // Update function 
-  //
+  /// Update function
+
   AliMagF* magF= (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
   if (!magF) AliError("Magneticd field - not initialized");
   Double_t bzField = magF->SolenoidField()/10.; //field in T
@@ -122,7 +101,7 @@ void AliTPCSpaceCharge::Update(const TTimeStamp &/*timeStamp*/) {
   if (!param) AliError("Parameters - not initialized");
   Double_t vdrift = param->GetDriftV()/1000000.; // [cm/us]  // From dataBase: to be updated: per second (ideally)
   Double_t ezField = 400; // [V/cm]   // to be updated: never (hopefully)
-  Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ; 
+  Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ;
   // Correction Terms for effective omegaTau; obtained by a laser calibration run
   SetOmegaTauT1T2(wt,fT1,fT2);
 
@@ -133,16 +112,14 @@ void AliTPCSpaceCharge::Update(const TTimeStamp &/*timeStamp*/) {
 
 
 void AliTPCSpaceCharge::GetCorrection(const Float_t x[],const Short_t roc,Float_t dx[]) {
-  //
-  // Calculates the correction due the Space Charge effect within the TPC drift volume
-  //   
+  /// Calculates the correction due the Space Charge effect within the TPC drift volume
 
   if (!fInitLookUp) {
     AliInfo("Lookup table was not initialized! Perform the inizialisation now ...");
     InitSpaceChargeDistortion();
   }
-  Int_t   order     = 1 ;    // FIXME: hardcoded? Linear interpolation = 1, Quadratic = 2         
-                        
+  Int_t   order     = 1 ;    // FIXME: hardcoded? Linear interpolation = 1, Quadratic = 2
+
   Double_t intEr, intEphi, intdEz;
   Double_t r, phi, z ;
   Int_t    sign;
@@ -157,42 +134,40 @@ void AliTPCSpaceCharge::GetCorrection(const Float_t x[],const Short_t roc,Float_
   } else {
     sign = -1;       // (TPC C side)
   }
-  
+
   if ( sign==1  && z <  fgkZOffSet ) z =  fgkZOffSet;    // Protect against discontinuity at CE
   if ( sign==-1 && z > -fgkZOffSet ) z = -fgkZOffSet;    // Protect against discontinuity at CE
-  
+
 
   if ( (sign==1 && z<0) || (sign==-1 && z>0) ) // just a consistency check
     AliError("ROC number does not correspond to z coordinate! Calculation of distortions is most likely wrong!");
 
   // Efield is symmetric in phi - 2D calculation
-  intEphi = 0.0; 
+  intEphi = 0.0;
   // Get the E field integrals
   Interpolate2DEdistortion( order, r, z, fLookUpErOverEz, intEr );
   // Get DeltaEz field integral
   Interpolate2DEdistortion( order, r, z, fLookUpDeltaEz, intdEz );
-  
- 
+
+
   // Calculate distorted position
   if ( r > 0.0 ) {
-    phi =  phi + fCorrectionFactor *( fC0*intEphi - fC1*intEr ) / r;      
-    r   =  r   + fCorrectionFactor *( fC0*intEr   + fC1*intEphi );  
+    phi =  phi + fCorrectionFactor *( fC0*intEphi - fC1*intEr ) / r;
+    r   =  r   + fCorrectionFactor *( fC0*intEr   + fC1*intEphi );
   }
   Double_t dz = intdEz*fCorrectionFactor;
- 
+
   // Calculate correction in cartesian coordinates
   dx[0] = - (r * TMath::Cos(phi) - x[0]);
-  dx[1] = - (r * TMath::Sin(phi) - x[1]); 
-  dx[2] = - dz;  // z distortion - (internally scaled with driftvelocity dependency 
-                 // on the Ez field 
+  dx[1] = - (r * TMath::Sin(phi) - x[1]);
+  dx[2] = - dz;  // z distortion - (internally scaled with driftvelocity dependency
+                 // on the Ez field
 
 }
 
 void AliTPCSpaceCharge::InitSpaceChargeDistortion() {
-  //
-  // Initialization of the Lookup table which contains the solutions of the 
-  // poisson problem
-  //
+  /// Initialization of the Lookup table which contains the solutions of the
+  /// poisson problem
 
   const Float_t  gridSizeR   =  (fgkOFCRadius-fgkIFCRadius) / (kRows-1) ;
   const Float_t  gridSizeZ   =  fgkTPCZ0 / (kColumns-1) ;
@@ -203,8 +178,8 @@ void AliTPCSpaceCharge::InitSpaceChargeDistortion() {
   TMatrixD arrayDeltaEz(kRows,kColumns);    // solution in Ez
 
   Double_t  rList[kRows], zedList[kColumns] ;
-  
-  // Fill arrays with initial conditions.  V on the boundary and ChargeDensity in the volume.      
+
+  // Fill arrays with initial conditions.  V on the boundary and ChargeDensity in the volume.
   for ( Int_t j = 0 ; j < kColumns ; j++ ) {
     Double_t zed = j*gridSizeZ ;
     zedList[j] = zed ;
@@ -214,26 +189,26 @@ void AliTPCSpaceCharge::InitSpaceChargeDistortion() {
       voltArray(i,j)        = 0;  // Initialize voltArray to zero - not used in this class
       chargeDensity(i,j)     = 0;  // Initialize ChargeDensity to zero
     }
-  }      
+  }
 
   // Fill the initial conditions
   for ( Int_t j = 1 ; j < kColumns-1 ; j++ ) {
     Double_t zed = j*gridSizeZ ;
-    for ( Int_t i = 1 ; i < kRows-1 ; i++ ) { 
+    for ( Int_t i = 1 ; i < kRows-1 ; i++ ) {
       Double_t radius = fgkIFCRadius + i*gridSizeR ;
 
       Double_t zterm = (fgkTPCZ0-zed) * (fgkOFCRadius*fgkOFCRadius - fgkIFCRadius*fgkIFCRadius) / fgkTPCZ0 ;
       // for 1/R**2 charge density in the TPC; then integrated in Z due to drifting ions
-      chargeDensity(i,j) = zterm / ( TMath::Log(fgkOFCRadius/fgkIFCRadius) * ( radius*radius ) ) ;              
+      chargeDensity(i,j) = zterm / ( TMath::Log(fgkOFCRadius/fgkIFCRadius) * ( radius*radius ) ) ;
     }
   }
   // Fill the initial space charge in case histogram exist
   if (fSpaceChargeHistogram){
     for ( Int_t j = 1 ; j < kColumns-1 ; j++ ) {
       Double_t zed = j*gridSizeZ ;
-      for ( Int_t i = 1 ; i < kRows-1 ; i++ ) { 
+      for ( Int_t i = 1 ; i < kRows-1 ; i++ ) {
 	Double_t radius = fgkIFCRadius + i*gridSizeR ;
-	
+
 	Double_t zterm = (fgkTPCZ0-zed) * (fgkOFCRadius*fgkOFCRadius - fgkIFCRadius*fgkIFCRadius) / fgkTPCZ0 ;
 	// for 1/R**2 charge density in the TPC; then integrated in Z due to drifting ions
 	chargeDensity(i,j) = fSpaceChargeHistogram->Interpolate(radius,zed);
@@ -242,14 +217,14 @@ void AliTPCSpaceCharge::InitSpaceChargeDistortion() {
   }
 
 
-  // Solve the electrosatic problem in 2D 
+  // Solve the electrosatic problem in 2D
 
   PoissonRelaxation2D( voltArray, chargeDensity, arrayErOverEz, arrayDeltaEz, kRows, kColumns, kIterations ) ;
-  
+
   //Interpolate results onto standard grid for Electric Fields
   Int_t ilow=0, jlow=0 ;
   Double_t z,r;
-  Float_t saveEr[2], saveEz[2] ;	      
+  Float_t saveEr[2], saveEz[2] ;
   for ( Int_t i = 0 ; i < kNZ ; ++i )  {
     z = TMath::Abs( fgkZList[i] ) ; // assume symmetric behaviour on A and C side
     for ( Int_t j = 0 ; j < kNR ; ++j ) {
@@ -259,36 +234,34 @@ void AliTPCSpaceCharge::InitSpaceChargeDistortion() {
       Search( kRows,   rList, r, ilow ) ;          // Note switch - R in rows and Z in columns
       Search( kColumns, zedList, z, jlow ) ;
       if ( ilow < 0 ) ilow = 0 ;                   // check if out of range
-      if ( jlow < 0 ) jlow = 0 ;   
-      if ( ilow + 1  >=  kRows - 1 ) ilow =  kRows - 2 ;	      
-      if ( jlow + 1  >=  kColumns - 1 ) jlow =  kColumns - 2 ; 
-    
-      saveEr[0] = arrayErOverEz(ilow,jlow) + 
+      if ( jlow < 0 ) jlow = 0 ;
+      if ( ilow + 1  >=  kRows - 1 ) ilow =  kRows - 2 ;
+      if ( jlow + 1  >=  kColumns - 1 ) jlow =  kColumns - 2 ;
+
+      saveEr[0] = arrayErOverEz(ilow,jlow) +
 	(arrayErOverEz(ilow,jlow+1)-arrayErOverEz(ilow,jlow))*(z-zedList[jlow])/gridSizeZ ;
-      saveEr[1] = arrayErOverEz(ilow+1,jlow) + 
+      saveEr[1] = arrayErOverEz(ilow+1,jlow) +
 	(arrayErOverEz(ilow+1,jlow+1)-arrayErOverEz(ilow+1,jlow))*(z-zedList[jlow])/gridSizeZ ;
-      saveEz[0] = arrayDeltaEz(ilow,jlow) + 
+      saveEz[0] = arrayDeltaEz(ilow,jlow) +
 	(arrayDeltaEz(ilow,jlow+1)-arrayDeltaEz(ilow,jlow))*(z-zedList[jlow])/gridSizeZ ;
-      saveEz[1] = arrayDeltaEz(ilow+1,jlow) + 
+      saveEz[1] = arrayDeltaEz(ilow+1,jlow) +
 	(arrayDeltaEz(ilow+1,jlow+1)-arrayDeltaEz(ilow+1,jlow))*(z-zedList[jlow])/gridSizeZ ;
 
-      
+
       fLookUpErOverEz[i][j] = saveEr[0] + (saveEr[1]-saveEr[0])*(r-rList[ilow])/gridSizeR ;
       fLookUpDeltaEz[i][j]  = saveEz[0] + (saveEz[1]-saveEz[0])*(r-rList[ilow])/gridSizeR ;
 
       if (fgkZList[i]<0)  fLookUpDeltaEz[i][j] *= -1; // C side is negative z
     }
   }
-  
+
   fInitLookUp = kTRUE;
 
 }
 
 void AliTPCSpaceCharge::Print(const Option_t* option) const {
-  //
-  // Print function to check the settings of the boundary vectors
-  // option=="a" prints the C0 and C1 coefficents for calibration purposes
-  //
+  /// Print function to check the settings of the boundary vectors
+  /// option=="a" prints the C0 and C1 coefficents for calibration purposes
 
   TString opt = option; opt.ToLower();
   printf("%s\n",GetTitle());
@@ -298,8 +271,8 @@ void AliTPCSpaceCharge::Print(const Option_t* option) const {
   if (opt.Contains("a")) { // Print all details
     printf(" - T1: %1.4f, T2: %1.4f \n",fT1,fT2);
     printf(" - C1: %1.4f, C0: %1.4f \n",fC1,fC0);
-  } 
-   
+  }
+
   if (!fInitLookUp) AliError("Lookup table was not initialized! You should do InitSpaceChargeDistortion() ...");
 
 }
diff --git a/TPC/TPCbase/AliTPCSpaceCharge.h b/TPC/TPCbase/AliTPCSpaceCharge.h
index 6426263e640..ecc8062d4c6 100644
--- a/TPC/TPCbase/AliTPCSpaceCharge.h
+++ b/TPC/TPCbase/AliTPCSpaceCharge.h
@@ -4,15 +4,13 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-////////////////////////////////////////////////////////////////////////////
-// AliTPCSpaceCharge class                                                //
-// Authors: Jim Thomas, Stefan Rossegger                                  //
-////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCSpaceCharge
+/// \brief \author Jim Thomas, Stefan Rossegger
 
 #include "AliTPCCorrection.h"
 
 
-class TH2; 
+class TH2;
 
 class AliTPCSpaceCharge : public AliTPCCorrection {
 public:
@@ -23,7 +21,7 @@ public:
   virtual void Init();
   virtual void Update(const TTimeStamp &timeStamp);
   void    SetInputSpaceCharge(TH2 * hisSpaceCharge){fSpaceChargeHistogram = hisSpaceCharge;}  // MI add
-  const TH2 *   GetInputSpaceCharge(){return fSpaceChargeHistogram;}       // MI add 
+  const TH2 *   GetInputSpaceCharge(){return fSpaceChargeHistogram;}       // MI add
 
 
   // common setters and getters for tangled ExB effect
@@ -48,23 +46,25 @@ protected:
   virtual void GetCorrection(const Float_t x[],const Short_t roc,Float_t dx[]);
 
 private:
-  Float_t fC0; // coefficient C0                 (compare Jim Thomas's notes for definitions)
-  Float_t fC1; // coefficient C1                 (compare Jim Thomas's notes for definitions)
-  Float_t fCorrectionFactor;       // Space Charge Correction factor in comparison to initialized
+  Float_t fC0; ///< coefficient C0                 (compare Jim Thomas's notes for definitions)
+  Float_t fC1; ///< coefficient C1                 (compare Jim Thomas's notes for definitions)
+  Float_t fCorrectionFactor;       ///< Space Charge Correction factor in comparison to initialized
                                    // look up table which was created for M_mb = 900 and IR = 3000
                                    // compare Internal Note Nr: ???
 
-  TH2 *    fSpaceChargeHistogram;      // Histogram with the input space charge histogram - used as an optional input 
-  Bool_t fInitLookUp;                  // flag to check it the Look Up table was created
+  TH2 *    fSpaceChargeHistogram;      ///< Histogram with the input space charge histogram - used as an optional input
+  Bool_t fInitLookUp;                  ///< flag to check it the Look Up table was created
 
-  Double_t fLookUpErOverEz[kNZ][kNR];  // Array to store electric field integral (int Er/Ez)
-  Double_t fLookUpDeltaEz[kNZ][kNR];   // Array to store electric field integral (int Delta Ez)
+  Double_t fLookUpErOverEz[kNZ][kNR];  ///< Array to store electric field integral (int Er/Ez)
+  Double_t fLookUpDeltaEz[kNZ][kNR];   ///< Array to store electric field integral (int Delta Ez)
   // basic numbers for the poisson relaxation //can be set individually in each class
   enum {kRows   =257}; // grid size in r direction used in the poisson relaxation // ( 2**n + 1 ) eg. 65, 129, 257 etc.
   enum {kColumns=129}; // grid size in z direction used in the poisson relaxation // ( 2**m + 1 ) eg. 65, 129, 257 etc.
-  enum {kIterations=100}; // Number of iterations within the poisson relaxation 
+  enum {kIterations=100}; // Number of iterations within the poisson relaxation
 
-  ClassDef(AliTPCSpaceCharge,0); 
+  /// \cond CLASSIMP
+  ClassDef(AliTPCSpaceCharge,0);
+  /// \endcond
 };
 
 #endif
diff --git a/TPC/TPCbase/AliTPCSpaceCharge3D.cxx b/TPC/TPCbase/AliTPCSpaceCharge3D.cxx
index 4b21bd2e9f1..58d4b4de921 100644
--- a/TPC/TPCbase/AliTPCSpaceCharge3D.cxx
+++ b/TPC/TPCbase/AliTPCSpaceCharge3D.cxx
@@ -13,40 +13,34 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-// _________________________________________________________________
-//
-// Begin_Html
-//   <h2>  AliTPCSpaceCharge3D class   </h2>    
-//   The class calculates the space point distortions due to an arbitrary space
-//   charge distribution in 3D. 
-//   <p>
-//   The method of calculation is based on the analytical solution for the Poisson 
-//   problem in 3D (cylindrical coordinates). The solution is used in form of 
-//   look up tables, where the pre calculated solutions for different voxel 
-//   positions are stored. These voxel solutions can be summed up according 
-//   to the weight of the position of the applied space charge distribution.
-//   Further details can be found in \cite[chap.5]{PhD-thesis_S.Rossegger}.
-//   <p>
-//   The class also allows a simple scaling of the resulting distortions
-//   via the function SetCorrectionFactor. This speeds up the calculation 
-//   time under the assumption, that the distortions scales linearly with the 
-//   magnitude of the space charge distribution $\rho(r,z)$ and the shape stays 
-//   the same at higher luminosities.
-//   <p>
-//   In contrast to the implementation in 2D (see the class AliTPCSpaceChargeabove), 
-//   the input charge distribution can be of arbitrary character. An example on how 
-//   to produce a corresponding charge distribution can be found in the function 
-//   WriteChargeDistributionToFile. In there, a $\rho(r,z) = (A-B\,z)/r^2$, 
-//   with slightly different magnitude on the A and C side (due to the muon absorber),
-//   is superpositioned with a few leaking wires at arbitrary positions. 
-//
-//
-//   Marian Ivanov change: 26.06.2013
-//   Usage of the realy 3D space charge map as an optional input
-//   SetInputSpaceCharge map.
-//   In case given map is used 2 2D maps are ignored and  scaling functions  $\rho(r,z) = (A-B\,z)/r^2$, 
-//   will not work
-//
+/// \class AliTPCSpaceCharge3D
+/// \brief The class calculates the space point distortions due to an arbitrary space charge distribution in 3D.
+///
+/// The method of calculation is based on the analytical solution for the Poisson
+/// problem in 3D (cylindrical coordinates). The solution is used in form of
+/// look up tables, where the pre calculated solutions for different voxel
+/// positions are stored. These voxel solutions can be summed up according
+/// to the weight of the position of the applied space charge distribution.
+/// Further details can be found in \cite[chap.5]{PhD-thesis_S.Rossegger}.
+///
+/// The class also allows a simple scaling of the resulting distortions
+/// via the function SetCorrectionFactor. This speeds up the calculation
+/// time under the assumption, that the distortions scales linearly with the
+/// magnitude of the space charge distribution $\rho(r,z)$ and the shape stays
+/// the same at higher luminosities.
+///
+/// In contrast to the implementation in 2D (see the class AliTPCSpaceChargeabove),
+/// the input charge distribution can be of arbitrary character. An example on how
+/// to produce a corresponding charge distribution can be found in the function
+/// WriteChargeDistributionToFile. In there, a $\rho(r,z) = (A-B\,z)/r^2$,
+/// with slightly different magnitude on the A and C side (due to the muon absorber),
+/// is superpositioned with a few leaking wires at arbitrary positions.
+///
+/// Marian Ivanov change: 26.06.2013
+/// Usage of the realy 3D space charge map as an optional input
+/// SetInputSpaceCharge map.
+/// In case given map is used 2 2D maps are ignored and  scaling functions  $\rho(r,z) = (A-B\,z)/r^2$,
+/// will not work
 
 
 // End_Html
@@ -54,7 +48,7 @@
 // Begin_Macro(source)
 //   {
 //   gROOT->SetStyle("Plain"); gStyle->SetPalette(1);
-//   TCanvas *c2 = new TCanvas("cAliTPCSpaceCharge3D","cAliTPCSpaceCharge3D",500,400); 
+//   TCanvas *c2 = new TCanvas("cAliTPCSpaceCharge3D","cAliTPCSpaceCharge3D",500,400);
 //   AliTPCSpaceCharge3D sc;
 //   sc.WriteChargeDistributionToFile("SC_zr2_GGleaks.root");
 //   sc.SetSCDataFileName("SC_zr2_GGleaks.root");
@@ -62,14 +56,14 @@
 //   sc.InitSpaceCharge3DDistortion();
 //   sc.CreateHistoDRinXY(15,300,300)->Draw("colz");
 //   return c2;
-//   } 
+//   }
 // End_Macro
 //
 // Begin_Html
 //   <p>
-//   Date: 19/06/2010  <br>                                                       
-//   Authors: Stefan Rossegger                                                
-// End_Html 
+//   Date: 19/06/2010  <br>
+//   Authors: Stefan Rossegger
+// End_Html
 // _________________________________________________________________
 
 
@@ -90,7 +84,9 @@
 #include "AliTPCSpaceCharge3D.h"
 #include "AliSysInfo.h"
 
+/// \cond CLASSIMP
 ClassImp(AliTPCSpaceCharge3D)
+/// \endcond
 
 AliTPCSpaceCharge3D::AliTPCSpaceCharge3D()
   : AliTPCCorrection("SpaceCharge3D","Space Charge - 3D"),
@@ -102,7 +98,7 @@ AliTPCSpaceCharge3D::AliTPCSpaceCharge3D()
     fSCLookUpPOCsFileNameRZ(""),
     fSCLookUpPOCsFileNameRPhi(""),
     fSCdensityInRZ(0),
-    fSCdensityInRPhiA(0), 
+    fSCdensityInRPhiA(0),
     fSCdensityInRPhiC(0),
     fSpaceChargeHistogram3D(0),
     fSpaceChargeHistogramRPhi(0),
@@ -115,9 +111,9 @@ AliTPCSpaceCharge3D::AliTPCSpaceCharge3D()
   // Array which will contain the solution according to the setted charge density distribution
   // see InitSpaceCharge3DDistortion() function
   for ( Int_t k = 0 ; k < kNPhi ; k++ ) {
-    fLookUpErOverEz[k]   =  new TMatrixF(kNR,kNZ);  
+    fLookUpErOverEz[k]   =  new TMatrixF(kNR,kNZ);
     fLookUpEphiOverEz[k] =  new TMatrixF(kNR,kNZ);
-    fLookUpDeltaEz[k]    =  new TMatrixF(kNR,kNZ); 
+    fLookUpDeltaEz[k]    =  new TMatrixF(kNR,kNZ);
     fSCdensityDistribution[k] = new TMatrixF(kNR,kNZ);
   }
   fSCdensityInRZ   = new TMatrixD(kNR,kNZ);
@@ -130,7 +126,7 @@ AliTPCSpaceCharge3D::AliTPCSpaceCharge3D()
   fSCLookUpPOCsFileNameRZ="$(ALICE_ROOT)/TPC/Calib/maps/sc_radSym_35-01-51_34p-01p-50p_MN60.root";
   fSCLookUpPOCsFileNameRPhi="$(ALICE_ROOT)/TPC/Calib/maps/sc_cChInZ_35-144-26_34p-18p-01p-MN30.root";
   //  fSCLookUpPOCsFileNameRPhi="$(ALICE_ROOT)/TPC/Calib/maps/sc_cChInZ_35-36-26_34p-18p-01p-MN40.root";
- 
+
 
 
   // standard location of the space charge distibution ... can be changes
@@ -142,10 +138,8 @@ AliTPCSpaceCharge3D::AliTPCSpaceCharge3D()
 }
 
 AliTPCSpaceCharge3D::~AliTPCSpaceCharge3D() {
-  //
-  // default destructor
-  //
- 
+  /// default destructor
+
   for ( Int_t k = 0 ; k < kNPhi ; k++ ) {
     delete fLookUpErOverEz[k];
     delete fLookUpEphiOverEz[k];
@@ -162,10 +156,8 @@ AliTPCSpaceCharge3D::~AliTPCSpaceCharge3D() {
 
 
 void AliTPCSpaceCharge3D::Init() {
-  //
-  // Initialization funtion
-  //
-  
+  /// Initialization funtion
+
   AliMagF* magF= (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
   if (!magF) AliError("Magneticd field - not initialized");
   Double_t bzField = magF->SolenoidField()/10.; //field in T
@@ -173,7 +165,7 @@ void AliTPCSpaceCharge3D::Init() {
   if (!param) AliError("Parameters - not initialized");
   Double_t vdrift = param->GetDriftV()/1000000.; // [cm/us]   // From dataBase: to be updated: per second (ideally)
   Double_t ezField = 400; // [V/cm]   // to be updated: never (hopefully)
-  Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ; 
+  Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ;
   // Correction Terms for effective omegaTau; obtained by a laser calibration run
   SetOmegaTauT1T2(wt,fT1,fT2);
 
@@ -181,9 +173,8 @@ void AliTPCSpaceCharge3D::Init() {
 }
 
 void AliTPCSpaceCharge3D::Update(const TTimeStamp &/*timeStamp*/) {
-  //
-  // Update function 
-  //
+  /// Update function
+
   AliMagF* magF= (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
   if (!magF) AliError("Magneticd field - not initialized");
   Double_t bzField = magF->SolenoidField()/10.; //field in T
@@ -191,7 +182,7 @@ void AliTPCSpaceCharge3D::Update(const TTimeStamp &/*timeStamp*/) {
   if (!param) AliError("Parameters - not initialized");
   Double_t vdrift = param->GetDriftV()/1000000.; // [cm/us]  // From dataBase: to be updated: per second (ideally)
   Double_t ezField = 400; // [V/cm]   // to be updated: never (hopefully)
-  Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ; 
+  Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ;
   // Correction Terms for effective omegaTau; obtained by a laser calibration run
   SetOmegaTauT1T2(wt,fT1,fT2);
 
@@ -201,17 +192,15 @@ void AliTPCSpaceCharge3D::Update(const TTimeStamp &/*timeStamp*/) {
 
 
 void AliTPCSpaceCharge3D::GetCorrection(const Float_t x[],const Short_t roc,Float_t dx[]) {
-  //
-  // Calculates the correction due the Space Charge effect within the TPC drift volume
-  //   
+  /// Calculates the correction due the Space Charge effect within the TPC drift volume
 
   if (!fInitLookUp) {
     AliInfo("Lookup table was not initialized! Performing the inizialisation now ...");
     InitSpaceCharge3DDistortion();
   }
 
-  Int_t   order     = 1 ;    // FIXME: hardcoded? Linear interpolation = 1, Quadratic = 2         
-                        
+  Int_t   order     = 1 ;    // FIXME: hardcoded? Linear interpolation = 1, Quadratic = 2
+
   Float_t intEr, intEphi, intdEz ;
   Double_t r, phi, z ;
   Int_t    sign;
@@ -226,71 +215,70 @@ void AliTPCSpaceCharge3D::GetCorrection(const Float_t x[],const Short_t roc,Floa
   } else {
     sign = -1;       // (TPC C side)
   }
-  
+
   if ( sign==1  && z <  fgkZOffSet ) z =  fgkZOffSet;    // Protect against discontinuity at CE
   if ( sign==-1 && z > -fgkZOffSet ) z = -fgkZOffSet;    // Protect against discontinuity at CE
-  
+
 
   if ( (sign==1 && z<0) || (sign==-1 && z>0) ) // just a consistency check
     AliError("ROC number does not correspond to z coordinate! Calculation of distortions is most likely wrong!");
 
-  // Get the Er and Ephi field integrals plus the integral over DeltaEz 
-  intEr      = Interpolate3DTable(order, r, z, phi, kNR, kNZ, kNPhi, 
+  // Get the Er and Ephi field integrals plus the integral over DeltaEz
+  intEr      = Interpolate3DTable(order, r, z, phi, kNR, kNZ, kNPhi,
 				  fgkRList, fgkZList, fgkPhiList, fLookUpErOverEz  );
-  intEphi    = Interpolate3DTable(order, r, z, phi, kNR, kNZ, kNPhi, 
+  intEphi    = Interpolate3DTable(order, r, z, phi, kNR, kNZ, kNPhi,
 				  fgkRList, fgkZList, fgkPhiList, fLookUpEphiOverEz);
-  intdEz = Interpolate3DTable(order, r, z, phi, kNR, kNZ, kNPhi, 
+  intdEz = Interpolate3DTable(order, r, z, phi, kNR, kNZ, kNPhi,
 				  fgkRList, fgkZList, fgkPhiList, fLookUpDeltaEz   );
 
   // Calculate distorted position
   if ( r > 0.0 ) {
-    phi =  phi + fCorrectionFactor *( fC0*intEphi - fC1*intEr ) / r;      
-    r   =  r   + fCorrectionFactor *( fC0*intEr   + fC1*intEphi );  
+    phi =  phi + fCorrectionFactor *( fC0*intEphi - fC1*intEr ) / r;
+    r   =  r   + fCorrectionFactor *( fC0*intEr   + fC1*intEphi );
   }
   Double_t dz = intdEz * fCorrectionFactor * fgkdvdE;
- 
+
   // Calculate correction in cartesian coordinates
   dx[0] = - (r * TMath::Cos(phi) - x[0]);
-  dx[1] = - (r * TMath::Sin(phi) - x[1]); 
+  dx[1] = - (r * TMath::Sin(phi) - x[1]);
   dx[2] = - dz;  // z distortion - (scaled with driftvelocity dependency on the Ez field and the overall scaling factor)
 
 }
 
 void AliTPCSpaceCharge3D::InitSpaceCharge3DDistortion() {
- //
-  // Initialization of the Lookup table which contains the solutions of the 
-  // "space charge" (poisson) problem - Faster and more accureate
-  //
-  // Method: Weighted sum-up of the different fields within the look up table 
-  // but using two lookup tables with higher granularity in the (r,z) and the (rphi)- plane to emulate
-  // more realistic space charges. (r,z) from primary ionisation. (rphi) for possible Gating leaks
+ /// Initialization of the Lookup table which contains the solutions of the
+ /// "space charge" (poisson) problem - Faster and more accureate
+ ///
+ /// Method: Weighted sum-up of the different fields within the look up table
+ /// but using two lookup tables with higher granularity in the (r,z) and the (rphi)- plane to emulate
+ /// more realistic space charges. (r,z) from primary ionisation. (rphi) for possible Gating leaks
 
   if (fInitLookUp) {
     AliInfo("Lookup table was already initialized!  Doing it again anyway ...");
     return;
   }
-  
+
   // ------------------------------------------------------------------------------------------------------
   // step 1: lookup table in rz, fine grid, radial symetric, to emulate primary ionization
 
   AliInfo("Step 1: Preparation of the weighted look-up tables.");
-   
+
   // lookup table in rz, fine grid
 
   TFile *fZR = new TFile(fSCLookUpPOCsFileNameRZ.Data(),"READ");
   if ( !fZR ) {
     AliError("Precalculated POC-looup-table in ZR could not be found");
     return;
-  } 
+  }
 
   // units are in [m]
-  TVector *gridf1  = (TVector*) fZR->Get("constants"); 
+  TVector *gridf1  = (TVector*) fZR->Get("constants");
   TVector &grid1 = *gridf1;
   TMatrix *coordf1  = (TMatrix*) fZR->Get("coordinates");
   TMatrix &coord1 = *coordf1;
   TMatrix *coordPOCf1  = (TMatrix*) fZR->Get("POCcoord");
   TMatrix &coordPOC1 = *coordPOCf1;
-  
+
   Int_t rows      = (Int_t)grid1(0);   // number of points in r direction  - from RZ or RPhi table
   Int_t phiSlices = (Int_t)grid1(1);   // number of points in phi          - from RPhi table
   Int_t columns   = (Int_t)grid1(2);   // number of points in z direction  - from RZ table
@@ -299,16 +287,16 @@ void AliTPCSpaceCharge3D::InitSpaceCharge3DDistortion() {
   Float_t gridSizeZ   =  fgkTPCZ0/(columns-1);                  // unit in [cm]
 
   // temporary matrices needed for the calculation // for rotational symmetric RZ table, phislices is 1
-  
-  TMatrixD *arrayofErA[kNPhiSlices], *arrayofdEzA[kNPhiSlices]; 
-  TMatrixD *arrayofErC[kNPhiSlices], *arrayofdEzC[kNPhiSlices]; 
+
+  TMatrixD *arrayofErA[kNPhiSlices], *arrayofdEzA[kNPhiSlices];
+  TMatrixD *arrayofErC[kNPhiSlices], *arrayofdEzC[kNPhiSlices];
 
   TMatrixD *arrayofEroverEzA[kNPhiSlices], *arrayofDeltaEzA[kNPhiSlices];
   TMatrixD *arrayofEroverEzC[kNPhiSlices], *arrayofDeltaEzC[kNPhiSlices];
 
- 
+
   for ( Int_t k = 0 ; k < phiSlices ; k++ ) {
-   
+
     arrayofErA[k]   =   new TMatrixD(rows,columns) ;
     arrayofdEzA[k]  =   new TMatrixD(rows,columns) ;
     arrayofErC[k]   =   new TMatrixD(rows,columns) ;
@@ -319,36 +307,36 @@ void AliTPCSpaceCharge3D::InitSpaceCharge3DDistortion() {
     arrayofEroverEzC[k]   =   new TMatrixD(rows,columns) ;
     arrayofDeltaEzC[k]    =   new TMatrixD(rows,columns) ;
 
-    // zero initialization not necessary, it is done in the constructor of TMatrix 
+    // zero initialization not necessary, it is done in the constructor of TMatrix
 
   }
- 
+
   // list of points as used during sum up
   Double_t  rlist1[kNRows], zedlist1[kNColumns];// , philist1[phiSlices];
   for ( Int_t i = 0 ; i < rows ; i++ )    {
     rlist1[i] = fgkIFCRadius + i*gridSizeR ;
-    for ( Int_t j = 0 ; j < columns ; j++ ) { 
+    for ( Int_t j = 0 ; j < columns ; j++ ) {
       zedlist1[j]  = j * gridSizeZ ;
     }
   }
-  
+
   TTree *treePOC = (TTree*)fZR->Get("POCall");
 
   TVector *bEr  = 0;   //TVector *bEphi= 0;
   TVector *bEz  = 0;
-  
+
   treePOC->SetBranchAddress("Er",&bEr);
   treePOC->SetBranchAddress("Ez",&bEz);
 
 
   // Read the complete tree and do a weighted sum-up over the POC configurations
   // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-  
+
   Int_t treeNumPOC = (Int_t)treePOC->GetEntries(); // Number of POC conf. in the look-up table
   Int_t ipC = 0; // POC Conf. counter (note: different to the POC number in the tree!)
 
   for (Int_t itreepC=0; itreepC<treeNumPOC; itreepC++) { // ------------- loop over POC configurations in tree
-  
+
     treePOC->GetEntry(itreepC);
 
     // center of the POC voxel in [meter]
@@ -362,33 +350,33 @@ void AliTPCSpaceCharge3D::InitSpaceCharge3DDistortion() {
     // note: coordinates are in [cm]
     Double_t weightA = GetSpaceChargeDensity(r0*100,phi0, z0*100, 1);  // partial load in r,z
     Double_t weightC = GetSpaceChargeDensity(r0*100,phi0,-z0*100, 1);  // partial load in r,z
-  
+
     // Summing up the vector components according to their weight
 
     Int_t ip = 0;
-    for ( Int_t j = 0 ; j < columns ; j++ ) { 
+    for ( Int_t j = 0 ; j < columns ; j++ ) {
       for ( Int_t i = 0 ; i < rows ; i++ )    {
 	for ( Int_t k = 0 ; k < phiSlices ; k++ ) {
-		  
+
 	  // check wether the coordinates were screwed
-	  if (TMath::Abs((coord1(0,ip)*100-rlist1[i]))>1 || 
-	      TMath::Abs((coord1(2,ip)*100-zedlist1[j])>1)) { 
+	  if (TMath::Abs((coord1(0,ip)*100-rlist1[i]))>1 ||
+	      TMath::Abs((coord1(2,ip)*100-zedlist1[j])>1)) {
 	    AliError("internal error: coordinate system was screwed during the sum-up");
 	    printf("sum-up: (r,z)=(%f,%f)\n",rlist1[i],zedlist1[j]);
 	    printf("lookup: (r,z)=(%f,%f)\n",coord1(0,ip)*100,coord1(2,ip)*100);
 	    AliError("Don't trust the results of the space charge calculation!");
 	  }
-	  
+
 	  // unfortunately, the lookup tables were produced to be faster for phi symmetric charges
 	  // This will be the most frequent usage (hopefully)
 	  // That's why we have to do this here ...
 
 	  TMatrixD &erA   =  *arrayofErA[k]  ;
 	  TMatrixD &dEzA  =  *arrayofdEzA[k]   ;
-   
+
 	  TMatrixD &erC   =  *arrayofErC[k]  ;
 	  TMatrixD &dEzC  =  *arrayofdEzC[k]   ;
-   
+
 	  // Sum up - Efield values in [V/m] -> transition to [V/cm]
 	  erA(i,j) += ((*bEr)(ip)) * weightA /100;
 	  erC(i,j) += ((*bEr)(ip)) * weightC /100;
@@ -422,18 +410,18 @@ void AliTPCSpaceCharge3D::InitSpaceCharge3DDistortion() {
     TMatrixD &erOverEzA   =  *arrayofEroverEzA[k]  ;
     TMatrixD &deltaEzA    =  *arrayofDeltaEzA[k];
     TMatrixD &erOverEzC   =  *arrayofEroverEzC[k]  ;
-    TMatrixD &deltaEzC    =  *arrayofDeltaEzC[k];    
-    
+    TMatrixD &deltaEzC    =  *arrayofDeltaEzC[k];
+
     for ( Int_t i = 0 ; i < rows ; i++ )    { // r loop
-      for ( Int_t j = columns-1 ; j >= 0 ; j-- ) {// z loop 
+      for ( Int_t j = columns-1 ; j >= 0 ; j-- ) {// z loop
 	// Count backwards to facilitate integration over Z
 
-	Int_t index = 1 ; // Simpsons rule if N=odd.If N!=odd then add extra point 
-	                  // by trapezoidal rule.  
+	Int_t index = 1 ; // Simpsons rule if N=odd.If N!=odd then add extra point
+	                  // by trapezoidal rule.
 
 	erOverEzA(i,j) = 0; //ephiOverEzA(i,j) = 0;
 	deltaEzA(i,j) = 0;
-	erOverEzC(i,j) = 0; //ephiOverEzC(i,j) = 0; 
+	erOverEzC(i,j) = 0; //ephiOverEzC(i,j) = 0;
 	deltaEzC(i,j) = 0;
 
 	for ( Int_t m = j ; m < columns ; m++ ) { // integration
@@ -466,43 +454,43 @@ void AliTPCSpaceCharge3D::InitSpaceCharge3DDistortion() {
 	  deltaEzC(i,j)    = (gridSizeZ/3.0)*(1.5*dezC(i,columns-2)+1.5*dezC(i,columns-1))/(-1) ;
 	}
 	if ( j == columns-1 ) {
-	  erOverEzA(i,j)   = 0;   
+	  erOverEzA(i,j)   = 0;
 	  erOverEzC(i,j)   = 0;
-	  deltaEzA(i,j)    = 0;  
+	  deltaEzA(i,j)    = 0;
 	  deltaEzC(i,j)    = 0;
 	}
       }
     }
 
   }
-  
+
   //  AliInfo("Step 1: Interpolation to Standard grid");
 
   // -------------------------------------------------------------------------------
   // Interpolate results onto the standard grid which is used for all AliTPCCorrections classes
 
-  const Int_t order  = 1  ;  // Linear interpolation = 1, Quadratic = 2  
+  const Int_t order  = 1  ;  // Linear interpolation = 1, Quadratic = 2
 
   Double_t  r, z;//phi, z ;
   for ( Int_t k = 0 ; k < kNPhi ; k++ ) {
     //    phi = fgkPhiList[k] ;
-	
+
     // final lookup table
     TMatrixF &erOverEzFinal   =  *fLookUpErOverEz[k]  ;
     TMatrixF &deltaEzFinal    =  *fLookUpDeltaEz[k]   ;
-	
+
     // calculated and integrated tables - just one phi slice
     TMatrixD &erOverEzA   =  *arrayofEroverEzA[0]  ;
     TMatrixD &deltaEzA    =  *arrayofDeltaEzA[0];
     TMatrixD &erOverEzC   =  *arrayofEroverEzC[0]  ;
-    TMatrixD &deltaEzC    =  *arrayofDeltaEzC[0];    
-    
-    
+    TMatrixD &deltaEzC    =  *arrayofDeltaEzC[0];
+
+
     for ( Int_t j = 0 ; j < kNZ ; j++ ) {
 
       z = TMath::Abs(fgkZList[j]) ;  // z position is symmetric
-    
-      for ( Int_t i = 0 ; i < kNR ; i++ ) { 
+
+      for ( Int_t i = 0 ; i < kNR ; i++ ) {
 	r = fgkRList[i] ;
 
 	// Interpolate Lookup tables onto standard grid
@@ -519,18 +507,18 @@ void AliTPCSpaceCharge3D::InitSpaceCharge3DDistortion() {
     } // end z loop
   } // end phi loop
 
-  
+
   // clear the temporary arrays lists
   for ( Int_t k = 0 ; k < phiSlices ; k++ )  {
 
-    delete arrayofErA[k];  
+    delete arrayofErA[k];
     delete arrayofdEzA[k];
-    delete arrayofErC[k];  
+    delete arrayofErC[k];
     delete arrayofdEzC[k];
 
-    delete arrayofEroverEzA[k];  
+    delete arrayofEroverEzA[k];
     delete arrayofDeltaEzA[k];
-    delete arrayofEroverEzC[k];  
+    delete arrayofEroverEzC[k];
     delete arrayofDeltaEzC[k];
 
   }
@@ -539,54 +527,54 @@ void AliTPCSpaceCharge3D::InitSpaceCharge3DDistortion() {
 
   // ------------------------------------------------------------------------------------------------------
   // Step 2: Load and sum up lookup table in rphi, fine grid, to emulate for example a GG leak
- 
+
   //  AliInfo("Step 2: Preparation of the weighted look-up table");
- 
+
   TFile *fRPhi = new TFile(fSCLookUpPOCsFileNameRPhi.Data(),"READ");
   if ( !fRPhi ) {
     AliError("Precalculated POC-looup-table in RPhi could not be found");
     return;
-  } 
+  }
 
   // units are in [m]
-  TVector *gridf2  = (TVector*) fRPhi->Get("constants"); 
+  TVector *gridf2  = (TVector*) fRPhi->Get("constants");
   TVector &grid2 = *gridf2;
   TMatrix *coordf2  = (TMatrix*) fRPhi->Get("coordinates");
   TMatrix &coord2 = *coordf2;
   TMatrix *coordPOCf2  = (TMatrix*) fRPhi->Get("POCcoord");
   TMatrix &coordPOC2 = *coordPOCf2;
 
-  rows      = (Int_t)grid2(0);   // number of points in r direction   
-  phiSlices = (Int_t)grid2(1);   // number of points in phi           
-  columns   = (Int_t)grid2(2);   // number of points in z direction   
+  rows      = (Int_t)grid2(0);   // number of points in r direction
+  phiSlices = (Int_t)grid2(1);   // number of points in phi
+  columns   = (Int_t)grid2(2);   // number of points in z direction
 
   gridSizeR   =  (fgkOFCRadius-fgkIFCRadius)/(rows-1);   // unit in [cm]
   Float_t gridSizePhi =  TMath::TwoPi()/phiSlices;         // unit in [rad]
   gridSizeZ   =  fgkTPCZ0/(columns-1);                  // unit in [cm]
- 
+
   // list of points as used during sum up
-  Double_t  rlist2[kNRows], philist2[kNPhiSlices], zedlist2[kNColumns]; 
+  Double_t  rlist2[kNRows], philist2[kNPhiSlices], zedlist2[kNColumns];
   for ( Int_t k = 0 ; k < phiSlices ; k++ ) {
     philist2[k] =  gridSizePhi * k;
     for ( Int_t i = 0 ; i < rows ; i++ )    {
       rlist2[i] = fgkIFCRadius + i*gridSizeR ;
-      for ( Int_t j = 0 ; j < columns ; j++ ) { 
+      for ( Int_t j = 0 ; j < columns ; j++ ) {
 	zedlist2[j]  = j * gridSizeZ ;
       }
     }
   } // only done once
- 
-  // temporary matrices needed for the calculation 
+
+  // temporary matrices needed for the calculation
 
   TMatrixD *arrayofErA2[kNPhiSlices], *arrayofEphiA2[kNPhiSlices], *arrayofdEzA2[kNPhiSlices];
-  TMatrixD *arrayofErC2[kNPhiSlices], *arrayofEphiC2[kNPhiSlices], *arrayofdEzC2[kNPhiSlices]; 
+  TMatrixD *arrayofErC2[kNPhiSlices], *arrayofEphiC2[kNPhiSlices], *arrayofdEzC2[kNPhiSlices];
+
+  TMatrixD *arrayofEroverEzA2[kNPhiSlices], *arrayofEphioverEzA2[kNPhiSlices], *arrayofDeltaEzA2[kNPhiSlices];
+  TMatrixD *arrayofEroverEzC2[kNPhiSlices], *arrayofEphioverEzC2[kNPhiSlices], *arrayofDeltaEzC2[kNPhiSlices];
 
-  TMatrixD *arrayofEroverEzA2[kNPhiSlices], *arrayofEphioverEzA2[kNPhiSlices], *arrayofDeltaEzA2[kNPhiSlices]; 
-  TMatrixD *arrayofEroverEzC2[kNPhiSlices], *arrayofEphioverEzC2[kNPhiSlices], *arrayofDeltaEzC2[kNPhiSlices]; 
 
- 
   for ( Int_t k = 0 ; k < phiSlices ; k++ ) {
-   
+
     arrayofErA2[k]   =   new TMatrixD(rows,columns) ;
     arrayofEphiA2[k] =   new TMatrixD(rows,columns) ;
     arrayofdEzA2[k]  =   new TMatrixD(rows,columns) ;
@@ -595,17 +583,17 @@ void AliTPCSpaceCharge3D::InitSpaceCharge3DDistortion() {
     arrayofdEzC2[k]  =   new TMatrixD(rows,columns) ;
 
     arrayofEroverEzA2[k]   =   new TMatrixD(rows,columns) ;
-    arrayofEphioverEzA2[k] =   new TMatrixD(rows,columns) ; 
+    arrayofEphioverEzA2[k] =   new TMatrixD(rows,columns) ;
     arrayofDeltaEzA2[k]    =   new TMatrixD(rows,columns) ;
     arrayofEroverEzC2[k]   =   new TMatrixD(rows,columns) ;
-    arrayofEphioverEzC2[k] =   new TMatrixD(rows,columns) ; 
+    arrayofEphioverEzC2[k] =   new TMatrixD(rows,columns) ;
     arrayofDeltaEzC2[k]    =   new TMatrixD(rows,columns) ;
 
-    // zero initialization not necessary, it is done in the constructor of TMatrix 
+    // zero initialization not necessary, it is done in the constructor of TMatrix
 
   }
- 
-    
+
+
   treePOC = (TTree*)fRPhi->Get("POCall");
 
   //  TVector *bEr  = 0;   // done above
@@ -618,12 +606,12 @@ void AliTPCSpaceCharge3D::InitSpaceCharge3DDistortion() {
 
   // Read the complete tree and do a weighted sum-up over the POC configurations
   // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-  
+
   treeNumPOC = (Int_t)treePOC->GetEntries(); // Number of POC conf. in the look-up table
   ipC = 0; // POC Conf. counter (note: different to the POC number in the tree!)
 
   for (Int_t itreepC=0; itreepC<treeNumPOC; itreepC++) { // ------------- loop over POC configurations in tree
-  
+
     treePOC->GetEntry(itreepC);
 
     // center of the POC voxel in [meter]
@@ -635,26 +623,26 @@ void AliTPCSpaceCharge3D::InitSpaceCharge3DDistortion() {
     // note: coordinates are in [cm]
     Double_t weightA = GetSpaceChargeDensity(r0*100,phi0, 0.499, 2);  // partial load in r,phi
     Double_t weightC = GetSpaceChargeDensity(r0*100,phi0,-0.499, 2);  // partial load in r,phi
-  
+
     //    printf("-----\n%f %f : %e %e\n",r0,phi0,weightA,weightC);
 
     // Summing up the vector components according to their weight
 
     Int_t ip = 0;
-    for ( Int_t j = 0 ; j < columns ; j++ ) { 
+    for ( Int_t j = 0 ; j < columns ; j++ ) {
       for ( Int_t i = 0 ; i < rows ; i++ )    {
 	for ( Int_t k = 0 ; k < phiSlices ; k++ ) {
-		  
+
 	  // check wether the coordinates were screwed
-	  if (TMath::Abs((coord2(0,ip)*100-rlist2[i]))>1 || 
-	      TMath::Abs((coord2(1,ip)-philist2[k]))>1 || 
-	      TMath::Abs((coord2(2,ip)*100-zedlist2[j]))>1) { 
+	  if (TMath::Abs((coord2(0,ip)*100-rlist2[i]))>1 ||
+	      TMath::Abs((coord2(1,ip)-philist2[k]))>1 ||
+	      TMath::Abs((coord2(2,ip)*100-zedlist2[j]))>1) {
 	    AliError("internal error: coordinate system was screwed during the sum-up");
 	    printf("lookup: (r,phi,z)=(%f,%f,%f)\n",coord2(0,ip)*100,coord2(1,ip),coord2(2,ip)*100);
 	    printf("sum-up: (r,phi,z)=(%f,%f,%f)\n",rlist2[i],philist2[k],zedlist2[j]);
 	    AliError("Don't trust the results of the space charge calculation!");
 	  }
-	  
+
 	  // unfortunately, the lookup tables were produced to be faster for phi symmetric charges
 	  // This will be the most frequent usage (hopefully)
 	  // That's why we have to do this here ...
@@ -662,11 +650,11 @@ void AliTPCSpaceCharge3D::InitSpaceCharge3DDistortion() {
 	  TMatrixD &erA   =  *arrayofErA2[k]  ;
 	  TMatrixD &ephiA =  *arrayofEphiA2[k];
 	  TMatrixD &dEzA  =  *arrayofdEzA2[k] ;
-   
+
 	  TMatrixD &erC   =  *arrayofErC2[k]  ;
 	  TMatrixD &ephiC =  *arrayofEphiC2[k];
 	  TMatrixD &dEzC  =  *arrayofdEzC2[k]   ;
-   
+
 	  // Sum up - Efield values in [V/m] -> transition to [V/cm]
 	  erA(i,j) += ((*bEr)(ip)) * weightA /100;
 	  erC(i,j) += ((*bEr)(ip)) * weightC /100;
@@ -680,57 +668,57 @@ void AliTPCSpaceCharge3D::InitSpaceCharge3DDistortion() {
 	}
       }
     } // end coordinate loop
-    
-    
+
+
     // Rotation and summation in the rest of the dPhiSteps
     // which were not stored in the this tree due to storage & symmetry reasons
 
-    
+
     Int_t phiPoints = (Int_t) grid2(1);
     Int_t phiPOC    = (Int_t) grid2(4);
-    
+
     //   printf("%d %d\n",phiPOC,flagRadSym);
-    
-    for (Int_t phiiC = 1; phiiC<phiPOC; phiiC++) { // just used for non-radial symetric table 
-      
+
+    for (Int_t phiiC = 1; phiiC<phiPOC; phiiC++) { // just used for non-radial symetric table
+
       Double_t phi0R = phiiC*phi0*2 + phi0; // rotate further
 
       // weights (charge density) at POC position on the A and C side (in C/m^3/e0)
       // note: coordinates are in [cm] // ecxept z
       weightA = GetSpaceChargeDensity(r0*100,phi0R, 0.499, 2);  // partial load in r,phi
       weightC = GetSpaceChargeDensity(r0*100,phi0R,-0.499, 2);  // partial load in r,phi
-    
+
       // printf("%f %f : %e %e\n",r0,phi0R,weightA,weightC);
-         
+
       // Summing up the vector components according to their weight
       ip = 0;
-      for ( Int_t j = 0 ; j < columns ; j++ ) { 
+      for ( Int_t j = 0 ; j < columns ; j++ ) {
 	for ( Int_t i = 0 ; i < rows ; i++ )    {
 	  for ( Int_t k = 0 ; k < phiSlices ; k++ ) {
-	    
+
 	    // Note: rotating the coordinated during the sum up
-	    
+
 	    Int_t rotVal = (phiPoints/phiPOC)*phiiC;
 	    Int_t ipR = -1;
-	    
+
 	    if ((ip%phiPoints)>=rotVal) {
 	      ipR = ip-rotVal;
 	    } else {
 	      ipR = ip+(phiPoints-rotVal);
 	    }
-	    
+
 	    // unfortunately, the lookup tables were produced to be faster for phi symmetric charges
-	    // This will be the most frequent usage 
+	    // This will be the most frequent usage
 	    // That's why we have to do this here and not outside the loop ...
-	    
+
 	    TMatrixD &erA   =  *arrayofErA2[k]  ;
 	    TMatrixD &ephiA =  *arrayofEphiA2[k];
 	    TMatrixD &dEzA  =  *arrayofdEzA2[k]   ;
-	    
+
 	    TMatrixD &erC   =  *arrayofErC2[k]  ;
 	    TMatrixD &ephiC =  *arrayofEphiC2[k];
 	    TMatrixD &dEzC  =  *arrayofdEzC2[k]   ;
-       
+
 	    // Sum up - Efield values in [V/m] -> transition to [V/cm]
 	    erA(i,j) += ((*bEr)(ipR)) * weightA /100;
 	    erC(i,j) += ((*bEr)(ipR)) * weightC /100;
@@ -750,7 +738,7 @@ void AliTPCSpaceCharge3D::InitSpaceCharge3DDistortion() {
     ipC++; // POC configuration counter
 
     //   printf("POC: (r,phi,z) = (%f %f %f) | weight(A,C): %03.1lf %03.1lf\n",r0,phi0,z0, weightA, weightC);
-    
+
   }
 
 
@@ -778,19 +766,19 @@ void AliTPCSpaceCharge3D::InitSpaceCharge3DDistortion() {
     TMatrixD &deltaEzA    =  *arrayofDeltaEzA2[k];
     TMatrixD &erOverEzC   =  *arrayofEroverEzC2[k]  ;
     TMatrixD &ephiOverEzC =  *arrayofEphioverEzC2[k];
-    TMatrixD &deltaEzC    =  *arrayofDeltaEzC2[k];    
-    
+    TMatrixD &deltaEzC    =  *arrayofDeltaEzC2[k];
+
     for ( Int_t i = 0 ; i < rows ; i++ )    { // r loop
-      for ( Int_t j = columns-1 ; j >= 0 ; j-- ) {// z loop 
+      for ( Int_t j = columns-1 ; j >= 0 ; j-- ) {// z loop
 	// Count backwards to facilitate integration over Z
 
-	Int_t index = 1 ; // Simpsons rule if N=odd.If N!=odd then add extra point by trapezoidal rule.  
+	Int_t index = 1 ; // Simpsons rule if N=odd.If N!=odd then add extra point by trapezoidal rule.
 
-	erOverEzA(i,j) = 0; 
+	erOverEzA(i,j) = 0;
 	ephiOverEzA(i,j) = 0;
 	deltaEzA(i,j) = 0;
-	erOverEzC(i,j) = 0; 
-	ephiOverEzC(i,j) = 0; 
+	erOverEzC(i,j) = 0;
+	ephiOverEzC(i,j) = 0;
 	deltaEzC(i,j) = 0;
 
 	for ( Int_t m = j ; m < columns ; m++ ) { // integration
@@ -831,18 +819,18 @@ void AliTPCSpaceCharge3D::InitSpaceCharge3DDistortion() {
 	  deltaEzC(i,j)    = (gridSizeZ/3.0)*(1.5*dezC(i,columns-2)+1.5*dezC(i,columns-1))/(-1) ;
 	}
 	if ( j == columns-1 ) {
-	  erOverEzA(i,j)   = 0;   
+	  erOverEzA(i,j)   = 0;
 	  erOverEzC(i,j)   = 0;
-	  ephiOverEzA(i,j) = 0; 
+	  ephiOverEzA(i,j) = 0;
 	  ephiOverEzC(i,j) = 0;
-	  deltaEzA(i,j)    = 0;  
+	  deltaEzA(i,j)    = 0;
 	  deltaEzC(i,j)    = 0;
 	}
       }
     }
 
   }
-  
+
   AliInfo("Step 2: Interpolation to Standard grid");
 
   // -------------------------------------------------------------------------------
@@ -851,29 +839,29 @@ void AliTPCSpaceCharge3D::InitSpaceCharge3DDistortion() {
 
   for ( Int_t k = 0 ; k < kNPhi ; k++ ) {
     Double_t phi = fgkPhiList[k] ;
-	
+
     // final lookup table
     TMatrixF &erOverEzFinal   =  *fLookUpErOverEz[k]  ;
     TMatrixF &ephiOverEzFinal =  *fLookUpEphiOverEz[k];
     TMatrixF &deltaEzFinal    =  *fLookUpDeltaEz[k]   ;
-	
+
     for ( Int_t j = 0 ; j < kNZ ; j++ ) {
 
       z = TMath::Abs(fgkZList[j]) ;  // z position is symmetric
-    
-      for ( Int_t i = 0 ; i < kNR ; i++ ) { 
+
+      for ( Int_t i = 0 ; i < kNR ; i++ ) {
 	r = fgkRList[i] ;
 
 	// Interpolate Lookup tables onto standard grid
 	if (fgkZList[j]>0) {
-	  erOverEzFinal(i,j)   += Interpolate3DTable(order, r, z, phi, rows, columns, phiSlices, 
+	  erOverEzFinal(i,j)   += Interpolate3DTable(order, r, z, phi, rows, columns, phiSlices,
 					       rlist2, zedlist2, philist2, arrayofEroverEzA2  );
 	  ephiOverEzFinal(i,j) += Interpolate3DTable(order, r, z, phi, rows, columns, phiSlices,
 					       rlist2, zedlist2, philist2, arrayofEphioverEzA2);
 	  deltaEzFinal(i,j)    += Interpolate3DTable(order, r, z, phi, rows, columns, phiSlices,
 					       rlist2, zedlist2, philist2, arrayofDeltaEzA2   );
 	} else {
-	  erOverEzFinal(i,j)   += Interpolate3DTable(order, r, z, phi, rows, columns, phiSlices, 
+	  erOverEzFinal(i,j)   += Interpolate3DTable(order, r, z, phi, rows, columns, phiSlices,
 					       rlist2, zedlist2, philist2, arrayofEroverEzC2  );
 	  ephiOverEzFinal(i,j) += Interpolate3DTable(order, r, z, phi, rows, columns, phiSlices,
 					       rlist2, zedlist2, philist2, arrayofEphioverEzC2);
@@ -884,29 +872,29 @@ void AliTPCSpaceCharge3D::InitSpaceCharge3DDistortion() {
       } // end r loop
     } // end z loop
   } // end phi loop
-  
-  
+
+
   // clear the temporary arrays lists
   for ( Int_t k = 0 ; k < phiSlices ; k++ )  {
 
-    delete arrayofErA2[k];  
+    delete arrayofErA2[k];
     delete arrayofEphiA2[k];
     delete arrayofdEzA2[k];
-    delete arrayofErC2[k];  
+    delete arrayofErC2[k];
     delete arrayofEphiC2[k];
     delete arrayofdEzC2[k];
 
-    delete arrayofEroverEzA2[k];  
+    delete arrayofEroverEzA2[k];
     delete arrayofEphioverEzA2[k];
     delete arrayofDeltaEzA2[k];
-    delete arrayofEroverEzC2[k];  
+    delete arrayofEroverEzC2[k];
     delete arrayofEphioverEzC2[k];
     delete arrayofDeltaEzC2[k];
 
   }
- 
+
   fRPhi->Close();
-  
+
   // FINISHED
 
   fInitLookUp = kTRUE;
@@ -914,16 +902,15 @@ void AliTPCSpaceCharge3D::InitSpaceCharge3DDistortion() {
 }
 
 void AliTPCSpaceCharge3D::InitSpaceCharge3DDistortionCourse() {
-  //
-  // Initialization of the Lookup table which contains the solutions of the 
-  // "space charge" (poisson) problem 
-  //
-  // The sum-up uses a look-up table which contains different discretized Space charge fields 
-  // in order to calculate the corresponding field deviations due to a given (discretized)
-  // space charge distribution ....
-  //
-  // Method of calculation: Weighted sum-up of the different fields within the look up table
-  // Note: Full 3d version: Course and slow ...
+  /// Initialization of the Lookup table which contains the solutions of the
+  /// "space charge" (poisson) problem
+  ///
+  /// The sum-up uses a look-up table which contains different discretized Space charge fields
+  /// in order to calculate the corresponding field deviations due to a given (discretized)
+  /// space charge distribution ....
+  ///
+  /// Method of calculation: Weighted sum-up of the different fields within the look up table
+  /// Note: Full 3d version: Course and slow ...
 
   if (fInitLookUp) {
     AliInfo("Lookup table was already initialized!");
@@ -931,7 +918,7 @@ void AliTPCSpaceCharge3D::InitSpaceCharge3DDistortionCourse() {
   }
 
   AliInfo("Preparation of the weighted look-up table");
-   
+
   TFile *f = new TFile(fSCLookUpPOCsFileName3D.Data(),"READ");
   if ( !f ) {
     AliError("Precalculated POC-looup-table could not be found");
@@ -939,27 +926,27 @@ void AliTPCSpaceCharge3D::InitSpaceCharge3DDistortionCourse() {
   }
 
   // units are in [m]
-  TVector *gridf  = (TVector*) f->Get("constants"); 
+  TVector *gridf  = (TVector*) f->Get("constants");
   TVector &grid = *gridf;
   TMatrix *coordf  = (TMatrix*) f->Get("coordinates");
   TMatrix &coord = *coordf;
   TMatrix *coordPOCf  = (TMatrix*) f->Get("POCcoord");
   TMatrix &coordPOC = *coordPOCf;
-  
+
   Bool_t flagRadSym = 0;
   if (grid(1)==1 && grid(4)==1) {
     //   AliInfo("LOOK UP TABLE IS RADIAL SYMETTRIC - Field in Phi is ZERO");
     flagRadSym=1;
   }
 
-  Int_t rows      = (Int_t)grid(0);   // number of points in r direction 
-  Int_t phiSlices = (Int_t)grid(1);   // number of points in phi         
-  Int_t columns   = (Int_t)grid(2);   // number of points in z direction 
+  Int_t rows      = (Int_t)grid(0);   // number of points in r direction
+  Int_t phiSlices = (Int_t)grid(1);   // number of points in phi
+  Int_t columns   = (Int_t)grid(2);   // number of points in z direction
 
   const Float_t gridSizeR   =  (fgkOFCRadius-fgkIFCRadius)/(rows-1);   // unit in [cm]
   const Float_t gridSizePhi =  TMath::TwoPi()/phiSlices;         // unit in [rad]
   const Float_t gridSizeZ   =  fgkTPCZ0/(columns-1);                  // unit in [cm]
- 
+
   // temporary matrices needed for the calculation
   TMatrixD *arrayofErA[kNPhiSlices], *arrayofEphiA[kNPhiSlices], *arrayofdEzA[kNPhiSlices];
   TMatrixD *arrayofErC[kNPhiSlices], *arrayofEphiC[kNPhiSlices], *arrayofdEzC[kNPhiSlices];
@@ -967,9 +954,9 @@ void AliTPCSpaceCharge3D::InitSpaceCharge3DDistortionCourse() {
   TMatrixD *arrayofEroverEzA[kNPhiSlices], *arrayofEphioverEzA[kNPhiSlices], *arrayofDeltaEzA[kNPhiSlices];
   TMatrixD *arrayofEroverEzC[kNPhiSlices], *arrayofEphioverEzC[kNPhiSlices], *arrayofDeltaEzC[kNPhiSlices];
 
- 
+
   for ( Int_t k = 0 ; k < phiSlices ; k++ ) {
-   
+
     arrayofErA[k]   =   new TMatrixD(rows,columns) ;
     arrayofEphiA[k] =   new TMatrixD(rows,columns) ; // zero if radial symmetric
     arrayofdEzA[k]  =   new TMatrixD(rows,columns) ;
@@ -988,24 +975,24 @@ void AliTPCSpaceCharge3D::InitSpaceCharge3DDistortionCourse() {
     // not necessary, it is done in the constructor of TMatrix - code deleted
 
   }
- 
+
   // list of points as used in the interpolation (during sum up)
   Double_t  rlist[kNRows], zedlist[kNColumns] , philist[kNPhiSlices];
   for ( Int_t k = 0 ; k < phiSlices ; k++ ) {
     philist[k] =  gridSizePhi * k;
     for ( Int_t i = 0 ; i < rows ; i++ )    {
       rlist[i] = fgkIFCRadius + i*gridSizeR ;
-      for ( Int_t j = 0 ; j < columns ; j++ ) { 
+      for ( Int_t j = 0 ; j < columns ; j++ ) {
 	zedlist[j]  = j * gridSizeZ ;
       }
     }
   } // only done once
-  
-  
+
+
   TTree *treePOC = (TTree*)f->Get("POCall");
 
   TVector *bEr  = 0;   TVector *bEphi= 0;   TVector *bEz  = 0;
-  
+
   treePOC->SetBranchAddress("Er",&bEr);
   if (!flagRadSym) treePOC->SetBranchAddress("Ephi",&bEphi);
   treePOC->SetBranchAddress("Ez",&bEz);
@@ -1013,12 +1000,12 @@ void AliTPCSpaceCharge3D::InitSpaceCharge3DDistortionCourse() {
 
   // Read the complete tree and do a weighted sum-up over the POC configurations
   // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-  
+
   Int_t treeNumPOC = (Int_t)treePOC->GetEntries(); // Number of POC conf. in the look-up table
   Int_t ipC = 0; // POC Conf. counter (note: different to the POC number in the tree!)
 
   for (Int_t itreepC=0; itreepC<treeNumPOC; itreepC++) { // ------------- loop over POC configurations in tree
-  
+
     treePOC->GetEntry(itreepC);
 
     // center of the POC voxel in [meter]
@@ -1032,24 +1019,24 @@ void AliTPCSpaceCharge3D::InitSpaceCharge3DDistortionCourse() {
     // note: coordinates are in [cm]
     Double_t weightA = GetSpaceChargeDensity(r0*100,phi0, z0*100,0);
     Double_t weightC = GetSpaceChargeDensity(r0*100,phi0,-z0*100,0);
-  
+
     // Summing up the vector components according to their weight
 
     Int_t ip = 0;
-    for ( Int_t j = 0 ; j < columns ; j++ ) { 
+    for ( Int_t j = 0 ; j < columns ; j++ ) {
       for ( Int_t i = 0 ; i < rows ; i++ )    {
 	for ( Int_t k = 0 ; k < phiSlices ; k++ ) {
-		  
+
 	  // check wether the coordinates were screwed
-	  if (TMath::Abs((coord(0,ip)*100-rlist[i]))>1 || 
-	      TMath::Abs((coord(1,ip)-philist[k]))>1 || 
-	      TMath::Abs((coord(2,ip)*100-zedlist[j]))>1) { 
+	  if (TMath::Abs((coord(0,ip)*100-rlist[i]))>1 ||
+	      TMath::Abs((coord(1,ip)-philist[k]))>1 ||
+	      TMath::Abs((coord(2,ip)*100-zedlist[j]))>1) {
 	    AliError("internal error: coordinate system was screwed during the sum-up");
 	    printf("lookup: (r,phi,z)=(%f,%f,%f)\n",coord(0,ip)*100,coord(1,ip),coord(2,ip)*100);
 	    printf("sum-up: (r,phi,z)=(%f,%f,%f)\n",rlist[i],philist[k],zedlist[j]);
 	    AliError("Don't trust the results of the space charge calculation!");
 	  }
-	  
+
 	  // unfortunately, the lookup tables were produced to be faster for phi symmetric charges
 	  // This will be the most frequent usage (hopefully)
 	  // That's why we have to do this here ...
@@ -1057,11 +1044,11 @@ void AliTPCSpaceCharge3D::InitSpaceCharge3DDistortionCourse() {
 	  TMatrixD &erA   =  *arrayofErA[k]  ;
 	  TMatrixD &ephiA =  *arrayofEphiA[k];
 	  TMatrixD &dEzA  =  *arrayofdEzA[k]   ;
-   
+
 	  TMatrixD &erC   =  *arrayofErC[k]  ;
 	  TMatrixD &ephiC =  *arrayofEphiC[k];
 	  TMatrixD &dEzC  =  *arrayofdEzC[k]   ;
-   
+
 	  // Sum up - Efield values in [V/m] -> transition to [V/cm]
 	  erA(i,j) += ((*bEr)(ip)) * weightA /100;
 	  erC(i,j) += ((*bEr)(ip)) * weightC /100;
@@ -1077,60 +1064,60 @@ void AliTPCSpaceCharge3D::InitSpaceCharge3DDistortionCourse() {
 	}
       }
     } // end coordinate loop
-    
-    
+
+
     // Rotation and summation in the rest of the dPhiSteps
     // which were not stored in the this tree due to storage & symmetry reasons
 
     Int_t phiPoints = (Int_t) grid(1);
     Int_t phiPOC    = (Int_t) grid(4);
-    
+
     //   printf("%d %d\n",phiPOC,flagRadSym);
-    
-    for (Int_t phiiC = 1; phiiC<phiPOC; phiiC++) { // just used for non-radial symetric table 
-      
+
+    for (Int_t phiiC = 1; phiiC<phiPOC; phiiC++) { // just used for non-radial symetric table
+
       r0 = coordPOC(ipC,0);
       phi0 = coordPOC(ipC,1);
       z0 = coordPOC(ipC,2);
-      
+
       ipC++; // POC conf. counter
-      
+
       // weights (charge density) at POC position on the A and C side (in C/m^3/e0)
       // note: coordinates are in [cm]
-      weightA = GetSpaceChargeDensity(r0*100,phi0, z0*100,0); 
+      weightA = GetSpaceChargeDensity(r0*100,phi0, z0*100,0);
       weightC = GetSpaceChargeDensity(r0*100,phi0,-z0*100,0);
-      
+
       //     printf("%f %f %f: %e %e\n",r0,phi0,z0,weightA,weightC);
-       
+
       // Summing up the vector components according to their weight
       ip = 0;
-      for ( Int_t j = 0 ; j < columns ; j++ ) { 
+      for ( Int_t j = 0 ; j < columns ; j++ ) {
 	for ( Int_t i = 0 ; i < rows ; i++ )    {
 	  for ( Int_t k = 0 ; k < phiSlices ; k++ ) {
-	    
+
 	    // Note: rotating the coordinated during the sum up
-	    
+
 	    Int_t rotVal = (phiPoints/phiPOC)*phiiC;
 	    Int_t ipR = -1;
-	    
+
 	    if ((ip%phiPoints)>=rotVal) {
 	      ipR = ip-rotVal;
 	    } else {
 	      ipR = ip+(phiPoints-rotVal);
 	    }
-	    
+
 	    // unfortunately, the lookup tables were produced to be faster for phi symmetric charges
-	    // This will be the most frequent usage 
+	    // This will be the most frequent usage
 	    // That's why we have to do this here and not outside the loop ...
-	    
+
 	    TMatrixD &erA   =  *arrayofErA[k]  ;
 	    TMatrixD &ephiA =  *arrayofEphiA[k];
 	    TMatrixD &dEzA  =  *arrayofdEzA[k]   ;
-	    
+
 	    TMatrixD &erC   =  *arrayofErC[k]  ;
 	    TMatrixD &ephiC =  *arrayofEphiC[k];
 	    TMatrixD &dEzC  =  *arrayofdEzC[k]   ;
-       
+
 	    // Sum up - Efield values in [V/m] -> transition to [V/cm]
 	    erA(i,j) += ((*bEr)(ipR)) * weightA /100;
 	    erC(i,j) += ((*bEr)(ipR)) * weightC /100;
@@ -1148,10 +1135,10 @@ void AliTPCSpaceCharge3D::InitSpaceCharge3DDistortionCourse() {
       } // end coordinate loop
 
     } // end phi-POC summation (phiiC)
-   
+
 
     // printf("POC: (r,phi,z) = (%f %f %f) | weight(A,C): %03.1lf %03.1lf\n",r0,phi0,z0, weightA, weightC);
-    
+
   }
 
 
@@ -1179,13 +1166,13 @@ void AliTPCSpaceCharge3D::InitSpaceCharge3DDistortionCourse() {
     TMatrixD &deltaEzA    =  *arrayofDeltaEzA[k];
     TMatrixD &erOverEzC   =  *arrayofEroverEzC[k]  ;
     TMatrixD &ephiOverEzC =  *arrayofEphioverEzC[k];
-    TMatrixD &deltaEzC    =  *arrayofDeltaEzC[k];    
-    
+    TMatrixD &deltaEzC    =  *arrayofDeltaEzC[k];
+
     for ( Int_t i = 0 ; i < rows ; i++ )    { // r loop
-      for ( Int_t j = columns-1 ; j >= 0 ; j-- ) {// z loop 
+      for ( Int_t j = columns-1 ; j >= 0 ; j-- ) {// z loop
 	// Count backwards to facilitate integration over Z
 
-	Int_t index = 1 ; // Simpsons rule if N=odd.If N!=odd then add extra point by trapezoidal rule.  
+	Int_t index = 1 ; // Simpsons rule if N=odd.If N!=odd then add extra point by trapezoidal rule.
 
 	erOverEzA(i,j) = 0; ephiOverEzA(i,j) = 0;  deltaEzA(i,j) = 0;
 	erOverEzC(i,j) = 0; ephiOverEzC(i,j) = 0;  deltaEzC(i,j) = 0;
@@ -1236,54 +1223,54 @@ void AliTPCSpaceCharge3D::InitSpaceCharge3DDistortionCourse() {
 	  deltaEzC(i,j)    = (gridSizeZ/3.0)*(1.5*dezC(i,columns-2)+1.5*dezC(i,columns-1))/(-1) ;
 	}
 	if ( j == columns-1 ) {
-	  erOverEzA(i,j)   = 0;   
+	  erOverEzA(i,j)   = 0;
 	  erOverEzC(i,j)   = 0;
 	  if (!flagRadSym) {
-	    ephiOverEzA(i,j) = 0; 
+	    ephiOverEzA(i,j) = 0;
 	    ephiOverEzC(i,j) = 0;
 	  }
-	  deltaEzA(i,j)    = 0;  
+	  deltaEzA(i,j)    = 0;
 	  deltaEzC(i,j)    = 0;
 	}
       }
     }
 
   }
-  
 
- 
+
+
   AliInfo("Interpolation to Standard grid");
 
   // -------------------------------------------------------------------------------
   // Interpolate results onto the standard grid which is used for all AliTPCCorrections classes
 
-  const Int_t order  = 1  ;  // Linear interpolation = 1, Quadratic = 2  
+  const Int_t order  = 1  ;  // Linear interpolation = 1, Quadratic = 2
 
   Double_t  r, phi, z ;
   for ( Int_t k = 0 ; k < kNPhi ; k++ ) {
     phi = fgkPhiList[k] ;
-	
+
     TMatrixF &erOverEz   =  *fLookUpErOverEz[k]  ;
     TMatrixF &ephiOverEz =  *fLookUpEphiOverEz[k];
     TMatrixF &deltaEz    =  *fLookUpDeltaEz[k]   ;
-	
+
     for ( Int_t j = 0 ; j < kNZ ; j++ ) {
 
       z = TMath::Abs(fgkZList[j]) ;  // z position is symmetric
-    
-      for ( Int_t i = 0 ; i < kNR ; i++ ) { 
+
+      for ( Int_t i = 0 ; i < kNR ; i++ ) {
 	r = fgkRList[i] ;
 
 	// Interpolate Lookup tables onto standard grid
 	if (fgkZList[j]>0) {
-	  erOverEz(i,j)   = Interpolate3DTable(order, r, z, phi, rows, columns, phiSlices, 
+	  erOverEz(i,j)   = Interpolate3DTable(order, r, z, phi, rows, columns, phiSlices,
 					       rlist, zedlist, philist, arrayofEroverEzA  );
 	  ephiOverEz(i,j) = Interpolate3DTable(order, r, z, phi, rows, columns, phiSlices,
 					       rlist, zedlist, philist, arrayofEphioverEzA);
 	  deltaEz(i,j)    = Interpolate3DTable(order, r, z, phi, rows, columns, phiSlices,
 					       rlist, zedlist, philist, arrayofDeltaEzA   );
 	} else {
-	  erOverEz(i,j)   = Interpolate3DTable(order, r, z, phi, rows, columns, phiSlices, 
+	  erOverEz(i,j)   = Interpolate3DTable(order, r, z, phi, rows, columns, phiSlices,
 					       rlist, zedlist, philist, arrayofEroverEzC  );
 	  ephiOverEz(i,j) = Interpolate3DTable(order, r, z, phi, rows, columns, phiSlices,
 					       rlist, zedlist, philist, arrayofEphioverEzC);
@@ -1296,21 +1283,21 @@ void AliTPCSpaceCharge3D::InitSpaceCharge3DDistortionCourse() {
     } // end z loop
   } // end phi loop
 
- 
+
   // clear the temporary arrays lists
   for ( Int_t k = 0 ; k < phiSlices ; k++ )  {
 
-    delete arrayofErA[k];  
+    delete arrayofErA[k];
     delete arrayofEphiA[k];
     delete arrayofdEzA[k];
-    delete arrayofErC[k];  
+    delete arrayofErC[k];
     delete arrayofEphiC[k];
     delete arrayofdEzC[k];
 
-    delete arrayofEroverEzA[k];  
+    delete arrayofEroverEzA[k];
     delete arrayofEphioverEzA[k];
     delete arrayofDeltaEzA[k];
-    delete arrayofEroverEzC[k];  
+    delete arrayofEroverEzC[k];
     delete arrayofEphioverEzC[k];
     delete arrayofDeltaEzC[k];
 
@@ -1322,35 +1309,33 @@ void AliTPCSpaceCharge3D::InitSpaceCharge3DDistortionCourse() {
 
 
 void AliTPCSpaceCharge3D::SetSCDataFileName(TString fname) {
-  //
-  // Set & load the Space charge density distribution from a file 
-  // (linear interpolation onto a standard grid)
-  //
+  /// Set & load the Space charge density distribution from a file
+  /// (linear interpolation onto a standard grid)
+
 
- 
   fSCDataFileName = fname;
 
   TFile *f = new TFile(fSCDataFileName.Data(),"READ");
-  if (!f) { 
+  if (!f) {
     AliError(Form("File %s, which should contain the space charge distribution, could not be found",
 		  fSCDataFileName.Data()));
     return;
   }
- 
+
   TH2F *densityRZ = (TH2F*) f->Get("SpaceChargeInRZ");
-  if (!densityRZ) { 
+  if (!densityRZ) {
     AliError(Form("The indicated file (%s) does not contain a histogram called %s",
 		  fSCDataFileName.Data(),"SpaceChargeInRZ"));
     return;
   }
 
   TH3F *densityRPhi = (TH3F*) f->Get("SpaceChargeInRPhi");
-  if (!densityRPhi) { 
+  if (!densityRPhi) {
     AliError(Form("The indicated file (%s) does not contain a histogram called %s",
 		  fSCDataFileName.Data(),"SpaceChargeInRPhi"));
     return;
   }
- 
+
 
   Double_t  r, phi, z ;
 
@@ -1361,8 +1346,8 @@ void AliTPCSpaceCharge3D::SetSCDataFileName(TString fname) {
     phi = fgkPhiList[k] ;
     TMatrixF &scDensity   =  *fSCdensityDistribution[k]  ;
     for ( Int_t j = 0 ; j < kNZ ; j++ ) {
-      z = fgkZList[j] ; 
-      for ( Int_t i = 0 ; i < kNR ; i++ ) { 
+      z = fgkZList[j] ;
+      for ( Int_t i = 0 ; i < kNR ; i++ ) {
 	r = fgkRList[i] ;
 
 	// partial load in (r,z)
@@ -1371,17 +1356,17 @@ void AliTPCSpaceCharge3D::SetSCDataFileName(TString fname) {
 
 	// partial load in (r,phi)
 	if ( j==0 || j == kNZ/2 ) {
-	  if (z>0) 
+	  if (z>0)
 	    scDensityInRPhiA(i,k) =  densityRPhi->Interpolate(r,phi,0.499);  // A side
-	  else 
+	  else
 	    scDensityInRPhiC(i,k) =  densityRPhi->Interpolate(r,phi,-0.499); // C side
 	}
 
 	// Full 3D configuration ...
-	if (z>0) 
-	   scDensity(i,j) = scDensityInRZ(i,j) + scDensityInRPhiA(i,k); 
+	if (z>0)
+	   scDensity(i,j) = scDensityInRZ(i,j) + scDensityInRPhiA(i,k);
 	else
-	   scDensity(i,j) = scDensityInRZ(i,j) + scDensityInRPhiC(i,k); 
+	   scDensity(i,j) = scDensityInRZ(i,j) + scDensityInRPhiC(i,k);
       }
     }
   }
@@ -1390,18 +1375,16 @@ void AliTPCSpaceCharge3D::SetSCDataFileName(TString fname) {
 
   fInitLookUp = kFALSE;
 
-  
+
 }
 
 void     AliTPCSpaceCharge3D::SetInputSpaceCharge(TH3 * hisSpaceCharge3D,  TH2 * hisRPhi, TH2* hisRZ, Double_t norm){
-  //
-  // Use 3D space charge map as an optional input
-  // The layout of the input histogram is assumed to be: (phi,r,z)
-  // Density histogram is expreseed is expected to bin in  C/m^3
-  //
-  // Standard histogram interpolation is used in order to use the density at center of voxel
-  // 
-  //
+  /// Use 3D space charge map as an optional input
+  /// The layout of the input histogram is assumed to be: (phi,r,z)
+  /// Density histogram is expreseed is expected to bin in  C/m^3
+  ///
+  /// Standard histogram interpolation is used in order to use the density at center of voxel
+
   fSpaceChargeHistogram3D = hisSpaceCharge3D;
   fSpaceChargeHistogramRPhi = hisRPhi;
   fSpaceChargeHistogramRZ = hisRZ;
@@ -1420,42 +1403,40 @@ void     AliTPCSpaceCharge3D::SetInputSpaceCharge(TH3 * hisSpaceCharge3D,  TH2 *
     phi = fgkPhiList[k] ;
     TMatrixF &scDensity   =  *fSCdensityDistribution[k]  ;
     for ( Int_t j = 0 ; j < kNZ ; j++ ) {
-      z = fgkZList[j] ; 
-      for ( Int_t i = 0 ; i < kNR ; i++ ) { 
+      z = fgkZList[j] ;
+      for ( Int_t i = 0 ; i < kNR ; i++ ) {
 	// Full 3D configuration ...
 	r = fgkRList[i] ;
-	if (r>rmin && r<rmax && z>zmin && z< zmax){	  	  
+	if (r>rmin && r<rmax && z>zmin && z< zmax){
 	  // partial load in (r,z)
 	  if (k==0) {
 	    if (fSpaceChargeHistogramRZ) scDensityInRZ(i,j) = norm*fSpaceChargeHistogramRZ->Interpolate(r,z) ;
 	  }
 	  // partial load in (r,phi)
 	  if ( (j==0 || j == kNZ/2) && fSpaceChargeHistogramRPhi) {
-	    if (z>0) 
+	    if (z>0)
 	      scDensityInRPhiA(i,k) = norm*fSpaceChargeHistogramRPhi->Interpolate(phi,r);  // A side
-	    else 
+	    else
 	      scDensityInRPhiC(i,k) = norm*fSpaceChargeHistogramRPhi->Interpolate(phi+TMath::TwoPi(),r); // C side
 	  }
-	  
-	  if (z>0) 
-	    scDensity(i,j) = norm*fSpaceChargeHistogram3D->Interpolate(phi,r,z); 
+
+	  if (z>0)
+	    scDensity(i,j) = norm*fSpaceChargeHistogram3D->Interpolate(phi,r,z);
 	  else
 	    scDensity(i,j) = norm*fSpaceChargeHistogram3D->Interpolate(phi,r,z);
 	}
       }
     }
   }
-  
+
   fInitLookUp = kFALSE;
 
 }
 
 
 Float_t  AliTPCSpaceCharge3D::GetSpaceChargeDensity(Float_t r, Float_t phi, Float_t z, Int_t mode) {
-  //
-  // returns the (input) space charge density at a given point according 
-  // Note: input in [cm], output in [C/m^3/e0] !!
-  //
+  /// returns the (input) space charge density at a given point according
+  /// Note: input in [cm], output in [C/m^3/e0] !!
 
   while (phi<0) phi += TMath::TwoPi();
   while (phi>TMath::TwoPi()) phi -= TMath::TwoPi();
@@ -1466,13 +1447,13 @@ Float_t  AliTPCSpaceCharge3D::GetSpaceChargeDensity(Float_t r, Float_t phi, Floa
   Float_t sc = 0;
 
   if (mode == 0) { // return full load
-    sc = Interpolate3DTable(order, r, z, phi, kNR, kNZ, kNPhi, 
+    sc = Interpolate3DTable(order, r, z, phi, kNR, kNZ, kNPhi,
 			    fgkRList, fgkZList, fgkPhiList, fSCdensityDistribution );
- 
+
   } else if (mode == 1) { // return partial load in (r,z)
     TMatrixD &scDensityInRZ   =  *fSCdensityInRZ;
     sc = Interpolate2DTable(order, r, z, kNR, kNZ, fgkRList, fgkZList, scDensityInRZ );
-    
+
   } else if (mode == 2) { // return partial load in (r,phi)
 
     if (z>0) {
@@ -1487,17 +1468,15 @@ Float_t  AliTPCSpaceCharge3D::GetSpaceChargeDensity(Float_t r, Float_t phi, Floa
     // should i give a warning?
     sc = 0;
   }
-  
+
   //  printf("%f %f %f: %f\n",r,phi,z,sc);
-  
+
   return sc;
 }
 
 
 TH2F * AliTPCSpaceCharge3D::CreateHistoSCinXY(Float_t z, Int_t nx, Int_t ny, Int_t mode) {
-  //
-  // return a simple histogramm containing the space charge distribution (input for the calculation)
-  //
+  /// return a simple histogramm containing the space charge distribution (input for the calculation)
 
   TH2F *h=CreateTH2F("spaceCharge",GetTitle(),"x [cm]","y [cm]","#rho_{sc} [C/m^{3}/e_{0}]",
 		     nx,-250.,250.,ny,-250.,250.);
@@ -1506,26 +1485,24 @@ TH2F * AliTPCSpaceCharge3D::CreateHistoSCinXY(Float_t z, Int_t nx, Int_t ny, Int
     Double_t yp = h->GetYaxis()->GetBinCenter(iy);
     for (Int_t ix=1;ix<=nx;++ix) {
       Double_t xp = h->GetXaxis()->GetBinCenter(ix);
-    
+
       Float_t r = TMath::Sqrt(xp*xp+yp*yp);
-      Float_t phi = TMath::ATan2(yp,xp); 
-   
+      Float_t phi = TMath::ATan2(yp,xp);
+
       if (85.<=r && r<=250.) {
 	Float_t sc = GetSpaceChargeDensity(r,phi,z,mode)/fgke0; // in [C/m^3/e0]
-	h->SetBinContent(ix,iy,sc); 
+	h->SetBinContent(ix,iy,sc);
       } else {
 	h->SetBinContent(ix,iy,0.);
       }
     }
   }
-  
+
   return h;
-} 
+}
 
 TH2F * AliTPCSpaceCharge3D::CreateHistoSCinZR(Float_t phi, Int_t nz, Int_t nr,Int_t mode ) {
-  //
-  // return a simple histogramm containing the space charge distribution (input for the calculation)
-  //
+  /// return a simple histogramm containing the space charge distribution (input for the calculation)
 
   TH2F *h=CreateTH2F("spaceCharge",GetTitle(),"z [cm]","r [cm]","#rho_{sc} [C/m^{3}/e_{0}]",
 		     nz,-250.,250.,nr,85.,250.);
@@ -1540,18 +1517,16 @@ TH2F * AliTPCSpaceCharge3D::CreateHistoSCinZR(Float_t phi, Int_t nz, Int_t nr,In
   }
 
   return h;
-} 
+}
 
 void AliTPCSpaceCharge3D::WriteChargeDistributionToFile(const char* fname) {
-  //
-  // Example on how to write a Space charge distribution into a File
-  //  (see below: estimate from scaling STAR measurements to Alice)
-  // Charge distribution is splitted into two (RZ and RPHI) in order to speed up
-  // the needed calculation time
-  //
+  /// Example on how to write a Space charge distribution into a File
+  ///  (see below: estimate from scaling STAR measurements to Alice)
+  /// Charge distribution is splitted into two (RZ and RPHI) in order to speed up
+  /// the needed calculation time
 
   TFile *f = new TFile(fname,"RECREATE");
-  
+
   // some grid, not too course
   Int_t nr = 350;
   Int_t nphi = 180;
@@ -1568,17 +1543,17 @@ void AliTPCSpaceCharge3D::WriteChargeDistributionToFile(const char* fname) {
   TH2F *histoZR = new TH2F("chargeZR","chargeZR",
 			   nr,fgkIFCRadius-dr-safty,fgkOFCRadius+dr+safty,
 			   nz,-250-dz-safty,250+dz+safty);
- 
+
   for (Int_t ir=1;ir<=nr;++ir) {
     Double_t rp = histoZR->GetXaxis()->GetBinCenter(ir);
     for (Int_t iz=1;iz<=nz;++iz) {
       Double_t zp = histoZR->GetYaxis()->GetBinCenter(iz);
-      
+
       // recalculation to meter
       Double_t lZ = 2.5; // approx. TPC drift length
       Double_t rpM = rp/100.; // in [m]
       Double_t zpM = TMath::Abs(zp/100.); // in [m]
-      
+
       // setting of mb multiplicity and Interaction rate
       Double_t multiplicity = 950;
       Double_t intRate = 7800;
@@ -1586,28 +1561,28 @@ void AliTPCSpaceCharge3D::WriteChargeDistributionToFile(const char* fname) {
       // calculation of "scaled" parameters
       Double_t a = multiplicity*intRate/79175;
       Double_t b = a/lZ;
-	
+
       Double_t charge = (a - b*zpM)/(rpM*rpM); // charge in [C/m^3/e0]
-	
+
       charge = charge*fgke0; // [C/m^3]
-	
+
       if (zp<0) charge *= 0.9; // e.g. slightly less on C side due to front absorber
 
       //  charge = 0; // for tests
-      histoZR->SetBinContent(ir,iz,charge); 
+      histoZR->SetBinContent(ir,iz,charge);
     }
   }
-    
+
   histoZR->Write("SpaceChargeInRZ");
-  
+
 
   // Charge distribution in RPhi (e.g. Floating GG wire) ------------
-  
+
   TH3F *histoRPhi = new TH3F("chargeRPhi","chargeRPhi",
 			     nr,fgkIFCRadius-dr-safty,fgkOFCRadius+dr+safty,
 			     nphi,0-dphi-safty,TMath::TwoPi()+dphi+safty,
 			     2,-1,1); // z part - to allow A and C side differences
-  
+
   // some 'arbitrary' GG leaks
   Int_t   nGGleaks = 5;
   Double_t secPosA[5]    = {3,6,6,11,13};         // sector
@@ -1621,31 +1596,31 @@ void AliTPCSpaceCharge3D::WriteChargeDistributionToFile(const char* fname) {
       Double_t phip = histoRPhi->GetYaxis()->GetBinCenter(iphi);
       for (Int_t iz=1;iz<=2;++iz) {
 	Double_t zp = histoRPhi->GetZaxis()->GetBinCenter(iz);
-	
+
 	Double_t charge = 0;
-	
+
 	for (Int_t igg = 0; igg<nGGleaks; igg++) { // loop over GG leaks
-	  
+
 	  // A side
-	  Double_t secPos = secPosA[igg]; 
+	  Double_t secPos = secPosA[igg];
 	  Double_t radialPos = radialPosA[igg];
 
 	  if (zp<0) { // C side
-	    secPos = secPosC[igg]; 
+	    secPos = secPosC[igg];
 	    radialPos = radialPosC[igg];
-	  }	    
+	  }
 
 	  // some 'arbitrary' GG leaks
 	  if (  (phip<(TMath::Pi()/9*(secPos+1)) && phip>(TMath::Pi()/9*secPos) ) ) { // sector slice
 	    if ( rp>(radialPos-2.5) && rp<(radialPos+2.5))  // 5 cm slice
-	      charge = 300; 
+	      charge = 300;
 	  }
-	  
-	}		
-	
+
+	}
+
 	charge = charge*fgke0; // [C/m^3]
 
-	histoRPhi->SetBinContent(ir,iphi,iz,charge); 
+	histoRPhi->SetBinContent(ir,iphi,iz,charge);
       }
     }
   }
@@ -1653,15 +1628,13 @@ void AliTPCSpaceCharge3D::WriteChargeDistributionToFile(const char* fname) {
   histoRPhi->Write("SpaceChargeInRPhi");
 
   f->Close();
-  
+
 }
 
 
 void AliTPCSpaceCharge3D::Print(const Option_t* option) const {
-  //
-  // Print function to check the settings of the boundary vectors
-  // option=="a" prints the C0 and C1 coefficents for calibration purposes
-  //
+  /// Print function to check the settings of the boundary vectors
+  /// option=="a" prints the C0 and C1 coefficents for calibration purposes
 
   TString opt = option; opt.ToLower();
   printf("%s\n",GetTitle());
@@ -1671,33 +1644,32 @@ void AliTPCSpaceCharge3D::Print(const Option_t* option) const {
   if (opt.Contains("a")) { // Print all details
     printf(" - T1: %1.4f, T2: %1.4f \n",fT1,fT2);
     printf(" - C1: %1.4f, C0: %1.4f \n",fC1,fC0);
-  } 
-   
+  }
+
   if (!fInitLookUp) AliError("Lookup table was not initialized! You should do InitSpaceCharge3DDistortion() ...");
 
-} 
+}
 
 
 
 void AliTPCSpaceCharge3D::InitSpaceCharge3DPoisson(Int_t kRows, Int_t kColumns, Int_t kPhiSlices, Int_t kIterations){
+  /// MI extension  - calculate E field
+  /// - inspired by  AliTPCROCVoltError3D::InitROCVoltError3D()
+  /// Initialization of the Lookup table which contains the solutions of the
+  /// Dirichlet boundary problem
+  /// Calculation of the single 3D-Poisson solver is done just if needed
+  /// (see basic lookup tables in header file)
+
+  Int_t kPhiSlicesPerSector = kPhiSlices/18;
   //
-  // MI extension  - calculate E field
-  //               - inspired by  AliTPCROCVoltError3D::InitROCVoltError3D()
-  // Initialization of the Lookup table which contains the solutions of the 
-  // Dirichlet boundary problem
-  // Calculation of the single 3D-Poisson solver is done just if needed
-  // (see basic lookup tables in header file)
-  //  
-  Int_t kPhiSlicesPerSector = kPhiSlices/18; 
-  //
-  const Int_t   order       =    1  ;  // Linear interpolation = 1, Quadratic = 2  
+  const Int_t   order       =    1  ;  // Linear interpolation = 1, Quadratic = 2
   const Float_t gridSizeR   =  (fgkOFCRadius-fgkIFCRadius) / (kRows-1) ;
   const Float_t gridSizeZ   =  fgkTPCZ0 / (kColumns-1) ;
   const Float_t gridSizePhi =  TMath::TwoPi() / ( 18.0 * kPhiSlicesPerSector);
 
   // temporary arrays to create the boundary conditions
-  TMatrixD *arrayofArrayV[kPhiSlices], *arrayofCharge[kPhiSlices] ; 
-  TMatrixD *arrayofEroverEz[kPhiSlices], *arrayofEphioverEz[kPhiSlices], *arrayofDeltaEz[kPhiSlices] ; 
+  TMatrixD *arrayofArrayV[kPhiSlices], *arrayofCharge[kPhiSlices] ;
+  TMatrixD *arrayofEroverEz[kPhiSlices], *arrayofEphioverEz[kPhiSlices], *arrayofDeltaEz[kPhiSlices] ;
 
   for ( Int_t k = 0 ; k < kPhiSlices ; k++ ) {
     arrayofArrayV[k]     =   new TMatrixD(kRows,kColumns) ;
@@ -1706,7 +1678,7 @@ void AliTPCSpaceCharge3D::InitSpaceCharge3DPoisson(Int_t kRows, Int_t kColumns,
     arrayofEphioverEz[k] =   new TMatrixD(kRows,kColumns) ;
     arrayofDeltaEz[k]    =   new TMatrixD(kRows,kColumns) ;
   }
-  
+
   // list of point as used in the poisson relation and the interpolation (during sum up)
   Double_t  rlist[kRows], zedlist[kColumns] , philist[kPhiSlices];
   for ( Int_t k = 0 ; k < kPhiSlices ; k++ ) {
@@ -1722,30 +1694,30 @@ void AliTPCSpaceCharge3D::InitSpaceCharge3DPoisson(Int_t kRows, Int_t kColumns,
   // ==========================================================================
   // Solve Poisson's equation in 3D cylindrical coordinates by relaxation technique
   // Allow for different size grid spacing in R and Z directions
-  
+
   const Int_t   symmetry = 0;
- 
+
   // Set bondaries and solve Poisson's equation --------------------------
-  
+
   if ( !fInitLookUp ) {
-    
+
     AliInfo(Form("Solving the poisson equation (~ %d sec)",2*10*(int)(kPhiSlices/10)));
-    
+
     for ( Int_t side = 0 ; side < 2 ; side++ ) {  // Solve Poisson3D twice; once for +Z and once for -Z
       AliSysInfo::AddStamp("RunSide", 1,side,0);
       for ( Int_t k = 0 ; k < kPhiSlices ; k++ )  {
 	TMatrixD &arrayV    =  *arrayofArrayV[k] ;
 	TMatrixD &charge    =  *arrayofCharge[k] ;
-	
+
 	//Fill arrays with initial conditions.  V on the boundary and Charge in the volume.
 // 	for ( Int_t i = 0 ; i < kRows ; i++ ) {
 // 	  for ( Int_t j = 0 ; j < kColumns ; j++ ) {  // Fill Vmatrix with Boundary Conditions
-// 	    arrayV(i,j) = 0.0 ; 
+// 	    arrayV(i,j) = 0.0 ;
 // 	    charge(i,j) = 0.0 ;
 
 // // 	    Float_t radius0 = rlist[i] ;
 // // 	    Float_t phi0    = gridSizePhi * k ;
-	    
+
 // 	    // To avoid problems at sector boundaries, use an average of +- 1 degree from actual phi location
 // // 	    if ( j == (kColumns-1) ) {
 // // 	      arrayV(i,j) = 0.5*  ( GetROCVoltOffset( side, radius0, phi0+0.02 ) + GetROCVoltOffset( side, radius0, phi0-0.02 ) ) ;
@@ -1754,54 +1726,54 @@ void AliTPCSpaceCharge3D::InitSpaceCharge3DPoisson(Int_t kRows, Int_t kColumns,
 // // 		arrayV(i,j) = -arrayV(i,j); // minus sign on the C side to allow a consistent usage of global z when setting the boundaries
 // // 	    }
 // 	  }
-// 	}      
-	
-	for ( Int_t i = 1 ; i < kRows-1 ; i++ ) { 
-	  for ( Int_t j = 1 ; j < kColumns-1 ; j++ ) {	    
+// 	}
+
+	for ( Int_t i = 1 ; i < kRows-1 ; i++ ) {
+	  for ( Int_t j = 1 ; j < kColumns-1 ; j++ ) {
 	    Float_t radius0 = rlist[i] ;
 	    Float_t phi0    = gridSizePhi * k ;
 	    Double_t z0 = zedlist[j];
 	    if (side==1) z0= -TMath::Abs(zedlist[j]);
-	    arrayV(i,j) = 0.0 ; 
+	    arrayV(i,j) = 0.0 ;
 	    charge(i,j)  =  fSpaceChargeHistogram3D->Interpolate(phi0,radius0,z0);
 	  }
 	}
-      }      
+      }
       AliSysInfo::AddStamp("RunPoisson", 2,side,0);
-      
+
       // Solve Poisson's equation in 3D cylindrical coordinates by relaxation technique
       // Allow for different size grid spacing in R and Z directions
-      
-      //      PoissonRelaxation3D( arrayofArrayV, arrayofCharge, 
+
+      //      PoissonRelaxation3D( arrayofArrayV, arrayofCharge,
       // 			   arrayofEroverEz, arrayofEphioverEz, arrayofDeltaEz,
-      // 			   kRows, kColumns, kPhiSlices, gridSizePhi, kIterations, 
+      // 			   kRows, kColumns, kPhiSlices, gridSizePhi, kIterations,
       // 			   symmetry , fROCdisplacement) ;
-      PoissonRelaxation3D( arrayofArrayV, arrayofCharge, 
+      PoissonRelaxation3D( arrayofArrayV, arrayofCharge,
 			   arrayofEroverEz, arrayofEphioverEz, arrayofDeltaEz,
-			   kRows, kColumns, kPhiSlices, gridSizePhi, kIterations, 
+			   kRows, kColumns, kPhiSlices, gridSizePhi, kIterations,
 			   symmetry ) ;
-      
+
       //Interpolate results onto a custom grid which is used just for these calculations.
       Double_t  r, phi, z ;
       for ( Int_t k = 0 ; k < kNPhi ; k++ ) {
 	phi = fgkPhiList[k] ;
-	
+
 	TMatrixF &erOverEz   =  *fLookUpErOverEz[k]  ;
 	TMatrixF &ephiOverEz =  *fLookUpEphiOverEz[k];
 	TMatrixF &deltaEz    =  *fLookUpDeltaEz[k]   ;
-	
+
 	for ( Int_t j = 0 ; j < kNZ ; j++ ) {
 
 	  z = TMath::Abs(fgkZList[j]) ;  // Symmetric solution in Z that depends only on ABS(Z)
-  
+
 	  if ( side == 0 &&  fgkZList[j] < 0 ) continue; // Skip rest of this loop if on the wrong side
 	  if ( side == 1 &&  fgkZList[j] > 0 ) continue; // Skip rest of this loop if on the wrong side
-	  
-	  for ( Int_t i = 0 ; i < kNR ; i++ ) { 
+
+	  for ( Int_t i = 0 ; i < kNR ; i++ ) {
 	    r = fgkRList[i] ;
 
 	    // Interpolate basicLookup tables; once for each rod, then sum the results
-	    erOverEz(i,j)   = Interpolate3DTable(order, r, z, phi, kRows, kColumns, kPhiSlices, 
+	    erOverEz(i,j)   = Interpolate3DTable(order, r, z, phi, kRows, kColumns, kPhiSlices,
 						 rlist, zedlist, philist, arrayofEroverEz  );
 	    ephiOverEz(i,j) = Interpolate3DTable(order, r, z, phi, kRows, kColumns, kPhiSlices,
 						 rlist, zedlist, philist, arrayofEphioverEz);
@@ -1813,21 +1785,21 @@ void AliTPCSpaceCharge3D::InitSpaceCharge3DPoisson(Int_t kRows, Int_t kColumns,
 	  } // end r loop
 	}// end z loop
       }// end phi loop
-      AliSysInfo::AddStamp("Interpolate Poisson", 3,side,0);      
+      AliSysInfo::AddStamp("Interpolate Poisson", 3,side,0);
       if ( side == 0 ) AliInfo(" A side done");
       if ( side == 1 ) AliInfo(" C side done");
     } // end side loop
   }
-  
+
   // clear the temporary arrays lists
   for ( Int_t k = 0 ; k < kPhiSlices ; k++ )  {
     delete arrayofArrayV[k];
     delete arrayofCharge[k];
-    delete arrayofEroverEz[k];  
+    delete arrayofEroverEz[k];
     delete arrayofEphioverEz[k];
     delete arrayofDeltaEz[k];
   }
- 
+
 
   fInitLookUp = kTRUE;
 
@@ -1836,31 +1808,29 @@ void AliTPCSpaceCharge3D::InitSpaceCharge3DPoisson(Int_t kRows, Int_t kColumns,
 
 
 AliTPCSpaceCharge3D * AliTPCSpaceCharge3D::MakeCorrection22D(const char* fileName, Double_t multiplicity, Double_t intRate, Double_t epsIROC, Double_t epsOROC,
-							     Double_t gasfactor, 
+							     Double_t gasfactor,
 							     Double_t radialScaling){
-  //
-  // Origin: Christian Lippmann, CERN, Christian.Lippmann@cern.ch based on the internal note (xxx ...)
-  // adopted by Marian Ivanov (different epsilon in IROC and OROC)
-  //
-  // Charge distribution is splitted into two (RZ and RPHI) in order to speed up
-  // the needed calculation time.  
-  //
-  // Explanation of variables:
-  // 1) multiplicity: charghed particle dn/deta for top 80% centrality (660 for 2011,
-  //    expect 950 for full energy)
-  // 2) intRate: Total interaction rate (e.g. 50kHz for the upgrade)
-  // 3) eps: Number of backdrifting ions per primary electron (0 for MWPC, e.g.10 for GEM)
-  // 4) gasfactor: Use different gas. E.g. Ar/CO2 has twice the primary ionization, ion drift
-  //    velocity factor 2.5 slower, so  gasfactor = 5.
-  //
-
-
-  TFile *f = new TFile(fileName, "RECREATE");  
+  /// Origin: Christian Lippmann, CERN, Christian.Lippmann@cern.ch based on the internal note (xxx ...)
+  /// adopted by Marian Ivanov (different epsilon in IROC and OROC)
+  ///
+  /// Charge distribution is splitted into two (RZ and RPHI) in order to speed up
+  /// the needed calculation time.
+  ///
+  /// Explanation of variables:
+  /// 1) multiplicity: charghed particle dn/deta for top 80% centrality (660 for 2011,
+  ///    expect 950 for full energy)
+  /// 2) intRate: Total interaction rate (e.g. 50kHz for the upgrade)
+  /// 3) eps: Number of backdrifting ions per primary electron (0 for MWPC, e.g.10 for GEM)
+  /// 4) gasfactor: Use different gas. E.g. Ar/CO2 has twice the primary ionization, ion drift
+  ///    velocity factor 2.5 slower, so  gasfactor = 5.
+
+
+  TFile *f = new TFile(fileName, "RECREATE");
   // some grid, not too coarse
   const Int_t nr   = 350;
   const Int_t nphi = 180;
   const Int_t nz   = 500;
-  const Double_t kROROC=134;  // hardwired OROC radius 
+  const Double_t kROROC=134;  // hardwired OROC radius
 
   Double_t dr = (fgkOFCRadius-fgkIFCRadius)/(nr+1);
   Double_t dphi = TMath::TwoPi()/(nphi+1);
@@ -1878,41 +1848,41 @@ AliTPCSpaceCharge3D * AliTPCSpaceCharge3D::MakeCorrection22D(const char* fileNam
   Double_t radialExponent             = -2.; // reference = 2
   Double_t radiusInner                = histoZR->GetXaxis()->GetBinCenter(1) / 100.;//in [m]
   Double_t radiusOuter                = histoZR->GetXaxis()->GetBinCenter(nr) / 100.;//in [m]
-  Double_t integralRadialExponent2    = TMath::Power(radiusOuter,radialExponent+1) * 1./(radialExponent+1) 
+  Double_t integralRadialExponent2    = TMath::Power(radiusOuter,radialExponent+1) * 1./(radialExponent+1)
     - TMath::Power(radiusInner,radialExponent+1) * 1./(radialExponent+1);
-  
-  radialExponent                      = -radialScaling; // user set   
+
+  radialExponent                      = -radialScaling; // user set
   Double_t integralRadialExponentUser = 0.;
   if(radialScaling > 1 + 0.000001 || radialScaling < 1 - 0.000001 ) // to avoid n = -1
-    integralRadialExponentUser = TMath::Power(radiusOuter,radialExponent+1) * 1./(radialExponent+1) 
+    integralRadialExponentUser = TMath::Power(radiusOuter,radialExponent+1) * 1./(radialExponent+1)
       - TMath::Power(radiusInner,radialExponent+1) * 1./(radialExponent+1);
   else
     integralRadialExponentUser = TMath::Log(radiusOuter) - TMath::Log(radiusInner);
-    
+
   Double_t normRadialExponent         = integralRadialExponent2 / integralRadialExponentUser;
- 
+
   for (Int_t ir=1;ir<=nr;++ir) {
     Double_t rp = histoZR->GetXaxis()->GetBinCenter(ir);
     for (Int_t iz=1;iz<=nz;++iz) {
       Double_t zp = histoZR->GetYaxis()->GetBinCenter(iz);
-      Double_t eps = (rp <kROROC) ? epsIROC:epsOROC; 
+      Double_t eps = (rp <kROROC) ? epsIROC:epsOROC;
       // recalculation to meter
       Double_t lZ = 2.5; // approx. TPC drift length
       Double_t rpM = rp/100.; // in [m]
       Double_t zpM = TMath::Abs(zp/100.); // in [m]
- 
+
       // calculation of "scaled" parameters
       Double_t a = multiplicity*intRate/76628;
       //Double_t charge = gasfactor * ( a / (rpM*rpM) * (1 - zpM/lZ) ); // charge in [C/m^3/e0], no IBF
       Double_t charge = normRadialExponent * gasfactor * ( a / (TMath::Power(rpM,radialScaling)) * (1 - zpM/lZ + eps) ); // charge in [C/m^3/e0], with IBF
-      
+
       charge = charge*fgke0;          // [C/m^3]
       if (zp<0) charge *= 0.9; // Slightly less on C side due to front absorber
 
-      histoZR->SetBinContent(ir, iz, charge); 
+      histoZR->SetBinContent(ir, iz, charge);
     }
   }
-    
+
   histoZR->Write("SpaceChargeInRZ");
   //
   // Charge distribution in RPhi (e.g. Floating GG wire) ------------
@@ -1920,7 +1890,7 @@ AliTPCSpaceCharge3D * AliTPCSpaceCharge3D::MakeCorrection22D(const char* fileNam
   TH3F *histoRPhi = new TH3F("chargeRPhi", "chargeRPhi",
                              nr, fgkIFCRadius-dr-safty, fgkOFCRadius+dr+safty,
                              nphi, 0-dphi-safty, TMath::TwoPi()+dphi+safty,
-                             2, -1, 1); // z part - to allow A and C side differences  
+                             2, -1, 1); // z part - to allow A and C side differences
   histoRPhi->Write("SpaceChargeInRPhi");
   f->Close();
   //
diff --git a/TPC/TPCbase/AliTPCSpaceCharge3D.h b/TPC/TPCbase/AliTPCSpaceCharge3D.h
index 976115cb9d7..20542001c49 100644
--- a/TPC/TPCbase/AliTPCSpaceCharge3D.h
+++ b/TPC/TPCbase/AliTPCSpaceCharge3D.h
@@ -4,10 +4,8 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-////////////////////////////////////////////////////////////////////////////
-// AliTPCSpaceCharge3D class                                              //
-// Authors: Stefan Rossegger                                              //
-////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCSpaceCharge3D
+/// \author Stefan Rossegger
 
 #include "AliTPCCorrection.h"
 class TH3F;
@@ -58,51 +56,53 @@ public:
   void    SetInputSpaceCharge(TH3 * hisSpaceCharge3D, TH2 * hisRPhi, TH2* hisRZ, Double_t norm);
   void    SetInputSpaceCharge3D(TH3 * hisSpaceCharge3D){fSpaceChargeHistogram3D= hisSpaceCharge3D;}
 
-  const TH3 *   GetInputSpaceCharge3D(){return fSpaceChargeHistogram3D;}       // MI add 
-  const TH2 *   GetInputSpaceChargeRPhi(){return fSpaceChargeHistogramRPhi;}       // MI add 
-  const TH2 *   GetInputSpaceChargeRZ(){return fSpaceChargeHistogramRZ;}       // MI add 
+  const TH3 *   GetInputSpaceCharge3D(){return fSpaceChargeHistogram3D;}       // MI add
+  const TH2 *   GetInputSpaceChargeRPhi(){return fSpaceChargeHistogramRPhi;}       // MI add
+  const TH2 *   GetInputSpaceChargeRZ(){return fSpaceChargeHistogramRZ;}       // MI add
 
   virtual void GetCorrection(const Float_t x[],const Short_t roc,Float_t dx[]);
 
   static AliTPCSpaceCharge3D *MakeCorrection22D(const char * filename = "SpaceChargeMap.root", Double_t multiplicity = 950., Double_t intRate = 5e4, Double_t epsIROC = 10., Double_t epsOROC=10,
-						Double_t gasfactor = 1., 
+						Double_t gasfactor = 1.,
 						Double_t radialScaling = 1.5);
 private:
 
   // maximum sizes of lookup tables
-  enum {kNRows= 90 };       // the maximum on row-slices so far ~ 2cm slicing    
-  enum {kNPhiSlices= 144 }; // the maximum of phi-slices so far = (8 per sector) 
-  enum {kNColumns= 130 };   // the maximum on column-slices so  ~ 2cm slicing    
+  enum {kNRows= 90 };       // the maximum on row-slices so far ~ 2cm slicing
+  enum {kNPhiSlices= 144 }; // the maximum of phi-slices so far = (8 per sector)
+  enum {kNColumns= 130 };   // the maximum on column-slices so  ~ 2cm slicing
 
   AliTPCSpaceCharge3D(const AliTPCSpaceCharge3D &);               // not implemented
   AliTPCSpaceCharge3D &operator=(const AliTPCSpaceCharge3D &);    // not implemented
 
-  Float_t fC0; // coefficient C0                 (compare Jim Thomas's notes for definitions)
-  Float_t fC1; // coefficient C1                 (compare Jim Thomas's notes for definitions)
-  Float_t fCorrectionFactor;       // Space Charge Correction factor in comparison to initialized
+  Float_t fC0; ///< coefficient C0                 (compare Jim Thomas's notes for definitions)
+  Float_t fC1; ///< coefficient C1                 (compare Jim Thomas's notes for definitions)
+  Float_t fCorrectionFactor;       ///< Space Charge Correction factor in comparison to initialized
                                    // look up table which was created for M_mb = 900 and IR = 3000
                                    // compare Internal Note Nr: ???
 
-  Bool_t fInitLookUp;                 // flag to check if the Look Up table was created
+  Bool_t fInitLookUp;                 ///< flag to check if the Look Up table was created
 
-  TMatrixF *fLookUpErOverEz[kNPhi];   // Array to store electric field integral (int Er/Ez)
-  TMatrixF *fLookUpEphiOverEz[kNPhi]; // Array to store electric field integral (int Er/Ez)
-  TMatrixF *fLookUpDeltaEz[kNPhi];    // Array to store electric field integral (int Er/Ez)
+  TMatrixF *fLookUpErOverEz[kNPhi];   ///< Array to store electric field integral (int Er/Ez)
+  TMatrixF *fLookUpEphiOverEz[kNPhi]; ///< Array to store electric field integral (int Er/Ez)
+  TMatrixF *fLookUpDeltaEz[kNPhi];    ///< Array to store electric field integral (int Er/Ez)
 
-  TString fSCDataFileName;          // file which contains the space charge distribution
-  TString fSCLookUpPOCsFileName3D;  // filename of the precalculated lookup tables (for individual voxels)
-  TString fSCLookUpPOCsFileNameRZ;  // filename of the precalculated lookup tables (for individual voxels)
-  TString fSCLookUpPOCsFileNameRPhi;  // filename of the precalculated lookup tables (for individual voxels)
+  TString fSCDataFileName;          ///< file which contains the space charge distribution
+  TString fSCLookUpPOCsFileName3D;  ///< filename of the precalculated lookup tables (for individual voxels)
+  TString fSCLookUpPOCsFileNameRZ;  ///< filename of the precalculated lookup tables (for individual voxels)
+  TString fSCLookUpPOCsFileNameRPhi;  ///< filename of the precalculated lookup tables (for individual voxels)
 
 
-  TMatrixF *fSCdensityDistribution[kNPhi]; // 3D space charge distribution
-  TMatrixD *fSCdensityInRZ;       // (r,z) space charge distribution
-  TMatrixD *fSCdensityInRPhiA;     // (r,phi) space charge distribution
-  TMatrixD *fSCdensityInRPhiC;     // (r,phi) space charge distribution
-  TH3 *    fSpaceChargeHistogram3D;      // Histogram with the input space charge histogram - used as an optional input 
-  TH2 *    fSpaceChargeHistogramRPhi;      // Histogram with the input space charge histogram - used as an optional input 
-  TH2 *    fSpaceChargeHistogramRZ;      // Histogram with the input space charge histogram - used as an optional input 
-  ClassDef(AliTPCSpaceCharge3D,2); 
+  TMatrixF *fSCdensityDistribution[kNPhi]; ///< 3D space charge distribution
+  TMatrixD *fSCdensityInRZ;       ///< (r,z) space charge distribution
+  TMatrixD *fSCdensityInRPhiA;     ///< (r,phi) space charge distribution
+  TMatrixD *fSCdensityInRPhiC;     ///< (r,phi) space charge distribution
+  TH3 *    fSpaceChargeHistogram3D;      ///< Histogram with the input space charge histogram - used as an optional input
+  TH2 *    fSpaceChargeHistogramRPhi;      ///< Histogram with the input space charge histogram - used as an optional input
+  TH2 *    fSpaceChargeHistogramRZ;      ///< Histogram with the input space charge histogram - used as an optional input
+  /// \cond CLASSIMP
+  ClassDef(AliTPCSpaceCharge3D,2);
+  /// \endcond
 };
 
 #endif
diff --git a/TPC/TPCbase/AliTPCTempMap.cxx b/TPC/TPCbase/AliTPCTempMap.cxx
index e3e32b5cbb7..58c6117dee3 100644
--- a/TPC/TPCbase/AliTPCTempMap.cxx
+++ b/TPC/TPCbase/AliTPCTempMap.cxx
@@ -14,16 +14,14 @@
  **************************************************************************/
 
 
-///////////////////////////////////////////////////////////////////////////////
-//                                                                           //
-//  TPC calibration class for temperature maps and tendencies                //
-//  (based on TPC Temperature Sensors and FiniteElement Simulation)          //
-//                                                                           //
-//  Authors: Stefan Rossegger, Haavard Helstrup                              //
-//                                                                           //
-//  Note: Obvioulsy some changes by Marian, but when ???                     //
-//                                                                           //
-///////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCTempMap
+/// \brief TPC calibration class for temperature maps and tendencies
+///
+/// (based on TPC Temperature Sensors and FiniteElement Simulation)
+///
+/// Note: Obvioulsy some changes by Marian, but when ???
+///
+/// \author Stefan Rossegger, Haavard Helstrup
 
 #include "AliTPCSensorTempArray.h"
 #include "TLinearFitter.h"
@@ -34,8 +32,10 @@
 #include "AliTPCTempMap.h"
 
 
+/// \cond CLASSIMP
 ClassImp(AliTPCTempMap)
-  
+/// \endcond
+
   const char kStringFEsimulation[] = "FEsimulation.txt";
 
 //_____________________________________________________________________________
@@ -44,9 +44,7 @@ AliTPCTempMap::AliTPCTempMap(AliTPCSensorTempArray *sensorDCS):
   fTempArray(0),
   fStringFEsimulation(kStringFEsimulation)
 {
-  //
-  // AliTPCTempMap default constructor
-  //
+  /// AliTPCTempMap default constructor
 
   fTempArray = sensorDCS;
 
@@ -58,27 +56,21 @@ AliTPCTempMap::AliTPCTempMap(const AliTPCTempMap &c):
   fTempArray(c.fTempArray),
   fStringFEsimulation(c.fStringFEsimulation)
 {
-  //
-  // AliTPCTempMap copy constructor
-  //
+  /// AliTPCTempMap copy constructor
 
 }
 
 //_____________________________________________________________________________
 AliTPCTempMap::~AliTPCTempMap()
 {
-  //
-  // AliTPCTempMap destructor
-  //
-  
+  /// AliTPCTempMap destructor
+
 }
 
 //_____________________________________________________________________________
 AliTPCTempMap &AliTPCTempMap::operator=(const AliTPCTempMap &c)
 {
-  //
-  // Assignment operator
-  //
+  /// Assignment operator
 
   if (this != &c) ((AliTPCTempMap &) c).Copy(*this);
   return *this;
@@ -88,27 +80,24 @@ AliTPCTempMap &AliTPCTempMap::operator=(const AliTPCTempMap &c)
 //_____________________________________________________________________________
 void AliTPCTempMap::Copy(TObject &c) const
 {
-  //
-  // Copy function
-  //
-  
+  /// Copy function
+
   TObject::Copy(c);
-  
+
 }
 
 //_____________________________________________________________________________
 
 Double_t AliTPCTempMap::GetTempGradientY(UInt_t timeSec, Int_t side){
- //
- // Extract Linear Vertical Temperature Gradient [K/cm] within the TPC on 
- // Shaft Side(A): 0
- // Muon  Side(C): 1
- // Values based on TemperatureSensors within the TPC ( type: 3 (TPC) )
- //
- // FIXME: Also return residual-distribution, covariance Matrix
- //        or simply chi2 for validity check? 
- //        -> better use GetLinearFitter - function in this case!
-  
+ /// Extract Linear Vertical Temperature Gradient [K/cm] within the TPC on
+ /// Shaft Side(A): 0
+ /// Muon  Side(C): 1
+ /// Values based on TemperatureSensors within the TPC ( type: 3 (TPC) )
+ ///
+ /// FIXME: Also return residual-distribution, covariance Matrix
+ ///        or simply chi2 for validity check?
+ ///        -> better use GetLinearFitter - function in this case!
+
  TLinearFitter *fitter = new TLinearFitter(3,"x0++x1++x2");
  TVectorD param(3);
  Int_t i = 0;
@@ -116,34 +105,33 @@ Double_t AliTPCTempMap::GetTempGradientY(UInt_t timeSec, Int_t side){
  Int_t nsensors = fTempArray->NumSensors();
  for (Int_t isensor=0; isensor<nsensors; isensor++) { // loop over all sensors
    AliTPCSensorTemp *entry = (AliTPCSensorTemp*)fTempArray->GetSensorNum(isensor);
-   
-   if (entry->GetType()==3 && entry->GetSide()==side) { // take SensorType:TPC 
+
+   if (entry->GetType()==3 && entry->GetSide()==side) { // take SensorType:TPC
      Double_t x[3];
      x[0]=1;
      x[1]=entry->GetX();
-     x[2]=entry->GetY();    
+     x[2]=entry->GetY();
      Double_t y = fTempArray->GetValue(timeSec,isensor); // get temperature value
      if (IsOK(y)) fitter->AddPoint(x,y,1); // add values to LinearFitter
      i++;
    }
 
- }  
+ }
  fitter->Eval();
  fitter->GetParameters(param);
 
  fitter->~TLinearFitter();
 
  return param[2]; // return vertical (Y) tempGradient in [K/cm]
-  
+
 }
 
 //_____________________________________________________________________________
 TLinearFitter *AliTPCTempMap::GetLinearFitter(Int_t type, Int_t side, TTimeStamp &stamp)
 {
-  //
-  // absolute time stamp used
-  // see AliTPCTempMap::GetLinearFitter(Int_t type, Int_t side, UInt_t timeSec) for details
-  //
+  /// absolute time stamp used
+  /// see AliTPCTempMap::GetLinearFitter(Int_t type, Int_t side, UInt_t timeSec) for details
+
   Int_t timeSec = stamp.GetSec()-fTempArray->GetStartTime().GetSec();
   return GetLinearFitter(type,side,timeSec);
 }
@@ -151,26 +139,24 @@ TLinearFitter *AliTPCTempMap::GetLinearFitter(Int_t type, Int_t side, TTimeStamp
 //_____________________________________________________________________________
 TLinearFitter *AliTPCTempMap::GetLinearFitter(Int_t type, Int_t side, UInt_t timeSec)
 {
-  // 
-  // Creates a TlinearFitter object for the desired region of the TPC 
-  // (via choosen type and side of TPC temperature sensors) at a given 
-  // timeSec (in secounds) after start time
-  // type: 0 ... ReadOutChambers (ROC)
-  //       1 ... OuterContainmentVessel (OFC)
-  //       2 ... InnerContainmentVessel (IFC) + ThermalScreener (TS)
-  //       3 ... Within the TPC (DriftVolume) (TPC)
-  //       4 ... Only InnerContainmentVessel (IFC) 
-  // side: Can be choosen for type 0 and 3 (otherwise it will be ignored in 
-  //       in order to get all temperature sensors of interest)
-  //       0 ... Shaft Side (A)
-  //       1 ... Muon Side (C)
-  // 
+  /// Creates a TlinearFitter object for the desired region of the TPC
+  /// (via choosen type and side of TPC temperature sensors) at a given
+  /// timeSec (in secounds) after start time
+  /// type: 0 ... ReadOutChambers (ROC)
+  ///       1 ... OuterContainmentVessel (OFC)
+  ///       2 ... InnerContainmentVessel (IFC) + ThermalScreener (TS)
+  ///       3 ... Within the TPC (DriftVolume) (TPC)
+  ///       4 ... Only InnerContainmentVessel (IFC)
+  /// side: Can be choosen for type 0 and 3 (otherwise it will be ignored in
+  ///       in order to get all temperature sensors of interest)
+  ///       0 ... Shaft Side (A)
+  ///       1 ... Muon Side (C)
 
   TLinearFitter *fitter = new TLinearFitter(3);
   Double_t x[3]={0};
   Double_t y = 0;
   const Float_t kMaxDelta=0.5;
-  
+
   if (type == 1 || type == 2 || type == 4) {
     fitter->SetFormula("x0++x1++TMath::Sin(x2)"); // returns Z,Y gradient
   } else {
@@ -191,17 +177,17 @@ TLinearFitter *AliTPCTempMap::GetLinearFitter(Int_t type, Int_t side, UInt_t tim
   Float_t medianTemp = TMath::Median(i, temps);
   if (i<3) return 0;
   Float_t rmsTemp = TMath::RMS(i, temps);
-  
+
   i=0;
-  
+
   for (Int_t isensor=0; isensor<nsensors; isensor++) { // loop over all sensors
     AliTPCSensorTemp *entry = (AliTPCSensorTemp*)fTempArray->GetSensorNum(isensor);
-    
+
     if (type==0 || type==3) { // 'side' information used
       if (entry->GetType()==type && entry->GetSide()==side) {
 	x[0]=1;
 	x[1]=entry->GetX();
-	x[2]=entry->GetY();    
+	x[2]=entry->GetY();
 	y = fTempArray->GetValue(timeSec,isensor); // get temperature value
 	if (TMath::Abs(y-medianTemp)>kMaxDelta+4.*rmsTemp) continue;
 	if (IsOK(y)) fitter->AddPoint(x,y,1); // add values to LinearFitter
@@ -211,70 +197,68 @@ TLinearFitter *AliTPCTempMap::GetLinearFitter(Int_t type, Int_t side, UInt_t tim
       if ((entry->GetType()==2) || (entry->GetType()==5)) {
 	x[0]=1;
 	x[1]=entry->GetZ();
-	x[2]=entry->GetPhi();    
+	x[2]=entry->GetPhi();
 	y = fTempArray->GetValue(timeSec,isensor);
 	if (TMath::Abs(y-medianTemp)>kMaxDelta+4.*rmsTemp) continue;
-	if (IsOK(y)) fitter->AddPoint(x,y,1); 
+	if (IsOK(y)) fitter->AddPoint(x,y,1);
 	i++;
       }
     } else if (type==1){
       if (entry->GetType()==type) {
 	x[0]=1;
 	x[1]=entry->GetZ();
-	x[2]=entry->GetPhi();    
+	x[2]=entry->GetPhi();
 	y = fTempArray->GetValue(timeSec,isensor);
 	if (TMath::Abs(y-medianTemp)>kMaxDelta+4.*rmsTemp) continue;
 	if (IsOK(y)) fitter->AddPoint(x,y,1);
-	i++;	
+	i++;
       }
     } else if (type==4) { // ONLY IFC
       if (entry->GetType()==2) {
 	x[0]=1;
 	x[1]=entry->GetZ();
-	x[2]=entry->GetPhi();    
+	x[2]=entry->GetPhi();
 	y = fTempArray->GetValue(timeSec,isensor);
 	if (TMath::Abs(y-medianTemp)>kMaxDelta+4.*rmsTemp) continue;
-	if (IsOK(y)) fitter->AddPoint(x,y,1); 
+	if (IsOK(y)) fitter->AddPoint(x,y,1);
 	i++;
       }
     }
-  }  
+  }
   fitter->Eval();
   //fitter->EvalRobust(0.9); // Evaluates fitter
-  
 
-  return fitter; 
 
-  // returns TLinearFitter object where Chi2, Fitparameters and residuals can 
+  return fitter;
+
+  // returns TLinearFitter object where Chi2, Fitparameters and residuals can
   // be extracted via usual memberfunctions
   // example: fitter->GetParameters(param)
-  // In case of type IFC or OFC, the parameters are the gradients in 
+  // In case of type IFC or OFC, the parameters are the gradients in
   // Z and Y direction (see fitformula)
-  // Caution: Parameters are [K/cm] except Y at IFC,OFC ([K/radius]) 
+  // Caution: Parameters are [K/cm] except Y at IFC,OFC ([K/radius])
 }
 
 //_____________________________________________________________________________
 
 TGraph2D *AliTPCTempMap::GetTempMapsViaSensors(Int_t type, Int_t side, UInt_t timeSec)
 {
-  // 
-  // Creates a TGraph2D object for the desired region of the TPC 
-  // (via choosen type and side of TPC temperature sensors) at a given 
-  // timeSec (in secounds) after start time
-  // type: 0 ... ReadOutChambers (ROC)
-  //       1 ... OuterContainmentVessel (OFC)
-  //       2 ... InnerContainmentVessel (IFC) + ThermalScreener (TS)
-  //       3 ... Within the TPC (DriftVolume) (TPC)
-  // side: Can be choosen for type 0 and 3 (otherwise it will be ignored in 
-  //       in order to get all temperature sensors of interest)
-  //       0 ... A - side
-  //       1 ... C - side
-  // 
+  /// Creates a TGraph2D object for the desired region of the TPC
+  /// (via choosen type and side of TPC temperature sensors) at a given
+  /// timeSec (in secounds) after start time
+  /// type: 0 ... ReadOutChambers (ROC)
+  ///       1 ... OuterContainmentVessel (OFC)
+  ///       2 ... InnerContainmentVessel (IFC) + ThermalScreener (TS)
+  ///       3 ... Within the TPC (DriftVolume) (TPC)
+  /// side: Can be choosen for type 0 and 3 (otherwise it will be ignored in
+  ///       in order to get all temperature sensors of interest)
+  ///       0 ... A - side
+  ///       1 ... C - side
 
   TGraph2D *graph2D = new TGraph2D();
 
   Int_t i = 0;
-  
+
   Int_t nsensors = fTempArray->NumSensors();
   for (Int_t isensor=0; isensor<nsensors; isensor++) { // loop over all sensors
     AliTPCSensorTemp *entry = (AliTPCSensorTemp*)fTempArray->GetSensorNum(isensor);
@@ -303,8 +287,8 @@ TGraph2D *AliTPCTempMap::GetTempMapsViaSensors(Int_t type, Int_t side, UInt_t ti
 	i++;
       }
     }
-  }  
-  
+  }
+
   if (type==0 || type==3) {
     graph2D->GetXaxis()->SetTitle("X[cm]");
     graph2D->GetYaxis()->SetTitle("Y[cm]");
@@ -334,36 +318,34 @@ TGraph2D *AliTPCTempMap::GetTempMapsViaSensors(Int_t type, Int_t side, UInt_t ti
   graph2D->GetXaxis()->SetLabelOffset(0.0);
   graph2D->GetYaxis()->SetLabelOffset(0.005);
   graph2D->GetZaxis()->SetLabelOffset(-0.04);
-  
+
 
   return graph2D; // returns TGgraph2D object
-  
+
 }
 
 
 //_____________________________________________________________________________
 
 TGraph *AliTPCTempMap::MakeGraphGradient(Int_t axis, Int_t side, Int_t nPoints)
-{  
-  //
-  // Make graph from start time to end time of TempGradient in axis direction
-  // axis: 0 ... horizontal Temperature Gradient (X)
-  //       1 ... vertical Temperature Gradient (Y)
-  //       2 ... longitudenal Temperature Gradient (Z) (side is ignored) 
-  //             z gradient value based on OFC temperature sensors
-  //             Caution!: better z gradient values through difference between 
-  //             param[0] A- and param[0] C-side !
-  // side for X and Y gradient: 
-  //       0 ... Shaft Side (A)
-  //       1 ... Muon Side (C)
-  //
-  
+{
+  /// Make graph from start time to end time of TempGradient in axis direction
+  /// axis: 0 ... horizontal Temperature Gradient (X)
+  ///       1 ... vertical Temperature Gradient (Y)
+  ///       2 ... longitudenal Temperature Gradient (Z) (side is ignored)
+  /// z gradient value based on OFC temperature sensors
+  /// Caution!: better z gradient values through difference between
+  /// param[0] A- and param[0] C-side !
+  /// side for X and Y gradient:
+  ///       0 ... Shaft Side (A)
+  ///       1 ... Muon Side (C)
+
   TVectorD param(3);
   TLinearFitter *fitter = new TLinearFitter(3);
 
   UInt_t fStartTime = fTempArray->AliTPCSensorTempArray::GetStartTime();
   UInt_t fEndTime = fTempArray->AliTPCSensorTempArray::GetEndTime();
-  
+
   UInt_t stepTime = (fEndTime-fStartTime)/nPoints;
 
   Double_t *x = new Double_t[nPoints];
@@ -376,7 +358,7 @@ TGraph *AliTPCTempMap::MakeGraphGradient(Int_t axis, Int_t side, Int_t nPoints)
       fitter = GetLinearFitter(3, side, ip*stepTime);
     }
     fitter->GetParameters(param);
-    // multiplied by 500 since TempGradient is in [K/cm] 
+    // multiplied by 500 since TempGradient is in [K/cm]
     // (TPC diameter and length ~500cm)
     if (axis==1) { // Y axis
       y[ip] = param[2]*500;
@@ -387,7 +369,7 @@ TGraph *AliTPCTempMap::MakeGraphGradient(Int_t axis, Int_t side, Int_t nPoints)
 
   TGraph *graph = new TGraph(nPoints,x,y);
 
-  fitter->~TLinearFitter(); 
+  fitter->~TLinearFitter();
   delete [] x;
   delete [] y;
 
@@ -402,10 +384,8 @@ TGraph *AliTPCTempMap::MakeGraphGradient(Int_t axis, Int_t side, Int_t nPoints)
 //_____________________________________________________________________________
 Double_t AliTPCTempMap::GetTemperature(Double_t x, Double_t y, Double_t z, TTimeStamp &stamp)
 {
-  //
-  // absolute time stamp used
-  // see also Double_t AliTPCTempMap::GetTemperature(Double_t x, Double_t y, Double_t z, UInt_t timeSec) for details
-  //
+  /// absolute time stamp used
+  /// see also Double_t AliTPCTempMap::GetTemperature(Double_t x, Double_t y, Double_t z, UInt_t timeSec) for details
 
   Int_t timeSec = stamp.GetSec()-fTempArray->GetStartTime().GetSec();
   return GetTemperature(x, y, z, timeSec);
@@ -414,16 +394,14 @@ Double_t AliTPCTempMap::GetTemperature(Double_t x, Double_t y, Double_t z, TTime
 //_____________________________________________________________________________
 
 Double_t AliTPCTempMap::GetTemperature(Double_t x, Double_t y, Double_t z, UInt_t timeSec)
-{  
-  //
-  // Returns estimated Temperature at given position (x,y,z[cm]) at given time 
-  // (timeSec) after starttime
-  // Method: so far just a linear interpolation between Linar fits of 
-  //         the TPC temperature sensors
-  //         FIXME: 'Educated Fit' through FiniteElement Simulation results!
-  // FIXXME: Return 0? if x,y,z out of range
-  //
-  
+{
+  /// Returns estimated Temperature at given position (x,y,z[cm]) at given time
+  /// (timeSec) after starttime
+  /// Method: so far just a linear interpolation between Linar fits of
+  /// the TPC temperature sensors
+  /// FIXME: 'Educated Fit' through FiniteElement Simulation results!
+  /// FIXXME: Return 0? if x,y,z out of range
+
   TVectorD paramA(3), paramC(3);
   TLinearFitter *fitterA = 0;
   TLinearFitter *fitterC = 0;
@@ -448,9 +426,8 @@ Double_t AliTPCTempMap::GetTemperature(Double_t x, Double_t y, Double_t z, UInt_
 
 
 Bool_t  AliTPCTempMap::IsOK(Float_t value){
-  //
-  // checks if value is within a certain range
-  //
+  /// checks if value is within a certain range
+
   const Float_t kMinT=15;
   const Float_t kMaxT=25;
   return (value>kMinT && value<kMaxT);
diff --git a/TPC/TPCbase/AliTPCTempMap.h b/TPC/TPCbase/AliTPCTempMap.h
index fe8c07bda9e..960bcabcf92 100644
--- a/TPC/TPCbase/AliTPCTempMap.h
+++ b/TPC/TPCbase/AliTPCTempMap.h
@@ -4,11 +4,8 @@
  * See cxx source for full Copyright notice                               */
 
 
-///////////////////////////////////////////////////////////////////////////////
-//                                                                           //
-//  TPC calibration class for temperature maps and tendencies                //
-//                                                                           //
-///////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCTempMap
+/// \brief TPC calibration class for temperature maps and tendencies
 
 #include "TSystem.h"
 
@@ -22,7 +19,7 @@ class TTimeStamp;
 class AliTPCTempMap : public TNamed  {
  public:
   AliTPCTempMap(AliTPCSensorTempArray *SensorsDCS);
-  AliTPCTempMap(const AliTPCTempMap &c);   
+  AliTPCTempMap(const AliTPCTempMap &c);
   virtual ~AliTPCTempMap();
   AliTPCTempMap &operator=(const AliTPCTempMap &c);
   virtual void Copy (TObject &c) const;
@@ -37,16 +34,17 @@ class AliTPCTempMap : public TNamed  {
   Double_t GetTemperature(Double_t x, Double_t y, Double_t z, TTimeStamp &stamp);
   Bool_t  IsOK(Float_t value);
  protected:
-  
-  AliTPCSensorTempArray *fTempArray;   // Array of Sensors (initialized in Constructor)
-  TString fStringFEsimulation; // Placeholder for file of FiniteElement 
-                               // Simulation under ideal conditions - not existing yet
+
+  AliTPCSensorTempArray *fTempArray;   ///< Array of Sensors (initialized in Constructor)
+  TString fStringFEsimulation; ///< Placeholder for file of FiniteElement Simulation under ideal conditions - not existing yet
 
  private:
 
   AliTPCTempMap(const char *fname);
 
-  ClassDef(AliTPCTempMap,2)      //  
+  /// \cond CLASSIMP
+  ClassDef(AliTPCTempMap,2)      //
+  /// \endcond
 
 };
 
diff --git a/TPC/TPCbase/AliTPCTransform.cxx b/TPC/TPCbase/AliTPCTransform.cxx
index cfbc0d6fe72..4e9accff035 100644
--- a/TPC/TPCbase/AliTPCTransform.cxx
+++ b/TPC/TPCbase/AliTPCTransform.cxx
@@ -13,43 +13,43 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-//-------------------------------------------------------
-//          Implementation of the TPC transformation class
-//
-//   Origin: Marian Ivanov   Marian.Ivanov@cern.ch
-//           Magnus Mager
-//
-//   Class for tranformation of the coordinate frame
-//   Transformation  
-//    local coordinate frame (sector, padrow, pad, timebine) ==>
-//    rotated global (tracking) cooridnate frame (sector, lx,ly,lz)
-//
-//    Unisochronity  - (substract time0 - pad by pad)
-//    Drift velocity - Currently common drift velocity - functionality of AliTPCParam
-//    ExB effect     - 
-//
-//    Time of flight correction -
-//                   - Depends on the vertex position
-//                   - by default 
-//                           
-//    Usage:
-//          AliTPCclusterer::AddCluster
-//          AliTPCtracker::Transform
-//    
-//-------------------------------------------------------
-
-/* To test it:
-   cdb=AliCDBManager::Instance()
-   cdb->SetDefaultStorage("local:///u/mmager/mycalib1")
-   c=AliTPCcalibDB::Instance()
-   c->SetRun(0)
-   Double_t x[]={1.0,2.0,3.0}
-   Int_t i[]={4}
-   AliTPCTransform trafo
-   trafo.Transform(x,i,0,1)
- */
-
-/* $Id$ */
+/// \class AliTPCTransform
+/// \brief Implementation of the TPC transformation class
+///
+/// Class for tranformation of the coordinate frame
+/// Transformation
+/// local coordinate frame (sector, padrow, pad, timebine) ==>
+/// rotated global (tracking) cooridnate frame (sector, lx,ly,lz)
+///
+/// Unisochronity  - (substract time0 - pad by pad)
+/// Drift velocity - Currently common drift velocity - functionality of AliTPCParam
+/// ExB effect     -
+///
+/// Time of flight correction -
+/// - Depends on the vertex position
+/// - by default
+///
+/// Usage:
+///
+/// ~~~{.cxx}
+/// AliTPCclusterer::AddCluster
+/// AliTPCtracker::Transform
+/// ~~~
+///
+/// To test it:
+///
+/// ~~~{.cxx}
+/// cdb=AliCDBManager::Instance()
+/// cdb->SetDefaultStorage("local:///u/mmager/mycalib1")
+/// c=AliTPCcalibDB::Instance()
+/// c->SetRun(0)
+/// Double_t x[]={1.0,2.0,3.0}
+/// Int_t i[]={4}
+/// AliTPCTransform trafo
+/// trafo.Transform(x,i,0,1)
+/// ~~~
+///
+/// \author Magnus Mager, Marian Ivanov
 
 #include "AliTPCROC.h"
 #include "AliTPCCalPad.h"
@@ -69,14 +69,16 @@
 #include "AliTracker.h"
 #include <AliCTPTimeParams.h>
 
+/// \cond CLASSIMP
 ClassImp(AliTPCTransform)
+/// \endcond
 
 
 AliTPCTransform::AliTPCTransform():
   AliTransform(),
   fCurrentRecoParam(0),       //! current reconstruction parameters
   fCurrentRun(0),             //! current run
-  fCurrentTimeStamp(0)        //! current time stamp   
+  fCurrentTimeStamp(0)        //! current time stamp
 {
   //
   // Speed it up a bit!
@@ -94,11 +96,10 @@ AliTPCTransform::AliTPCTransform(const AliTPCTransform& transform):
   AliTransform(transform),
   fCurrentRecoParam(transform.fCurrentRecoParam),       //! current reconstruction parameters
   fCurrentRun(transform.fCurrentRun),             //! current run
-  fCurrentTimeStamp(transform.fCurrentTimeStamp)        //! current time stamp   
+  fCurrentTimeStamp(transform.fCurrentTimeStamp)        //! current time stamp
 {
-  //
-  // Speed it up a bit!
-  //
+  /// Speed it up a bit!
+
   for (Int_t i=0;i<18;++i) {
     Double_t alpha=TMath::DegToRad()*(10.+20.*(i%18));
     fSins[i]=TMath::Sin(alpha);
@@ -110,15 +111,13 @@ AliTPCTransform::AliTPCTransform(const AliTPCTransform& transform):
 }
 
 AliTPCTransform::~AliTPCTransform() {
-  //
-  // Destructor
-  //
+  /// Destructor
+
 }
 
 void AliTPCTransform::SetPrimVertex(Double_t *vtx){
-  //
-  //
-  //
+  ///
+
   fPrimVtx[0]=vtx[0];
   fPrimVtx[1]=vtx[1];
   fPrimVtx[2]=vtx[2];
@@ -127,39 +126,39 @@ void AliTPCTransform::SetPrimVertex(Double_t *vtx){
 
 void AliTPCTransform::Transform(Double_t *x,Int_t *i,UInt_t /*time*/,
 				Int_t /*coordinateType*/) {
-  // input: x[0] - pad row
-  //        x[1] - pad 
-  //        x[2] - time in us
-  //        i[0] - sector
-  // output: x[0] - x (all in the rotated global coordinate frame)
-  //         x[1] - y
-  //         x[2] - z
-  //
-  //  primvtx     - position of the primary vertex
-  //                used for the TOF correction
-  //                TOF of particle calculated assuming the speed-of-light and 
-  //                line approximation  
-  //
+  /// input: x[0] - pad row
+  ///        x[1] - pad
+  ///        x[2] - time in us
+  ///        i[0] - sector
+  /// output: x[0] - x (all in the rotated global coordinate frame)
+  /// x[1] - y
+  /// x[2] - z
+  ///
+  ///  primvtx     - position of the primary vertex
+  /// used for the TOF correction
+  /// TOF of particle calculated assuming the speed-of-light and
+  /// line approximation
+
   if (!fCurrentRecoParam) {
     return;
   }
   Int_t row=TMath::Nint(x[0]);
   Int_t pad=TMath::Nint(x[1]);
   Int_t sector=i[0];
-  AliTPCcalibDB*  calib=AliTPCcalibDB::Instance();  
+  AliTPCcalibDB*  calib=AliTPCcalibDB::Instance();
   //
-  AliTPCCalPad * time0TPC = calib->GetPadTime0(); 
-  AliTPCCalPad * distortionMapY = calib->GetDistortionMap(0); 
-  AliTPCCalPad * distortionMapZ = calib->GetDistortionMap(1); 
-  AliTPCCalPad * distortionMapR = calib->GetDistortionMap(2); 
-  AliTPCParam  * param    = calib->GetParameters(); 
+  AliTPCCalPad * time0TPC = calib->GetPadTime0();
+  AliTPCCalPad * distortionMapY = calib->GetDistortionMap(0);
+  AliTPCCalPad * distortionMapZ = calib->GetDistortionMap(1);
+  AliTPCCalPad * distortionMapR = calib->GetDistortionMap(2);
+  AliTPCParam  * param    = calib->GetParameters();
   AliTPCCorrection * correction = calib->GetTPCComposedCorrection();   // first user defined correction  // if does not exist  try to get it from calibDB array
   if (!correction) correction = calib->GetTPCComposedCorrection(AliTracker::GetBz());
   if (!time0TPC){
     AliFatal("Time unisochronity missing");
     return ; // make coverity happy
   }
-  AliTPCCorrection * correctionDelta = calib->GetTPCComposedCorrectionDelta(); 
+  AliTPCCorrection * correctionDelta = calib->GetTPCComposedCorrectionDelta();
 
   if (!param){
     AliFatal("Parameters missing");
@@ -168,7 +167,7 @@ void AliTPCTransform::Transform(Double_t *x,Int_t *i,UInt_t /*time*/,
 
   Double_t xx[3];
   //  Apply Time0 correction - Pad by pad fluctuation
-  //  
+  //
   if (!calib->HasAlignmentOCDB()) x[2]-=time0TPC->GetCalROC(sector)->GetValue(row,pad);
   //
   // Tranform from pad - time coordinate system to the rotated global (tracking) system
@@ -180,9 +179,9 @@ void AliTPCTransform::Transform(Double_t *x,Int_t *i,UInt_t /*time*/,
   // Alignment
   //TODO:  calib->GetParameters()->GetClusterMatrix(sector)->LocalToMaster(x,xx);
   RotatedGlobal2Global(sector,x);
-  
+
   //
-  // old ExB correction 
+  // old ExB correction
   //
   if(fCurrentRecoParam->GetUseExBCorrection()) {
 
@@ -211,14 +210,14 @@ void AliTPCTransform::Transform(Double_t *x,Int_t *i,UInt_t /*time*/,
       xx[1]=distPointDelta[1];
       xx[2]=distPointDelta[2];
     }
-  } 
+  }
 
 
   //
   // Time of flight correction
-  // 
+  //
   if (fCurrentRecoParam->GetUseTOFCorrection()){
-    const Int_t kNIS=param->GetNInnerSector(), kNOS=param->GetNOuterSector(); 
+    const Int_t kNIS=param->GetNInnerSector(), kNOS=param->GetNOuterSector();
     Float_t sign=1;
     if (sector < kNIS) {
       sign = (sector < kNIS/2) ? 1 : -1;
@@ -233,7 +232,7 @@ void AliTPCTransform::Transform(Double_t *x,Int_t *i,UInt_t /*time*/,
     dist = TMath::Sqrt(dist);
     // drift length correction because of TOF
     // the drift velocity is in cm/s therefore multiplication by 0.01
-    deltaDr = (dist*(0.01*param->GetDriftV()))/TMath::C(); 
+    deltaDr = (dist*(0.01*param->GetDriftV()))/TMath::C();
     xx[2]+=sign*deltaDr;
   }
   //
@@ -244,7 +243,7 @@ void AliTPCTransform::Transform(Double_t *x,Int_t *i,UInt_t /*time*/,
   Global2RotatedGlobal(sector,xx);
 
   //
-  // Apply non linear distortion correction  
+  // Apply non linear distortion correction
   //
   if (distortionMapY ){
     // wt - to get it form the OCDB
@@ -257,22 +256,22 @@ void AliTPCTransform::Transform(Double_t *x,Int_t *i,UInt_t /*time*/,
     Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ;
     Double_t c0=1./(1.+wt*wt);
     Double_t c1=wt/c0;
-    
+
     //can be switch on for each dimension separatelly
     if (fCurrentRecoParam->GetUseFieldCorrection()&0x2)
       if (distortionMapY){
 	xx[1]-= c0*distortionMapY->GetCalROC(sector)->GetValue(row,pad);
 	xx[0]-= c1*distortionMapY->GetCalROC(sector)->GetValue(row,pad);
       }
-    if (fCurrentRecoParam->GetUseFieldCorrection()&0x4) 
+    if (fCurrentRecoParam->GetUseFieldCorrection()&0x4)
       if (distortionMapZ)
 	xx[2]-=distortionMapZ->GetCalROC(sector)->GetValue(row,pad);
-    if (fCurrentRecoParam->GetUseFieldCorrection()&0x8) 
+    if (fCurrentRecoParam->GetUseFieldCorrection()&0x8)
       if (distortionMapR){
 	xx[0]-= c0*distortionMapR->GetCalROC(sector)->GetValue(row,pad);
 	xx[1]-=-c1*distortionMapR->GetCalROC(sector)->GetValue(row,pad)*wt;
       }
-    
+
   }
   //
 
@@ -281,24 +280,20 @@ void AliTPCTransform::Transform(Double_t *x,Int_t *i,UInt_t /*time*/,
 }
 
 void AliTPCTransform::Local2RotatedGlobal(Int_t sector, Double_t *x) const {
-  //
-  //  
-  // Tranform coordinate from  
-  // row, pad, time to x,y,z
-  //
-  // Drift Velocity 
-  // Current implementation - common drift velocity - for full chamber
-  // TODO: use a map or parametrisation!
-  //
-  //  
-  //
+  /// Tranform coordinate from
+  /// row, pad, time to x,y,z
+  ///
+  /// Drift Velocity
+  /// Current implementation - common drift velocity - for full chamber
+  /// TODO: use a map or parametrisation!
+
   if (!fCurrentRecoParam) return;
   const  Int_t kMax =60;  // cache for 60 seconds
   static Int_t lastStamp=-1;  //cached values
   static Double_t lastCorr = 1;
   //
   AliTPCcalibDB*  calib=AliTPCcalibDB::Instance();
-  AliTPCParam  * param    = calib->GetParameters(); 
+  AliTPCParam  * param    = calib->GetParameters();
   AliTPCCalibVdrift *driftCalib = AliTPCcalibDB::Instance()->GetVdrift(fCurrentRun);
   Double_t driftCorr = 1.;
   if (driftCalib){
@@ -311,7 +306,7 @@ void AliTPCTransform::Local2RotatedGlobal(Int_t sector, Double_t *x) const {
       driftCorr = 1.+(driftCalib->GetPTRelative(fCurrentTimeStamp,0)+ driftCalib->GetPTRelative(fCurrentTimeStamp,1))*0.5;
       lastCorr=driftCorr;
       lastStamp=fCurrentTimeStamp;
-      
+
     }
   }
   //
@@ -326,28 +321,28 @@ void AliTPCTransform::Local2RotatedGlobal(Int_t sector, Double_t *x) const {
     lastStampT=fCurrentTimeStamp;
     if(fCurrentRecoParam->GetUseDriftCorrectionTime()>0) {
       vdcorrectionTime = (1+AliTPCcalibDB::Instance()->
-			  GetVDriftCorrectionTime(fCurrentTimeStamp, 
+			  GetVDriftCorrectionTime(fCurrentTimeStamp,
 						  fCurrentRun,
 						  sector%36>=18,
-						  fCurrentRecoParam->GetUseDriftCorrectionTime()));			  
+						  fCurrentRecoParam->GetUseDriftCorrectionTime()));
       time0corrTime= AliTPCcalibDB::Instance()->
-	GetTime0CorrectionTime(fCurrentTimeStamp, 
+	GetTime0CorrectionTime(fCurrentTimeStamp,
 			       fCurrentRun,
 			       sector%36>=18,
-			       fCurrentRecoParam->GetUseDriftCorrectionTime());	
+			       fCurrentRecoParam->GetUseDriftCorrectionTime());
       //
       deltaZcorrTime= AliTPCcalibDB::Instance()->
-	GetVDriftCorrectionDeltaZ(fCurrentTimeStamp, 
+	GetVDriftCorrectionDeltaZ(fCurrentTimeStamp,
 			       fCurrentRun,
 			       sector%36>=18,
-			       0);	
-      
+			       0);
+
     }
     //
     if(fCurrentRecoParam->GetUseDriftCorrectionGY()>0) {
-      
+
       Double_t corrGy= AliTPCcalibDB::Instance()->
-			GetVDriftCorrectionGy(fCurrentTimeStamp, 
+			GetVDriftCorrectionGy(fCurrentTimeStamp,
 					      AliTPCcalibDB::Instance()->GetRun(),
 					      sector%36>=18,
 					      fCurrentRecoParam->GetUseDriftCorrectionGY());
@@ -395,9 +390,9 @@ void AliTPCTransform::Local2RotatedGlobal(Int_t sector, Double_t *x) const {
   if (sector%36>17){
     x[1]*=-1;
   }
-  
+
   //
-  
+
   //
   // Z coordinate
   //
@@ -419,9 +414,8 @@ void AliTPCTransform::Local2RotatedGlobal(Int_t sector, Double_t *x) const {
 }
 
 void AliTPCTransform::RotatedGlobal2Global(Int_t sector,Double_t *x) const {
-  //
-  // transform possition rotated global to the global
-  //
+  /// transform possition rotated global to the global
+
   Double_t cos,sin;
   GetCosAndSin(sector,cos,sin);
   Double_t tmp=x[0];
@@ -430,9 +424,8 @@ void AliTPCTransform::RotatedGlobal2Global(Int_t sector,Double_t *x) const {
 }
 
 void AliTPCTransform::Global2RotatedGlobal(Int_t sector,Double_t *x) const {
-  //
-  // tranform possition Global2RotatedGlobal
-  //
+  /// tranform possition Global2RotatedGlobal
+
   Double_t cos,sin;
   GetCosAndSin(sector,cos,sin);
   Double_t tmp=x[0];
@@ -448,11 +441,8 @@ void AliTPCTransform::GetCosAndSin(Int_t sector,Double_t &cos,
 
 
 void AliTPCTransform::ApplyTransformations(Double_t */*xyz*/, Int_t /*volID*/){
-  //
-  // Modify global position
-  // xyz    - global xyz position
-  // volID  - volID of detector (sector number)
-  //
-  //
-  
+  /// Modify global position
+  /// xyz    - global xyz position
+  /// volID  - volID of detector (sector number)
+
 }
diff --git a/TPC/TPCbase/AliTPCTransform.h b/TPC/TPCbase/AliTPCTransform.h
index e1f7d589654..d9b1b98bd12 100644
--- a/TPC/TPCbase/AliTPCTransform.h
+++ b/TPC/TPCbase/AliTPCTransform.h
@@ -4,14 +4,13 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-/* $Id$ */
 
-//
-//    Class for tranformation of the coordinate frame
-//    Transformation  
-//      local coordinate frame (sector, padrow, pad, timebine) ==>
-//      rotated global (tracking) cooridnate frame (sector, lx,ly,lz)
-//
+/// \class AliTPCTransform
+/// \brief Class for tranformation of the coordinate frame
+///
+/// Transformation
+///  local coordinate frame (sector, padrow, pad, timebine) ==>
+///  rotated global (tracking) cooridnate frame (sector, lx,ly,lz)
 
 class AliTPCRecoParam;
 #include "AliTransform.h"
@@ -20,7 +19,7 @@ class AliTPCTransform:public AliTransform {
 public:
   AliTPCTransform();
   AliTPCTransform(const AliTPCTransform& transform);
-  
+
   virtual ~AliTPCTransform();
   virtual void Transform(Double_t *x,Int_t *i,UInt_t time,
 			 Int_t coordinateType);
@@ -42,13 +41,15 @@ public:
   void ApplyTransformations(Double_t *xyz, Int_t volID);
 private:
   AliTPCTransform& operator=(const AliTPCTransform&); // not implemented
-  Double_t fCoss[18];  // cache the transformation
-  Double_t fSins[18];  // cache the transformation
-  Double_t fPrimVtx[3];// position of the primary vertex - needed for TOF correction
-  AliTPCRecoParam * fCurrentRecoParam; //! current reconstruction parameters
-  Int_t    fCurrentRun;                //! current run
-  UInt_t   fCurrentTimeStamp;          //! current time stamp
+  Double_t fCoss[18];  ///< cache the transformation
+  Double_t fSins[18];  ///< cache the transformation
+  Double_t fPrimVtx[3];///< position of the primary vertex - needed for TOF correction
+  AliTPCRecoParam * fCurrentRecoParam; //!< current reconstruction parameters
+  Int_t    fCurrentRun;                //!< current run
+  UInt_t   fCurrentTimeStamp;          //!< current time stamp
+  /// \cond CLASSIMP
   ClassDef(AliTPCTransform,1)
+  /// \endcond
 };
 
 #endif
diff --git a/TPC/TPCbase/AliTPCcalibDB.cxx b/TPC/TPCbase/AliTPCcalibDB.cxx
index c35efbd05d9..d4adef33a38 100644
--- a/TPC/TPCbase/AliTPCcalibDB.cxx
+++ b/TPC/TPCbase/AliTPCcalibDB.cxx
@@ -13,68 +13,60 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-
-///////////////////////////////////////////////////////////////////////////////
-//                                                                           //
-// Class providing the calibration parameters by accessing the CDB           //
-//                                                                           //
-// Request an instance with AliTPCcalibDB::Instance()                        //
-// If a new event is processed set the event number with SetRun              //
-// Then request the calibration data                                         ////
-//
-//
-// Calibration data:
-// 0.)  Altro mapping
-//          Simulation      - not yet 
-//          Reconstruction  - AliTPCclusterer::Digits2Clusters(AliRawReader* rawReader)
-//
-// 1.)  pad by pad calibration -  AliTPCCalPad
-//      
-//      a.) fPadGainFactor
-//          Simulation: AliTPCDigitizer::ExecFast - Multiply by gain
-//          Reconstruction : AliTPCclusterer::Digits2Clusters - Divide by gain  
-//
-//      b.) fPadNoise -
-//          Simulation:        AliTPCDigitizer::ExecFast
-//          Reconstruction:    AliTPCclusterer::FindClusters(AliTPCCalROC * noiseROC)
-//                             Noise depending cut on clusters charge (n sigma)
-//      c.) fPedestal:
-//          Simulation:     Not used yet - To be impleneted - Rounding to the nearest integer
-//          Reconstruction: Used in AliTPCclusterer::Digits2Clusters(AliRawReader* rawReader) 
-//                          if data taken without zero suppression  
-//                          Currently switch in  fRecoParam->GetCalcPedestal();
-//      
-//      d.) fPadTime0
-//          Simulation:      applied in the AliTPC::MakeSector - adding offset
-//          Reconstruction:  AliTPCTransform::Transform() - remove offset
-//                           AliTPCTransform::Transform() - to be called
-//                           in AliTPCtracker::Transform()      
-//
-// 
-// 2.)  Space points transformation:
-//
-//      a.) General coordinate tranformation - AliTPCtransform (see $ALICE_ROOT/TPC/AliTPCtransform.cxx)
-//          Created on fly - use the other calibration components
-//                 Unisochronity  - (substract time0 - pad by pad)
-//                 Drift velocity - Currently common drift velocity - functionality of AliTPCParam
-//                 ExB effect    
-//          Simulation     - Not used directly (the effects are applied one by one (see AliTPC::MakeSector)
-//          Reconstruction - 
-//                           AliTPCclusterer::AddCluster
-//                           AliTPCtracker::Transform
-//      b.) ExB effect calibration - 
-//             classes (base class AliTPCExB, implementation- AliTPCExBExact.h  AliTPCExBFirst.h)
-//             a.a) Simulation:   applied in the AliTPC::MakeSector - 
-//                                calib->GetExB()->CorrectInverse(dxyz0,dxyz1);
-//             a.b) Reconstruction -  
-//                  
-//                  in AliTPCtransform::Correct() - called calib->GetExB()->Correct(dxyz0,dxyz1)
-//
-//  3.)   cluster error, shape and Q parameterization
-//
-//
-//
-///////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCcalibDB
+/// \brief Class providing the calibration parameters by accessing the CDB
+///
+/// Request an instance with AliTPCcalibDB::Instance()
+/// If a new event is processed set the event number with SetRun
+/// Then request the calibration data
+///
+/// Calibration data:
+/// 0.)  Altro mapping
+///          Simulation      - not yet
+///          Reconstruction  - AliTPCclusterer::Digits2Clusters(AliRawReader* rawReader)
+///
+/// 1.)  pad by pad calibration -  AliTPCCalPad
+///
+///      a.) fPadGainFactor
+///          Simulation: AliTPCDigitizer::ExecFast - Multiply by gain
+///          Reconstruction : AliTPCclusterer::Digits2Clusters - Divide by gain
+///
+///      b.) fPadNoise -
+///          Simulation:        AliTPCDigitizer::ExecFast
+///          Reconstruction:    AliTPCclusterer::FindClusters(AliTPCCalROC * noiseROC)
+///                             Noise depending cut on clusters charge (n sigma)
+///      c.) fPedestal:
+///          Simulation:     Not used yet - To be impleneted - Rounding to the nearest integer
+///          Reconstruction: Used in AliTPCclusterer::Digits2Clusters(AliRawReader* rawReader)
+///                          if data taken without zero suppression
+///                          Currently switch in  fRecoParam->GetCalcPedestal();
+///
+///      d.) fPadTime0
+///          Simulation:      applied in the AliTPC::MakeSector - adding offset
+///          Reconstruction:  AliTPCTransform::Transform() - remove offset
+///                           AliTPCTransform::Transform() - to be called
+///                           in AliTPCtracker::Transform()
+///
+/// 2.)  Space points transformation:
+///
+///      a.) General coordinate tranformation - AliTPCtransform (see $ALICE_ROOT/TPC/AliTPCtransform.cxx)
+///          Created on fly - use the other calibration components
+///                 Unisochronity  - (substract time0 - pad by pad)
+///                 Drift velocity - Currently common drift velocity - functionality of AliTPCParam
+///                 ExB effect
+///          Simulation     - Not used directly (the effects are applied one by one (see AliTPC::MakeSector)
+///          Reconstruction -
+///                           AliTPCclusterer::AddCluster
+///                           AliTPCtracker::Transform
+///      b.) ExB effect calibration -
+///             classes (base class AliTPCExB, implementation- AliTPCExBExact.h  AliTPCExBFirst.h)
+///             a.a) Simulation:   applied in the AliTPC::MakeSector -
+///                                calib->GetExB()->CorrectInverse(dxyz0,dxyz1);
+///             a.b) Reconstruction -
+///
+///                  in AliTPCtransform::Correct() - called calib->GetExB()->Correct(dxyz0,dxyz1)
+///
+///  3.)   cluster error, shape and Q parameterization
 
 #include <iostream>
 #include <fstream>
@@ -133,21 +125,21 @@ class AliTPCCalDet;
 #include "AliTriggerScalers.h"
 #include "AliTriggerScalersRecord.h"
 
+/// \cond CLASSIMP
 ClassImp(AliTPCcalibDB)
+/// \endcond
 
 AliTPCcalibDB* AliTPCcalibDB::fgInstance = 0;
 Bool_t AliTPCcalibDB::fgTerminated = kFALSE;
-TObjArray    AliTPCcalibDB::fgExBArray;    // array of ExB corrections
+TObjArray    AliTPCcalibDB::fgExBArray;    ///< array of ExB corrections
 
 
 //_ singleton implementation __________________________________________________
 AliTPCcalibDB* AliTPCcalibDB::Instance()
 {
-  //
-  // Singleton implementation
-  // Returns an instance of this class, it is created if necessary
-  //
-  
+  /// Singleton implementation
+  /// Returns an instance of this class, it is created if necessary
+
   if (fgTerminated != kFALSE)
     return 0;
 
@@ -159,12 +151,10 @@ AliTPCcalibDB* AliTPCcalibDB::Instance()
 
 void AliTPCcalibDB::Terminate()
 {
-  //
-  // Singleton implementation
-  // Deletes the instance of this class and sets the terminated flag, instances cannot be requested anymore
-  // This function can be called several times.
-  //
-  
+  /// Singleton implementation
+  /// Deletes the instance of this class and sets the terminated flag, instances cannot be requested anymore
+  /// This function can be called several times.
+
   fgTerminated = kTRUE;
   
   if (fgInstance != 0)
@@ -217,10 +207,8 @@ AliTPCcalibDB::AliTPCcalibDB():
   fCTPTimeParams(0),
   fMode(-1)
 {
-  //
-  // constructor
-  //  
-  //
+  /// constructor
+
   fgInstance=this;
   for (Int_t i=0;i<72;++i){
     fChamberHVStatus[i]=kTRUE;
@@ -281,9 +269,8 @@ AliTPCcalibDB::AliTPCcalibDB(const AliTPCcalibDB& ):
   fCTPTimeParams(0),
   fMode(-1)
 {
-  //
-  // Copy constructor invalid -- singleton implementation
-  //
+  /// Copy constructor invalid -- singleton implementation
+
   Error("copy constructor","invalid -- singleton implementation");
   for (Int_t i=0;i<72;++i){
     fChamberHVStatus[i]=kTRUE;
@@ -303,9 +290,8 @@ AliTPCcalibDB::AliTPCcalibDB(const AliTPCcalibDB& ):
 
 AliTPCcalibDB& AliTPCcalibDB::operator= (const AliTPCcalibDB& )
 {
-//
-// Singleton implementation - no assignment operator
-//
+/// Singleton implementation - no assignment operator
+
   Error("operator =", "assignment operator not implemented");
   return *this;
 }
@@ -315,19 +301,18 @@ AliTPCcalibDB& AliTPCcalibDB::operator= (const AliTPCcalibDB& )
 //_____________________________________________________________________________
 AliTPCcalibDB::~AliTPCcalibDB() 
 {
-  //
-  // destructor
-  //
-  //delete fIonTailArray; 
+  /// destructor
+  ///
+  /// delete fIonTailArray;
+
   delete fActiveChannelMap;
   delete fGrRunState;
   fgInstance = 0;
 }
 
 AliTPCCalPad* AliTPCcalibDB::GetDistortionMap(Int_t i) const {
-  //
-  // get distortion map - due E field distortions
-  //
+  /// get distortion map - due E field distortions
+
   return (fDistortionMap) ? (AliTPCCalPad*)fDistortionMap->At(i):0;
 }
 
@@ -338,9 +323,8 @@ AliTPCRecoParam* AliTPCcalibDB::GetRecoParam(Int_t i) const {
 //_____________________________________________________________________________
 AliCDBEntry* AliTPCcalibDB::GetCDBEntry(const char* cdbPath)
 {
-  // 
-  // Retrieves an entry with path <cdbPath> from the CDB.
-  //
+  /// Retrieves an entry with path <cdbPath> from the CDB.
+
   char chinfo[1000];
     
   AliCDBEntry* entry = AliCDBManager::Instance()->Get(cdbPath, fRun); 
@@ -357,9 +341,8 @@ AliCDBEntry* AliTPCcalibDB::GetCDBEntry(const char* cdbPath)
 //_____________________________________________________________________________
 void AliTPCcalibDB::SetRun(Long64_t run)
 {
-  //
-  // Sets current run number. Calibration data is read from the corresponding file. 
-  //  
+  /// Sets current run number. Calibration data is read from the corresponding file.
+
   if (fRun == run)
     return;  
 	fRun = run;
@@ -369,10 +352,8 @@ void AliTPCcalibDB::SetRun(Long64_t run)
 
 
 void AliTPCcalibDB::Update(){
-  //
-  // cache the OCDB entries for simulation, reconstruction, calibration
-  //  
-  //
+  /// cache the OCDB entries for simulation, reconstruction, calibration
+
   AliCDBEntry * entry=0;
   Bool_t cdbCache = AliCDBManager::Instance()->GetCacheFlag(); // save cache status
   AliCDBManager::Instance()->SetCacheFlag(kTRUE); // activate CDB cache
@@ -575,11 +556,11 @@ void AliTPCcalibDB::Update(){
 }
 
 void AliTPCcalibDB::UpdateNonRec(){
-  //
-  // Update/Load the parameters which are important for QA studies
-  // and not used yet for the reconstruction
-  //
-   //RAW calibration data
+  /// Update/Load the parameters which are important for QA studies
+  /// and not used yet for the reconstruction
+  ///
+  /// RAW calibration data
+
   AliCDBEntry * entry=0;
   entry          = GetCDBEntry("TPC/Calib/Raw");
   if (entry){
@@ -606,11 +587,9 @@ void AliTPCcalibDB::UpdateNonRec(){
 
 Bool_t AliTPCcalibDB::GetTailcancelationGraphs(Int_t sector, TGraphErrors ** graphRes, Float_t * indexAmpGraphs){
  
-// 
-//   Read OCDB entry object of Iontail (TObjArray of TGraphErrors of TRFs)
-//   Naming of the TRF objects is: "gr_<chamber_type>_<voltage>_<laser_track_angle>_<distance_to_COG>" --> "gr_iroc_1240_1_1" 
-//   
-  
+///   Read OCDB entry object of Iontail (TObjArray of TGraphErrors of TRFs)
+///   Naming of the TRF objects is: "gr_<chamber_type>_<voltage>_<laser_track_angle>_<distance_to_COG>" --> "gr_iroc_1240_1_1"
+
   //Int_t run = fTransform->GetCurrentRunNumber();
   //SetRun(run);
   //Float_t rocVoltage = GetChamberHighVoltage(run,sector, -1);      // Get the voltage from OCDB with a getter (old function)
@@ -720,9 +699,8 @@ Bool_t AliTPCcalibDB::GetTailcancelationGraphs(Int_t sector, TGraphErrors ** gra
 
 void AliTPCcalibDB::CreateObjectList(const Char_t *filename, TObjArray *calibObjects)
 {
-//
-// Create calibration objects and read contents from OCDB
-//
+/// Create calibration objects and read contents from OCDB
+
    if ( calibObjects == 0x0 ) return;
    ifstream in;
    in.open(filename);
@@ -813,11 +791,11 @@ void AliTPCcalibDB::CreateObjectList(const Char_t *filename, TObjArray *calibObj
 }
 
 Int_t AliTPCcalibDB::InitDeadMap() {
-  // Initialize DeadChannel Map 
-  // Source of information:
-  // -  HV (see UpdateChamberHighVoltageData())
-  // -  Altro disabled channels. Noisy channels.
-  // -  DDL list
+  /// Initialize DeadChannel Map
+  /// Source of information:
+  /// -  HV (see UpdateChamberHighVoltageData())
+  /// -  Altro disabled channels. Noisy channels.
+  /// -  DDL list
 
   // check necessary information
   const Int_t run=GetRun();
@@ -894,12 +872,11 @@ Int_t AliTPCcalibDB::InitDeadMap() {
 }
 
 void AliTPCcalibDB::MakeTree(const char * fileName, TObjArray * array, const char * mapFileName, AliTPCCalPad* outlierPad, Float_t ltmFraction) {
-  //
-  // Write a tree with all available information
-  // if mapFileName is specified, the Map information are also written to the tree
-  // pads specified in outlierPad are not used for calculating statistics
-  //  - the same function as AliTPCCalPad::MakeTree - 
-  //
+  /// Write a tree with all available information
+  /// if mapFileName is specified, the Map information are also written to the tree
+  /// pads specified in outlierPad are not used for calculating statistics
+  ///  - the same function as AliTPCCalPad::MakeTree -
+
    AliTPCROC* tpcROCinstance = AliTPCROC::Instance();
 
    TObjArray* mapIROCs = 0;
@@ -1103,9 +1080,8 @@ void AliTPCcalibDB::MakeTree(const char * fileName, TObjArray * array, const cha
 
 Int_t AliTPCcalibDB::GetRCUTriggerConfig() const
 {
-  //
-  // return the RCU trigger configuration register
-  //
+  /// return the RCU trigger configuration register
+
   TMap *map=GetRCUconfig();
   if (!map) return -1;
   TVectorF *v=(TVectorF*)map->GetValue("TRGCONF_TRG_MODE");
@@ -1122,27 +1098,24 @@ Int_t AliTPCcalibDB::GetRCUTriggerConfig() const
 
 Bool_t AliTPCcalibDB::IsTrgL0() 
 {
-  //
-  // return if the FEE readout was triggered on L0
-  //
+  /// return if the FEE readout was triggered on L0
+
   if (fMode<0) return kFALSE;
   return (fMode==1);
 }
 
 Bool_t AliTPCcalibDB::IsTrgL1()
 {
-  //
-  // return if the FEE readout was triggered on L1
-  //
+  /// return if the FEE readout was triggered on L1
+
   if (fMode<0) return kFALSE;
   return (fMode==0);
 }
 
 void AliTPCcalibDB::RegisterExB(Int_t index, Float_t bz, Bool_t bdelete){
-  //
-  // Register static ExB correction map
-  // index - registration index - used for visualization
-  // bz    - bz field in kGaus
+  /// Register static ExB correction map
+  /// index - registration index - used for visualization
+  /// bz    - bz field in kGaus
 
   //  Float_t factor =  bz/(-5.);  // default b filed in Cheb with minus sign
   Float_t factor =  bz/(5.);  // default b filed in Cheb with minus sign
@@ -1164,11 +1137,10 @@ void AliTPCcalibDB::RegisterExB(Int_t index, Float_t bz, Bool_t bdelete){
 
 
 AliTPCExB*    AliTPCcalibDB::GetExB(Float_t bz, Bool_t deleteB) {
-  //
-  // bz filed in KGaus not in tesla
-  // Get ExB correction map
-  // if doesn't exist - create it
-  //
+  /// bz filed in KGaus not in tesla
+  /// Get ExB correction map
+  /// if doesn't exist - create it
+
   Int_t index = TMath::Nint(5+bz);
   if (index>fgExBArray.GetEntries()) fgExBArray.Expand((index+1)*2+11);
   if (!fgExBArray.At(index)) AliTPCcalibDB::RegisterExB(index,bz,deleteB);
@@ -1177,16 +1149,14 @@ AliTPCExB*    AliTPCcalibDB::GetExB(Float_t bz, Bool_t deleteB) {
 
 
 void  AliTPCcalibDB::SetExBField(Float_t bz){
-  //
-  // Set magnetic filed for ExB correction
-  //
+  /// Set magnetic filed for ExB correction
+
   fExB = GetExB(bz,kFALSE);
 }
 
 void  AliTPCcalibDB::SetExBField(const AliMagF*   bmap){
-  //
-  // Set magnetic field for ExB correction
-  //
+  /// Set magnetic field for ExB correction
+
   AliTPCExBFirst *exb  = new  AliTPCExBFirst(bmap,0.88*2.6400e+04,50,50,50);
   AliTPCExB::SetInstance(exb);
   fExB=exb;
@@ -1195,9 +1165,8 @@ void  AliTPCcalibDB::SetExBField(const AliMagF*   bmap){
 
 
 void AliTPCcalibDB::UpdateRunInformations( Int_t run, Bool_t force){
-  //
-  // - > Don't use it for reconstruction - Only for Calibration studies
-  //
+  /// - > Don't use it for reconstruction - Only for Calibration studies
+
   if (run<=0) return;
   TObjString runstr(Form("%i",run));
   fRun=run;
@@ -1303,27 +1272,24 @@ void AliTPCcalibDB::UpdateRunInformations( Int_t run, Bool_t force){
 
 
 Float_t AliTPCcalibDB::GetGain(Int_t sector, Int_t row, Int_t pad){
-  //
-  // Get Gain factor for given pad
-  //
+  /// Get Gain factor for given pad
+
   AliTPCCalPad *calPad = Instance()->fDedxGainFactor;;
   if (!calPad) return 0;
   return calPad->GetCalROC(sector)->GetValue(row,pad);
 }
 
 AliSplineFit* AliTPCcalibDB::GetVdriftSplineFit(const char* name, Int_t run){
-  //
-  // GetDrift velocity spline fit
-  //
+  /// GetDrift velocity spline fit
+
   TObjArray *arr=GetTimeVdriftSplineRun(run);
   if (!arr) return 0;
   return dynamic_cast<AliSplineFit*>(arr->FindObject(name));
 }
 
 AliSplineFit* AliTPCcalibDB::CreateVdriftSplineFit(const char* graphName, Int_t run){
-  //
-  // create spline fit from the drift time graph in TimeDrift
-  //
+  /// create spline fit from the drift time graph in TimeDrift
+
   TObjArray *arr=GetTimeVdriftSplineRun(run);
   if (!arr) return 0;
   TGraph *graph=dynamic_cast<TGraph*>(arr->FindObject(graphName));
@@ -1337,9 +1303,8 @@ AliSplineFit* AliTPCcalibDB::CreateVdriftSplineFit(const char* graphName, Int_t
 }
 
 AliGRPObject *AliTPCcalibDB::GetGRP(Int_t run){
-  //
-  // Get GRP object for given run 
-  //
+  /// Get GRP object for given run
+
   AliGRPObject * grpRun = dynamic_cast<AliGRPObject *>((Instance()->fGRPArray).GetValue(Form("%i",run)));
   if (!grpRun) {
     Instance()->UpdateRunInformations(run);
@@ -1350,9 +1315,8 @@ AliGRPObject *AliTPCcalibDB::GetGRP(Int_t run){
 }
 
 TMap *  AliTPCcalibDB::GetGRPMap(Int_t run){
-  //
-  // Get GRP map for given run
-  //
+  /// Get GRP map for given run
+
   TMap * grpRun = dynamic_cast<TMap *>((Instance()->fGRPMaps).GetValue(Form("%i",run)));
   if (!grpRun) {
     Instance()->UpdateRunInformations(run);
@@ -1364,13 +1328,11 @@ TMap *  AliTPCcalibDB::GetGRPMap(Int_t run){
 
 
 AliDCSSensor * AliTPCcalibDB::GetPressureSensor(Int_t run, Int_t type){
-  //
-  // Get Pressure sensor
-  // run  = run number
-  // type = 0 - Cavern pressure
-  //        1 - Suface pressure
-  // First try to get if trom map - if existing  (Old format of data storing)
-  //
+  /// Get Pressure sensor
+  /// run  = run number
+  /// type = 0 - Cavern pressure
+  ///        1 - Suface pressure
+  /// First try to get if trom map - if existing  (Old format of data storing)
 
 
   TMap *map = GetGRPMap(run);  
@@ -1397,9 +1359,8 @@ AliDCSSensor * AliTPCcalibDB::GetPressureSensor(Int_t run, Int_t type){
 }
 
 AliTPCSensorTempArray * AliTPCcalibDB::GetTemperatureSensor(Int_t run){
-  //
-  // Get temperature sensor array
-  //
+  /// Get temperature sensor array
+
   AliTPCSensorTempArray * tempArray = (AliTPCSensorTempArray *)fTemperatureArray.GetValue(Form("%i",run));
   if (!tempArray) {
     UpdateRunInformations(run);
@@ -1410,9 +1371,8 @@ AliTPCSensorTempArray * AliTPCcalibDB::GetTemperatureSensor(Int_t run){
 
 
 TObjArray * AliTPCcalibDB::GetTimeGainSplinesRun(Int_t run){
-  //
-  // Get temperature sensor array
-  //
+  /// Get temperature sensor array
+
   TObjArray * gainSplines = (TObjArray *)fTimeGainSplinesArray.GetValue(Form("%i",run));
   if (!gainSplines) {
     UpdateRunInformations(run);
@@ -1422,9 +1382,8 @@ TObjArray * AliTPCcalibDB::GetTimeGainSplinesRun(Int_t run){
 }
 
 TObjArray * AliTPCcalibDB::GetTimeVdriftSplineRun(Int_t run){
-  //
-  // Get drift spline array
-  //
+  /// Get drift spline array
+
   TObjArray * driftSplines = (TObjArray *)fDriftCorrectionArray.GetValue(Form("%i",run));
   if (!driftSplines) {
     UpdateRunInformations(run);
@@ -1434,9 +1393,8 @@ TObjArray * AliTPCcalibDB::GetTimeVdriftSplineRun(Int_t run){
 }
 
 AliDCSSensorArray * AliTPCcalibDB::GetVoltageSensors(Int_t run){
-  //
-  // Get temperature sensor array
-  //
+  /// Get temperature sensor array
+
   AliDCSSensorArray * voltageArray = (AliDCSSensorArray *)fVoltageArray.GetValue(Form("%i",run));
   if (!voltageArray) {
     UpdateRunInformations(run);
@@ -1446,9 +1404,8 @@ AliDCSSensorArray * AliTPCcalibDB::GetVoltageSensors(Int_t run){
 }
 
 AliDCSSensorArray * AliTPCcalibDB::GetGoofieSensors(Int_t run){
-  //
-  // Get temperature sensor array
-  //
+  /// Get temperature sensor array
+
   AliDCSSensorArray * goofieArray = (AliDCSSensorArray *)fGoofieArray.GetValue(Form("%i",run));
   if (!goofieArray) {
     UpdateRunInformations(run);
@@ -1460,9 +1417,8 @@ AliDCSSensorArray * AliTPCcalibDB::GetGoofieSensors(Int_t run){
 
 
 AliTPCCalibVdrift *     AliTPCcalibDB::GetVdrift(Int_t run){
-  //
-  // Get the interface to the the vdrift 
-  //
+  /// Get the interface to the the vdrift
+
   AliTPCCalibVdrift  * vdrift = (AliTPCCalibVdrift*)fVdriftArray.GetValue(Form("%i",run));
   if (!vdrift) {
     UpdateRunInformations(run);
@@ -1473,12 +1429,11 @@ AliTPCCalibVdrift *     AliTPCcalibDB::GetVdrift(Int_t run){
 
 Float_t AliTPCcalibDB::GetCEdriftTime(Int_t run, Int_t sector, Double_t timeStamp, Int_t *entries)
 {
-  //
-  // GetCE drift time information for 'sector'
-  // sector 72 is the mean drift time of the A-Side
-  // sector 73 is the mean drift time of the C-Side
-  // it timestamp==-1 return mean value
-  //
+  /// GetCE drift time information for 'sector'
+  /// sector 72 is the mean drift time of the A-Side
+  /// sector 73 is the mean drift time of the C-Side
+  /// it timestamp==-1 return mean value
+
   AliTPCcalibDB::Instance()->SetRun(run);
   TGraph *gr=AliTPCcalibDB::Instance()->GetCErocTgraph(sector);
   if (!gr||sector<0||sector>73) {
@@ -1502,10 +1457,9 @@ Float_t AliTPCcalibDB::GetCEdriftTime(Int_t run, Int_t sector, Double_t timeStam
   
 Float_t AliTPCcalibDB::GetCEchargeTime(Int_t run, Int_t sector, Double_t timeStamp, Int_t *entries)
 {
-  //
-  // GetCE mean charge for 'sector'
-  // it timestamp==-1 return mean value
-  //
+  /// GetCE mean charge for 'sector'
+  /// it timestamp==-1 return mean value
+
   AliTPCcalibDB::Instance()->SetRun(run);
   TGraph *gr=AliTPCcalibDB::Instance()->GetCErocQgraph(sector);
   if (!gr||sector<0||sector>71) {
@@ -1529,9 +1483,8 @@ Float_t AliTPCcalibDB::GetCEchargeTime(Int_t run, Int_t sector, Double_t timeSta
 
 Float_t AliTPCcalibDB::GetDCSSensorValue(AliDCSSensorArray *arr, Int_t timeStamp, const char * sensorName, Int_t sigDigits)
 {
-  //
-  // Get Value for a DCS sensor 'sensorName', run 'run' at time 'timeStamp'
-  //
+  /// Get Value for a DCS sensor 'sensorName', run 'run' at time 'timeStamp'
+
   Float_t val=0;
   const TString sensorNameString(sensorName);
   AliDCSSensor *sensor = arr->GetSensor(sensorNameString);
@@ -1578,9 +1531,8 @@ Float_t AliTPCcalibDB::GetDCSSensorValue(AliDCSSensorArray *arr, Int_t timeStamp
 
 Float_t AliTPCcalibDB::GetDCSSensorMeanValue(AliDCSSensorArray *arr, const char * sensorName, Int_t sigDigits)
 {
-  //
-  // Get mean Value for a DCS sensor 'sensorName' during run 'run'
-  //
+  /// Get mean Value for a DCS sensor 'sensorName' during run 'run'
+
   Float_t val=0;
   const TString sensorNameString(sensorName);
   AliDCSSensor *sensor = arr->GetSensor(sensorNameString);
@@ -1630,13 +1582,11 @@ Bool_t AliTPCcalibDB::IsDataTakingActive(time_t timeStamp)
 
 void AliTPCcalibDB::UpdateChamberHighVoltageData()
 {
-  //
-  // set chamber high voltage data
-  // 1. Robust median (sampling the hv graphs over time)
-  // 2. Current nominal voltages (nominal voltage corrected for common HV offset)
-  // 3. Fraction of good HV values over time (deviation from robust median)
-  // 4. HV status, based on the above
-  //
+  /// set chamber high voltage data
+  /// 1. Robust median (sampling the hv graphs over time)
+  /// 2. Current nominal voltages (nominal voltage corrected for common HV offset)
+  /// 3. Fraction of good HV values over time (deviation from robust median)
+  /// 4. HV status, based on the above
 
   // start and end time of the run
   const Int_t run=GetRun();
@@ -1822,10 +1772,9 @@ void AliTPCcalibDB::UpdateChamberHighVoltageData()
 }
 
 Float_t AliTPCcalibDB::GetChamberHighVoltage(Int_t run, Int_t sector, Int_t timeStamp, Int_t sigDigits, Bool_t current) {
-  //
-  // return the chamber HV for given run and time: 0-35 IROC, 36-72 OROC
-  // if timeStamp==-1 return mean value
-  //
+  /// return the chamber HV for given run and time: 0-35 IROC, 36-72 OROC
+  /// if timeStamp==-1 return mean value
+
   Float_t val=0;
   TString sensorName="";
   TTimeStamp stamp(timeStamp);
@@ -1859,11 +1808,10 @@ Float_t AliTPCcalibDB::GetChamberHighVoltage(Int_t run, Int_t sector, Int_t time
 }
 Float_t AliTPCcalibDB::GetSkirtVoltage(Int_t run, Int_t sector, Int_t timeStamp, Int_t sigDigits)
 {
-  //
-  // Get the skirt voltage for 'run' at 'timeStamp' and 'sector': 0-35 IROC, 36-72 OROC
-  // type corresponds to the following: 0 - IROC A-Side; 1 - IROC C-Side; 2 - OROC A-Side; 3 - OROC C-Side
-  // if timeStamp==-1 return the mean value for the run
-  //
+  /// Get the skirt voltage for 'run' at 'timeStamp' and 'sector': 0-35 IROC, 36-72 OROC
+  /// type corresponds to the following: 0 - IROC A-Side; 1 - IROC C-Side; 2 - OROC A-Side; 3 - OROC C-Side
+  /// if timeStamp==-1 return the mean value for the run
+
   Float_t val=0;
   TString sensorName="";
   TTimeStamp stamp(timeStamp);
@@ -1882,11 +1830,10 @@ Float_t AliTPCcalibDB::GetSkirtVoltage(Int_t run, Int_t sector, Int_t timeStamp,
 
 Float_t AliTPCcalibDB::GetCoverVoltage(Int_t run, Int_t sector, Int_t timeStamp, Int_t sigDigits)
 {
-  //
-  // Get the cover voltage for run 'run' at time 'timeStamp'
-  // type corresponds to the following: 0 - IROC A-Side; 1 - IROC C-Side; 2 - OROC A-Side; 3 - OROC C-Side
-  // if timeStamp==-1 return the mean value for the run
-  //
+  /// Get the cover voltage for run 'run' at time 'timeStamp'
+  /// type corresponds to the following: 0 - IROC A-Side; 1 - IROC C-Side; 2 - OROC A-Side; 3 - OROC C-Side
+  /// if timeStamp==-1 return the mean value for the run
+
   Float_t val=0;
   TString sensorName="";
   TTimeStamp stamp(timeStamp);
@@ -1911,11 +1858,10 @@ Float_t AliTPCcalibDB::GetCoverVoltage(Int_t run, Int_t sector, Int_t timeStamp,
 
 Float_t AliTPCcalibDB::GetGGoffsetVoltage(Int_t run, Int_t sector, Int_t timeStamp, Int_t sigDigits)
 {
-  //
-  // Get the GG offset voltage for run 'run' at time 'timeStamp'
-  // type corresponds to the following: 0 - IROC A-Side; 1 - IROC C-Side; 2 - OROC A-Side; 3 - OROC C-Side
-  // if timeStamp==-1 return the mean value for the run
-  //
+  /// Get the GG offset voltage for run 'run' at time 'timeStamp'
+  /// type corresponds to the following: 0 - IROC A-Side; 1 - IROC C-Side; 2 - OROC A-Side; 3 - OROC C-Side
+  /// if timeStamp==-1 return the mean value for the run
+
   Float_t val=0;
   TString sensorName="";
   TTimeStamp stamp(timeStamp);
@@ -1940,11 +1886,10 @@ Float_t AliTPCcalibDB::GetGGoffsetVoltage(Int_t run, Int_t sector, Int_t timeSta
 
 Float_t AliTPCcalibDB::GetGGnegVoltage(Int_t run, Int_t sector, Int_t timeStamp, Int_t sigDigits)
 {
-  //
-  // Get the GG offset voltage for run 'run' at time 'timeStamp'
-  // type corresponds to the following: 0 - IROC A-Side; 1 - IROC C-Side; 2 - OROC A-Side; 3 - OROC C-Side
-  // if timeStamp==-1 return the mean value for the run
-  //
+  /// Get the GG offset voltage for run 'run' at time 'timeStamp'
+  /// type corresponds to the following: 0 - IROC A-Side; 1 - IROC C-Side; 2 - OROC A-Side; 3 - OROC C-Side
+  /// if timeStamp==-1 return the mean value for the run
+
   Float_t val=0;
   TString sensorName="";
   TTimeStamp stamp(timeStamp);
@@ -1969,11 +1914,10 @@ Float_t AliTPCcalibDB::GetGGnegVoltage(Int_t run, Int_t sector, Int_t timeStamp,
 
 Float_t AliTPCcalibDB::GetGGposVoltage(Int_t run, Int_t sector, Int_t timeStamp, Int_t sigDigits)
 {
-  //
-  // Get the GG offset voltage for run 'run' at time 'timeStamp'
-  // type corresponds to the following: 0 - IROC A-Side; 1 - IROC C-Side; 2 - OROC A-Side; 3 - OROC C-Side
-  // if timeStamp==-1 return the mean value for the run
-  //
+  /// Get the GG offset voltage for run 'run' at time 'timeStamp'
+  /// type corresponds to the following: 0 - IROC A-Side; 1 - IROC C-Side; 2 - OROC A-Side; 3 - OROC C-Side
+  /// if timeStamp==-1 return the mean value for the run
+
   Float_t val=0;
   TString sensorName="";
   TTimeStamp stamp(timeStamp);
@@ -1997,9 +1941,8 @@ Float_t AliTPCcalibDB::GetGGposVoltage(Int_t run, Int_t sector, Int_t timeStamp,
 }
 
 Float_t AliTPCcalibDB::GetPressure(Int_t timeStamp, Int_t run, Int_t type){
-  //
-  // GetPressure for given time stamp and runt
-  //
+  /// GetPressure for given time stamp and runt
+
   TTimeStamp stamp(timeStamp);
   AliDCSSensor * sensor = Instance()->GetPressureSensor(run,type);
   if (!sensor) return 0;
@@ -2007,10 +1950,9 @@ Float_t AliTPCcalibDB::GetPressure(Int_t timeStamp, Int_t run, Int_t type){
 }
 
 Float_t AliTPCcalibDB::GetL3Current(Int_t run, Int_t statType){
-  //
-  // return L3 current
-  // stat type is: AliGRPObject::Stats: kMean = 0, kTruncMean = 1, kMedian = 2, kSDMean = 3, kSDMedian = 4
-  //
+  /// return L3 current
+  /// stat type is: AliGRPObject::Stats: kMean = 0, kTruncMean = 1, kMedian = 2, kSDMean = 3, kSDMedian = 4
+
   Float_t current=-1;
   AliGRPObject *grp=AliTPCcalibDB::GetGRP(run);
   if (grp) current=grp->GetL3Current((AliGRPObject::Stats)statType);
@@ -2018,9 +1960,8 @@ Float_t AliTPCcalibDB::GetL3Current(Int_t run, Int_t statType){
 }
 
 Float_t AliTPCcalibDB::GetBz(Int_t run){
-  //
-  // calculate BZ in T from L3 current
-  //
+  /// calculate BZ in T from L3 current
+
   Float_t bz=-1;
   Float_t current=AliTPCcalibDB::GetL3Current(run);
   if (current>-1) bz=5*current/30000.*.1;
@@ -2028,9 +1969,8 @@ Float_t AliTPCcalibDB::GetBz(Int_t run){
 }
 
 Char_t  AliTPCcalibDB::GetL3Polarity(Int_t run) {
-  //
-  // get l3 polarity from GRP
-  //
+  /// get l3 polarity from GRP
+
   Char_t pol=-100;
   AliGRPObject *grp=AliTPCcalibDB::GetGRP(run);
   if (grp) pol=grp->GetL3Polarity();
@@ -2038,9 +1978,7 @@ Char_t  AliTPCcalibDB::GetL3Polarity(Int_t run) {
 }
 
 TString AliTPCcalibDB::GetRunType(Int_t run){
-  //
-  // return run type from grp
-  //
+  /// return run type from grp
 
 //   TString type("UNKNOWN");
   AliGRPObject *grp=AliTPCcalibDB::GetGRP(run);
@@ -2049,9 +1987,8 @@ TString AliTPCcalibDB::GetRunType(Int_t run){
 }
 
 Float_t AliTPCcalibDB::GetValueGoofie(Int_t timeStamp, Int_t run, Int_t type){
-  //
-  // GetPressure for given time stamp and runt
-  //
+  /// GetPressure for given time stamp and runt
+
   TTimeStamp stamp(timeStamp);
   AliDCSSensorArray* goofieArray = AliTPCcalibDB::Instance()->GetGoofieSensors(run);
   if (!goofieArray) return 0;
@@ -2065,9 +2002,8 @@ Float_t AliTPCcalibDB::GetValueGoofie(Int_t timeStamp, Int_t run, Int_t type){
 
 
 Bool_t  AliTPCcalibDB::GetTemperatureFit(Int_t timeStamp, Int_t run, Int_t side,TVectorD& fit){
-  //
-  // GetTmeparature fit at parameter for given time stamp
-  //
+  /// GetTmeparature fit at parameter for given time stamp
+
   TTimeStamp tstamp(timeStamp);
   AliTPCSensorTempArray* tempArray  = Instance()->GetTemperatureSensor(run);
   if (! tempArray) return kFALSE;
@@ -2084,9 +2020,8 @@ Bool_t  AliTPCcalibDB::GetTemperatureFit(Int_t timeStamp, Int_t run, Int_t side,
 }
 
 Float_t AliTPCcalibDB::GetTemperature(Int_t timeStamp, Int_t run, Int_t side){
-  //
-  // Get mean temperature
-  // 
+  /// Get mean temperature
+
   TVectorD vec(5);
   if (side==0) {
     GetTemperatureFit(timeStamp,run,0,vec);
@@ -2101,21 +2036,21 @@ Float_t AliTPCcalibDB::GetTemperature(Int_t timeStamp, Int_t run, Int_t side){
 
 
 Double_t AliTPCcalibDB::GetPTRelative(UInt_t timeSec, Int_t run, Int_t side){
-  //
-  // Get relative P/T 
-  // time - absolute time
-  // run  - run number
-  // side - 0 - A side   1-C side
+  /// Get relative P/T
+  /// time - absolute time
+  /// run  - run number
+  /// side - 0 - A side   1-C side
+
   AliTPCCalibVdrift * vdrift =  Instance()->GetVdrift(run);
   if (!vdrift) return 0;
   return vdrift->GetPTRelative(timeSec,side);
 }
 
 AliGRPObject * AliTPCcalibDB::MakeGRPObjectFromMap(TMap *map){
-  //
-  // Function to covert old GRP run information from TMap to GRPObject
-  //
-  //  TMap * map = AliTPCcalibDB::GetGRPMap(52406);
+  /// Function to covert old GRP run information from TMap to GRPObject
+  ///
+  ///  TMap * map = AliTPCcalibDB::GetGRPMap(52406);
+
   if (!map) return 0;
   AliDCSSensor * sensor = 0;
   TObject *osensor=0;
@@ -2145,9 +2080,7 @@ AliGRPObject * AliTPCcalibDB::MakeGRPObjectFromMap(TMap *map){
 
 Bool_t AliTPCcalibDB::CreateGUITree(Int_t run, const char* filename)
 {
-  //
-  // Create a gui tree for run number 'run'
-  //
+  /// Create a gui tree for run number 'run'
 
   if (!AliCDBManager::Instance()->GetDefaultStorage()){
     AliLog::Message(AliLog::kError, "Default Storage not set. Cannot create Calibration Tree!",
@@ -2163,9 +2096,8 @@ Bool_t AliTPCcalibDB::CreateGUITree(Int_t run, const char* filename)
 }
 
 Bool_t AliTPCcalibDB::CreateGUITree(const char* filename){
-  //
-  //
-  //
+  ///
+
   if (!AliCDBManager::Instance()->GetDefaultStorage()){
     AliError("Default Storage not set. Cannot create calibration Tree!");
     return kFALSE;
@@ -2222,10 +2154,8 @@ Bool_t AliTPCcalibDB::CreateGUITree(const char* filename){
 
 Bool_t AliTPCcalibDB::CreateRefFile(Int_t run, const char* filename)
 {
-  //
-  // Create a gui tree for run number 'run'
-  //
-  
+  /// Create a gui tree for run number 'run'
+
   if (!AliCDBManager::Instance()->GetDefaultStorage()){
     AliLog::Message(AliLog::kError, "Default Storage not set. Cannot create Calibration Tree!",
                     MODULENAME(), "AliTPCcalibDB", FUNCTIONNAME(), __FILE__, __LINE__);
@@ -2266,17 +2196,16 @@ Bool_t AliTPCcalibDB::CreateRefFile(Int_t run, const char* filename)
 
 
 Double_t AliTPCcalibDB::GetVDriftCorrectionTime(Int_t timeStamp, Int_t run, Int_t /*side*/, Int_t mode){
-  //
-  // Get time dependent drift velocity correction
-  // multiplication factor        vd = vdnom *(1+vdriftcorr)
-  // Arguments:
-  // mode determines the algorith how to combine the Laser Track, LaserCE and physics tracks
-  // timestamp - timestamp
-  // run       - run number
-  // side      - the drift velocity per side (possible for laser and CE)
-  //
-  // Notice - Extrapolation outside of calibration range  - using constant function
-  //
+  /// Get time dependent drift velocity correction
+  /// multiplication factor        vd = vdnom *(1+vdriftcorr)
+  /// Arguments:
+  /// mode determines the algorith how to combine the Laser Track, LaserCE and physics tracks
+  /// timestamp - timestamp
+  /// run       - run number
+  /// side      - the drift velocity per side (possible for laser and CE)
+  ///
+  /// Notice - Extrapolation outside of calibration range  - using constant function
+
   Double_t result=0;
   // mode 1  automatic mode - according to the distance to the valid calibration
   //                        -  
@@ -2319,18 +2248,17 @@ Double_t AliTPCcalibDB::GetVDriftCorrectionTime(Int_t timeStamp, Int_t run, Int_
 }
 
 Double_t AliTPCcalibDB::GetTime0CorrectionTime(Int_t timeStamp, Int_t run, Int_t /*side*/, Int_t mode){
-  //
-  // Get time dependent time 0 (trigger delay in cm) correction
-  // additive correction        time0 = time0+ GetTime0CorrectionTime
-  // Value etracted combining the vdrift correction using laser tracks and CE and the physics track matchin
-  // Arguments:
-  // mode determines the algorith how to combine the Laser Track and physics tracks
-  // timestamp - timestamp
-  // run       - run number
-  // side      - the drift velocity per side (possible for laser and CE)
-  //
-  // Notice - Extrapolation outside of calibration range  - using constant function
-  //
+  /// Get time dependent time 0 (trigger delay in cm) correction
+  /// additive correction        time0 = time0+ GetTime0CorrectionTime
+  /// Value etracted combining the vdrift correction using laser tracks and CE and the physics track matchin
+  /// Arguments:
+  /// mode determines the algorith how to combine the Laser Track and physics tracks
+  /// timestamp - timestamp
+  /// run       - run number
+  /// side      - the drift velocity per side (possible for laser and CE)
+  ///
+  /// Notice - Extrapolation outside of calibration range  - using constant function
+
   Double_t result=0;
   if (mode==2) {
     // TPC-TPC mode
@@ -2350,18 +2278,17 @@ Double_t AliTPCcalibDB::GetTime0CorrectionTime(Int_t timeStamp, Int_t run, Int_t
 
 
 Double_t AliTPCcalibDB::GetVDriftCorrectionGy(Int_t timeStamp, Int_t run, Int_t side, Int_t /*mode*/){
-  //
-  // Get global y correction drift velocity correction factor
-  // additive factor        vd = vdnom*(1+GetVDriftCorrectionGy *gy)
-  // Value etracted combining the vdrift correction using laser tracks and CE or TPC-ITS
-  // Arguments:
-  // mode determines the algorith how to combine the Laser Track, LaserCE or TPC-ITS
-  // timestamp - timestamp
-  // run       - run number
-  // side      - the drift velocity gy correction per side (CE and Laser tracks)
-  //
-  // Notice - Extrapolation outside of calibration range  - using constant function
-  // 
+  /// Get global y correction drift velocity correction factor
+  /// additive factor        vd = vdnom*(1+GetVDriftCorrectionGy *gy)
+  /// Value etracted combining the vdrift correction using laser tracks and CE or TPC-ITS
+  /// Arguments:
+  /// mode determines the algorith how to combine the Laser Track, LaserCE or TPC-ITS
+  /// timestamp - timestamp
+  /// run       - run number
+  /// side      - the drift velocity gy correction per side (CE and Laser tracks)
+  ///
+  /// Notice - Extrapolation outside of calibration range  - using constant function
+
   if (run<=0 && fTransform) run = fTransform->GetCurrentRunNumber();
   UpdateRunInformations(run,kFALSE);
   TObjArray *array =AliTPCcalibDB::Instance()->GetTimeVdriftSplineRun(run);
@@ -2402,10 +2329,9 @@ Double_t AliTPCcalibDB::GetVDriftCorrectionGy(Int_t timeStamp, Int_t run, Int_t
 
 
 Double_t AliTPCcalibDB::GetVDriftCorrectionDeltaZ(Int_t /*timeStamp*/, Int_t run, Int_t /*side*/, Int_t /*mode*/){
-  //
-  // Get deltaZ run/by/run  correction - as fitted together with drift velocity
-  // Value extracted  form the TPC-ITS, mean value is used
-  
+  /// Get deltaZ run/by/run  correction - as fitted together with drift velocity
+  /// Value extracted  form the TPC-ITS, mean value is used
+
   // Arguments:
   // mode determines the algorith how to combine the Laser Track, LaserCE or TPC-ITS
   // timestamp - not used
@@ -2430,14 +2356,13 @@ Double_t AliTPCcalibDB::GetVDriftCorrectionDeltaZ(Int_t /*timeStamp*/, Int_t run
 
 
 AliTPCCalPad* AliTPCcalibDB::MakeDeadMap(Double_t notInMap, const char* nameMappingFile) {
-//
-//   Read list of active DDLs from OCDB entry
-//   Generate and return AliTPCCalPad containing 1 for all pads in active DDLs,
-//   0 for all pads in non-active DDLs. 
-//   For DDLs with missing status information (no DCS input point to Shuttle),
-//     the value of the AliTPCCalPad entry is determined by the parameter
-//     notInMap (default value 1)
-//
+///   Read list of active DDLs from OCDB entry
+///   Generate and return AliTPCCalPad containing 1 for all pads in active DDLs,
+///   0 for all pads in non-active DDLs.
+///   For DDLs with missing status information (no DCS input point to Shuttle),
+///     the value of the AliTPCCalPad entry is determined by the parameter
+///     notInMap (default value 1)
+
   char chinfo[1000];
    
   TFile *fileMapping = new TFile(nameMappingFile, "read");
@@ -2510,11 +2435,11 @@ AliTPCCalPad* AliTPCcalibDB::MakeDeadMap(Double_t notInMap, const char* nameMapp
 
 
 AliTPCCorrection * AliTPCcalibDB::GetTPCComposedCorrection(Float_t field) const{
-  //
-  // GetComposed correction for given field setting
-  // If not specific correction for field used return correction for all field
-  //        - Complication needed to gaurantee OCDB back compatibility 
-  //        - Not neeeded for the new space point correction 
+  /// GetComposed correction for given field setting
+  /// If not specific correction for field used return correction for all field
+  ///        - Complication needed to gaurantee OCDB back compatibility
+  ///        - Not neeeded for the new space point correction
+
   if (!fComposedCorrectionArray) return 0;
   if (field>0.1 && fComposedCorrectionArray->At(1)) {   
     return (AliTPCCorrection *)fComposedCorrectionArray->At(1);
@@ -2528,10 +2453,9 @@ AliTPCCorrection * AliTPCcalibDB::GetTPCComposedCorrection(Float_t field) const{
 
 
 AliTPCCorrection * AliTPCcalibDB::GetTPCComposedCorrectionDelta() const{
-  //
-  // GetComposedCorrection delta
-  // Delta is time dependent - taken form the CalibTime OCDB entry
-  //
+  /// GetComposedCorrection delta
+  /// Delta is time dependent - taken form the CalibTime OCDB entry
+
   if (!fComposedCorrectionArray) return 0;
   if (fRun<0) return 0;
   if (fDriftCorrectionArray.GetValue(Form("%i",fRun))==0) return 0;
@@ -2548,25 +2472,24 @@ AliTPCCorrection * AliTPCcalibDB::GetTPCComposedCorrectionDelta() const{
 }
 
 Double_t AliTPCcalibDB::GetGainCorrectionHVandPT(Int_t timeStamp, Int_t run, Int_t sector, Int_t deltaCache, Int_t mode){
-  //
-  // Correction for  changes of gain caused by change of the HV and by relative change of the gas density
-  // Function is slow some kind of caching needed
-  // Cache implemented using the static TVectorD
-  //
-  // Input paremeters:
-  //  deltaCache - maximal time differnce above which the cache is recaclulated
-  //  mode       - mode==0 by default return combined correction 
-  //                       actual HV and Pt correction has to be present in the run calibration otherwise it is ignored.
-  //                       (retrun value differnt than 1 only in case calibration present in the OCDB entry CalibTimeGain
-  //               mode==1 return combined correction ( important for calibration pass)
-  //                       (in case thereis  no calibration in  CalibTimeGain, default value from the AliTPCParam (Parameters) is used
-  //                       this mode is used in the CPass0
-  //               mode==2 return HV correction
-  //               mode==3 return P/T correction
-  //  Usage in the simulation/reconstruction
-  //  MC:     Qcorr  = Qorig*GetGainCorrectionHVandPT   ( in AliTPC.cxx ) 
-  //  Rec:    dEdx   = dEdx/GetGainCorrectionHVandPT    ( in aliTPCseed.cxx )
-  //
+  /// Correction for  changes of gain caused by change of the HV and by relative change of the gas density
+  /// Function is slow some kind of caching needed
+  /// Cache implemented using the static TVectorD
+  ///
+  /// Input paremeters:
+  ///  deltaCache - maximal time differnce above which the cache is recaclulated
+  ///  mode       - mode==0 by default return combined correction
+  ///                       actual HV and Pt correction has to be present in the run calibration otherwise it is ignored.
+  ///                       (retrun value differnt than 1 only in case calibration present in the OCDB entry CalibTimeGain
+  ///               mode==1 return combined correction ( important for calibration pass)
+  ///                       (in case thereis  no calibration in  CalibTimeGain, default value from the AliTPCParam (Parameters) is used
+  ///                       this mode is used in the CPass0
+  ///               mode==2 return HV correction
+  ///               mode==3 return P/T correction
+  ///  Usage in the simulation/reconstruction
+  ///  MC:     Qcorr  = Qorig*GetGainCorrectionHVandPT   ( in AliTPC.cxx )
+  ///  Rec:    dEdx   = dEdx/GetGainCorrectionHVandPT    ( in aliTPCseed.cxx )
+
   static Float_t gGainCorrection[72];
   static Float_t gGainCorrectionPT[72];
   static Float_t gGainCorrectionHV[72];
diff --git a/TPC/TPCbase/AliTPCcalibDB.h b/TPC/TPCbase/AliTPCcalibDB.h
index 537d2a9be13..9f27fdc5131 100644
--- a/TPC/TPCbase/AliTPCcalibDB.h
+++ b/TPC/TPCbase/AliTPCcalibDB.h
@@ -3,11 +3,8 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-///////////////////////////////////////////////////////////////////////////////
-//                                                                           //
-// Class providing the calibration parameters by accessing the CDB           //
-//                                                                           //
-///////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCcalibDB
+/// \brief Class providing the calibration parameters by accessing the CDB
 
 
 class AliTPCTransform;
@@ -199,76 +196,78 @@ protected:
   void         UpdateChamberHighVoltageData();
   Int_t        InitDeadMap();
 
-  Int_t        fRun;         // current run number
-  AliTPCTransform *fTransform;      // object responsible for spacial corrections
-  AliTPCExB *fExB;              // ExB correction factor
+  Int_t        fRun;         ///< current run number
+  AliTPCTransform *fTransform;      ///< object responsible for spacial corrections
+  AliTPCExB *fExB;              ///< ExB correction factor
 //  AliCDBStorage* fLocator;      // Storage locator retrieved from AliCDBManager
   //
   // calibration parameters per pad
   //
-  AliTPCCalPad* fPadGainFactor;   // Gain calibration entry
-  AliTPCCalPad* fActiveChannelMap; // Map of active channels calculated on the fly
-  AliTPCCalPad* fDedxGainFactor;   // Gain calibration entry - for dEdx
-  AliTPCCalPad* fPadTime0;        // Time0 calibration entry
-  TObjArray   *fDistortionMap;    // distortion map
-  AliTPCCorrection *fComposedCorrection;  // general space point corrections
-  TObjArray *      fComposedCorrectionArray; //space point corrections for different field setting
-  AliTPCCalPad* fPadNoise;        // Noise calibration entry
-  AliTPCCalPad* fPedestals;       // Pedestal calibration entry
-  AliTPCCalibRaw *fCalibRaw;      // raw data calibration entry
-  AliTPCdataQA  *fDataQA;         // qa object
-  TObjArray *fALTROConfigData;    // ALTRO configuration data
-  TObjArray * fIonTailArray;      // array of graphs with the ion tail 
-  TObjArray *fPulserData;         // Calibration Pulser data
-  TObjArray *fCEData;             // CE data
+  AliTPCCalPad* fPadGainFactor;   ///< Gain calibration entry
+  AliTPCCalPad* fActiveChannelMap; ///< Map of active channels calculated on the fly
+  AliTPCCalPad* fDedxGainFactor;   ///< Gain calibration entry - for dEdx
+  AliTPCCalPad* fPadTime0;        ///< Time0 calibration entry
+  TObjArray   *fDistortionMap;    ///< distortion map
+  AliTPCCorrection *fComposedCorrection;  ///< general space point corrections
+  TObjArray *      fComposedCorrectionArray; ///< space point corrections for different field setting
+  AliTPCCalPad* fPadNoise;        ///< Noise calibration entry
+  AliTPCCalPad* fPedestals;       ///< Pedestal calibration entry
+  AliTPCCalibRaw *fCalibRaw;      ///< raw data calibration entry
+  AliTPCdataQA  *fDataQA;         ///< qa object
+  TObjArray *fALTROConfigData;    ///< ALTRO configuration data
+  TObjArray * fIonTailArray;      ///< array of graphs with the ion tail
+  TObjArray *fPulserData;         ///< Calibration Pulser data
+  TObjArray *fCEData;             ///< CE data
   //
   // Chamber HV info
   //
-  Bool_t  fChamberHVStatus[72];       // Status of the Chamber, HV wise (on/off)
-  Float_t fChamberHVmedian[72];       // median chamber high voltage
-  Float_t fCurrentNominalVoltage[72]; // current nominal voltages
-  Float_t fChamberHVgoodFraction[72]; // fraction of time the chamber has a good HV (wrt. robust median)
-  AliDCSSensor *fHVsensors[72];       // HV sensors
-  TGraph *fGrRunState;                // store information if run is active or paused
+  Bool_t  fChamberHVStatus[72];       ///< Status of the Chamber, HV wise (on/off)
+  Float_t fChamberHVmedian[72];       ///< median chamber high voltage
+  Float_t fCurrentNominalVoltage[72]; ///< current nominal voltages
+  Float_t fChamberHVgoodFraction[72]; ///< fraction of time the chamber has a good HV (wrt. robust median)
+  AliDCSSensor *fHVsensors[72];       ///< HV sensors
+  TGraph *fGrRunState;                ///< store information if run is active or paused
   //
   //
   //
-  AliTPCSensorTempArray* fTemperature; // Temperature calibration entry
-  AliTPCAltroMapping **fMapping;   // Altro mapping   
+  AliTPCSensorTempArray* fTemperature; ///< Temperature calibration entry
+  AliTPCAltroMapping **fMapping;   ///< Altro mapping
   //
   //
-  AliTPCParam * fParam;                // TPC parameters
-  AliTPCClusterParam * fClusterParam;  // TPC cluster error, shape and Q parameterization
-  TObjArray * fRecoParamList;          // List of TPC reco param objects
-  TObjArray * fTimeGainSplines;        // Array of AliSplineFits: at 0 MIP position in time ; at 1 Fermi Plateau from cosmics
+  AliTPCParam * fParam;                ///< TPC parameters
+  AliTPCClusterParam * fClusterParam;  ///< TPC cluster error, shape and Q parameterization
+  TObjArray * fRecoParamList;          ///< List of TPC reco param objects
+  TObjArray * fTimeGainSplines;        ///< Array of AliSplineFits: at 0 MIP position in time ; at 1 Fermi Plateau from cosmics
   //
   // Get the corssrun information
   //
-  TMap      fTimeGainSplinesArray; //! array Array of AliSplineFits: at 0 MIP position in time ; at 1 Fermi Plateau from cosmics
-  TMap      fGRPArray;							//! array of GRPs  -  per run
-  TMap      fGRPMaps;							//! array of GRPs maps  -  per run - old data  
-  TMap      fGoofieArray;					//! array of GOOFIE values -per run
-  TMap      fVoltageArray;					//! array of Chamber HV values -per run
-  TMap      fTemperatureArray;			//! array of temperature sensors - per run
-  TMap      fVdriftArray;					//! array of v drift interfaces
-  TMap      fDriftCorrectionArray;                //! array of drift correction
+  TMap      fTimeGainSplinesArray; //!< array Array of AliSplineFits: at 0 MIP position in time ; at 1 Fermi Plateau from cosmics
+  TMap      fGRPArray;							//!< array of GRPs  -  per run
+  TMap      fGRPMaps;							//!< array of GRPs maps  -  per run - old data
+  TMap      fGoofieArray;					//!< array of GOOFIE values -per run
+  TMap      fVoltageArray;					//!< array of Chamber HV values -per run
+  TMap      fTemperatureArray;			//!< array of temperature sensors - per run
+  TMap      fVdriftArray;					//!< array of v drift interfaces
+  TMap      fDriftCorrectionArray;                //!< array of drift correction
 
-  TArrayI        fRunList;							//! run list - indicates try to get the run param
-  Bool_t         fBHasAlignmentOCDB;                // Flag - alignment from the Transformation class
+  TArrayI        fRunList;							//!< run list - indicates try to get the run param
+  Bool_t         fBHasAlignmentOCDB;                ///< Flag - alignment from the Transformation class
   //
-  static AliTPCcalibDB* fgInstance;  // singleton control
-  static Bool_t       fgTerminated;  // termination control 
-  static TObjArray    fgExBArray;    // array of ExB corrections
-  AliTPCcalibDButil   *fDButil;       // utility class
+  static AliTPCcalibDB* fgInstance;  ///< singleton control
+  static Bool_t       fgTerminated;  ///< termination control
+  static TObjArray    fgExBArray;    ///< array of ExB corrections
+  AliTPCcalibDButil   *fDButil;       ///< utility class
   //ctp info
-  AliCTPTimeParams *fCTPTimeParams;   //CTP timing parameters
-  Int_t            fMode;             //RCU trigger config mode
+  AliCTPTimeParams *fCTPTimeParams;   ///< CTP timing parameters
+  Int_t            fMode;             ///< RCU trigger config mode
 
  private:
    AliTPCcalibDB (const AliTPCcalibDB& );
    AliTPCcalibDB& operator= (const AliTPCcalibDB& );
   
+   /// \cond CLASSIMP
    ClassDef(AliTPCcalibDB, 1)
+   /// \endcond
 };
 
 #endif
diff --git a/TPC/TPCbase/AliTPCcalibDButil.cxx b/TPC/TPCbase/AliTPCcalibDButil.cxx
index 530c2bd3a0d..ab9ac4452bf 100644
--- a/TPC/TPCbase/AliTPCcalibDButil.cxx
+++ b/TPC/TPCbase/AliTPCcalibDButil.cxx
@@ -14,15 +14,8 @@
  **************************************************************************/
 
 
-///////////////////////////////////////////////////////////////////////////////
-//                                                                           //
-// Class providing the calculation of derived quantities (mean,rms,fits,...) //
-//       of calibration entries                                              //
-/*
-
-
-*/
-////////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCcalibDButil
+/// \brief Class providing the calculation of derived quantities (mean,rms,fits,...) of calibration entries
 
 #include <TMath.h>
 #include <TVectorT.h>
@@ -61,7 +54,9 @@
 
 const Float_t kAlmost0=1.e-30;
 
+/// \cond CLASSIMP
 ClassImp(AliTPCcalibDButil)
+/// \endcond
 AliTPCcalibDButil::AliTPCcalibDButil() :
   TObject(),
   fCalibDB(0),
@@ -118,9 +113,8 @@ AliTPCcalibDButil::AliTPCcalibDButil() :
 //_____________________________________________________________________________________
 AliTPCcalibDButil::~AliTPCcalibDButil()
 {
-  //
-  // dtor
-  //
+  /// dtor
+
   delete fPulserOutlier;
   delete fRefPulserOutlier;
   delete fMapper;
@@ -146,9 +140,8 @@ AliTPCcalibDButil::~AliTPCcalibDButil()
 //_____________________________________________________________________________________
 void AliTPCcalibDButil::UpdateFromCalibDB()
 {
-  //
-  // Update pointers from calibDB
-  //
+  /// Update pointers from calibDB
+
   if (!fCalibDB) fCalibDB=AliTPCcalibDB::Instance();
   fCalibDB->UpdateNonRec();  // load all infromation now
   fPadNoise=fCalibDB->GetPadNoise();
@@ -171,13 +164,11 @@ void AliTPCcalibDButil::UpdateFromCalibDB()
 void AliTPCcalibDButil::ProcessCEdata(const char* fitFormula, TVectorD &fitResultsA, TVectorD &fitResultsC,
                                       Int_t &noutliersCE, Double_t & chi2A, Double_t &chi2C, AliTPCCalPad * const outCE)
 {
-  //
-  // Process the CE data for this run
-  // the return TVectorD arrays contian the results of the fit
-  // noutliersCE contains the number of pads marked as outliers,
-  //   not including masked and edge pads
-  //
-  
+  /// Process the CE data for this run
+  /// the return TVectorD arrays contian the results of the fit
+  /// noutliersCE contains the number of pads marked as outliers,
+  ///   not including masked and edge pads
+
   //retrieve CE and ALTRO data
   if (!fCETmean){
     TString fitString(fitFormula);
@@ -255,10 +246,8 @@ void AliTPCcalibDButil::ProcessCEgraphs(TVectorD &vecTEntries, TVectorD &vecTMea
                      TVectorD &vecQEntries, TVectorD &vecQMean, TVectorD &vecQRMS, TVectorD &vecQMedian,
                      Float_t &driftTimeA, Float_t &driftTimeC )
 {
-  //
-  // Calculate statistical information from the CE graphs for drift time and charge
-  //
-  
+  /// Calculate statistical information from the CE graphs for drift time and charge
+
   //reset arrays
   vecTEntries.ResizeTo(72);
   vecTMean.ResizeTo(72);
@@ -340,14 +329,12 @@ void AliTPCcalibDButil::ProcessNoiseData(TVectorD &vNoiseMean, TVectorD &vNoiseM
                       TVectorD &vNoiseRMS, TVectorD &vNoiseRMSSenRegions,
                       Int_t &nonMaskedZero, Int_t &nNaN)
 {
-  //
-  // process noise data
-  // vNoiseMean/RMS contains the Mean/RMS noise of the complete TPC [0], IROCs only [1],
-  //    OROCs small pads [2] and OROCs large pads [3]
-  // vNoiseMean/RMSsenRegions constains the same information, but only for the sensitive regions (edge pads, corners, IROC spot)
-  // nonMaskedZero contains the number of pads which show zero noise and were not masked. This might indicate an error
-  //
-  
+  /// process noise data
+  /// vNoiseMean/RMS contains the Mean/RMS noise of the complete TPC [0], IROCs only [1],
+  ///    OROCs small pads [2] and OROCs large pads [3]
+  /// vNoiseMean/RMSsenRegions constains the same information, but only for the sensitive regions (edge pads, corners, IROC spot)
+  /// nonMaskedZero contains the number of pads which show zero noise and were not masked. This might indicate an error
+
   //set proper size and reset
   const UInt_t infoSize=4;
   vNoiseMean.ResizeTo(infoSize);
@@ -485,11 +472,9 @@ void AliTPCcalibDButil::ProcessNoiseData(TVectorD &vNoiseMean, TVectorD &vNoiseM
 void AliTPCcalibDButil::ProcessQAData(TVectorD &vQaOcc, TVectorD &vQaQtot, 
 				      TVectorD &vQaQmax)
 {
-  //
-  // process QA data
-  //
-  // vQaOcc/Qtot/Qmax contains the Mean occupancy/Qtot/Qmax for each sector
-  //
+  /// process QA data
+  ///
+  /// vQaOcc/Qtot/Qmax contains the Mean occupancy/Qtot/Qmax for each sector
 
 
   const UInt_t infoSize = 72;
@@ -567,10 +552,8 @@ void AliTPCcalibDButil::ProcessQAData(TVectorD &vQaOcc, TVectorD &vQaQtot,
 //_____________________________________________________________________________________
 void AliTPCcalibDButil::ProcessPulser(TVectorD &vMeanTime)
 {
-  //
-  // Process the Pulser information
-  // vMeanTime:     pulser mean time position in IROC-A, IROC-C, OROC-A, OROC-C
-  //
+  /// Process the Pulser information
+  /// vMeanTime:     pulser mean time position in IROC-A, IROC-C, OROC-A, OROC-C
 
   const UInt_t infoSize=4;
   //reset counters to error number
@@ -605,9 +588,8 @@ void AliTPCcalibDButil::ProcessPulser(TVectorD &vMeanTime)
 //_____________________________________________________________________________________
 void AliTPCcalibDButil::ProcessALTROConfig(Int_t &nMasked)
 {
-  //
-  // Get Values from ALTRO configuration data
-  //
+  /// Get Values from ALTRO configuration data
+
   nMasked=-1;
   if (!fALTROMasked) return;
   nMasked=0;
@@ -621,9 +603,9 @@ void AliTPCcalibDButil::ProcessALTROConfig(Int_t &nMasked)
 //_____________________________________________________________________________________
 void AliTPCcalibDButil::ProcessGoofie(TVectorD & vecEntries, TVectorD & vecMedian, TVectorD &vecMean, TVectorD &vecRMS)
 {
-  //
-  // Proces Goofie values, return statistical information of the currently set goofieArray
-  // The meaning of the entries are given below
+  /// Proces Goofie values, return statistical information of the currently set goofieArray
+  /// The meaning of the entries are given below
+
   /*
   1       TPC_ANODE_I_A00_STAT
   2       TPC_DVM_CO2
@@ -691,10 +673,9 @@ void AliTPCcalibDButil::ProcessGoofie(TVectorD & vecEntries, TVectorD & vecMedia
 //_____________________________________________________________________________________
 void AliTPCcalibDButil::ProcessPedestalVariations(TVectorF &pedestalDeviations)
 {
-  //
-  // check the variations of the pedestal data to the reference pedestal data
-  // thresholds are 0.5, 1.0, 1.5 and 2 timebins respectively.
-  //
+  /// check the variations of the pedestal data to the reference pedestal data
+  /// thresholds are 0.5, 1.0, 1.5 and 2 timebins respectively.
+
   const Int_t npar=4;
   TVectorF vThres(npar); //thresholds
   Int_t nActive=0;       //number of active channels
@@ -738,10 +719,9 @@ void AliTPCcalibDButil::ProcessPedestalVariations(TVectorF &pedestalDeviations)
 //_____________________________________________________________________________________
 void AliTPCcalibDButil::ProcessNoiseVariations(TVectorF &noiseDeviations)
 {
-  //
-  // check the variations of the noise data to the reference noise data
-  // thresholds are 5, 10, 15 and 20 percent respectively.
-  //
+  /// check the variations of the noise data to the reference noise data
+  /// thresholds are 5, 10, 15 and 20 percent respectively.
+
   const Int_t npar=4;
   TVectorF vThres(npar); //thresholds
   Int_t nActive=0;       //number of active channels
@@ -787,11 +767,9 @@ void AliTPCcalibDButil::ProcessNoiseVariations(TVectorF &noiseDeviations)
 void AliTPCcalibDButil::ProcessPulserVariations(TVectorF &pulserQdeviations, Float_t &varQMean,
                                                 Int_t &npadsOutOneTB, Int_t &npadsOffAdd)
 {
-  //
-  // check the variations of the pulserQmean data to the reference pulserQmean data: pulserQdeviations
-  // thresholds are .5, 1, 5 and 10 percent respectively.
-  // 
-  //
+  /// check the variations of the pulserQmean data to the reference pulserQmean data: pulserQdeviations
+  /// thresholds are .5, 1, 5 and 10 percent respectively.
+
   const Int_t npar=4;
   TVectorF vThres(npar); //thresholds
   Int_t nActive=0;       //number of active channels
@@ -860,29 +838,26 @@ void AliTPCcalibDButil::ProcessPulserVariations(TVectorF &pulserQdeviations, Flo
 //_____________________________________________________________________________________
 void AliTPCcalibDButil::UpdatePulserOutlierMap()
 {
-  //
-  // Update the outlier map of the pulser data
-  //
+  /// Update the outlier map of the pulser data
+
   PulserOutlierMap(fPulserOutlier,fPulserTmean, fPulserQmean);
 }
 //_____________________________________________________________________________________
 void AliTPCcalibDButil::UpdateRefPulserOutlierMap()
 {
-  //
-  // Update the outlier map of the pulser reference data
-  //
+  /// Update the outlier map of the pulser reference data
+
   PulserOutlierMap(fRefPulserOutlier,fRefPulserTmean, fRefPulserQmean);
 }
 //_____________________________________________________________________________________
 void AliTPCcalibDButil::PulserOutlierMap(AliTPCCalPad *pulOut, const AliTPCCalPad *pulT, const AliTPCCalPad *pulQ)
 {
-  //
-  // Create a map that contains outliers from the Pulser calibration data.
-  // The outliers include masked channels, edge pads and pads with
-  //   too large timing and charge variations.
-  // fNpulserOutliers is the number of outliers in the Pulser calibration data.
-  //   those do not contain masked and edge pads
-  //
+  /// Create a map that contains outliers from the Pulser calibration data.
+  /// The outliers include masked channels, edge pads and pads with
+  ///   too large timing and charge variations.
+  /// fNpulserOutliers is the number of outliers in the Pulser calibration data.
+  ///   those do not contain masked and edge pads
+
   if (!pulT||!pulQ) {
     //reset map
     pulOut->Multiply(0.);
@@ -931,14 +906,13 @@ void AliTPCcalibDButil::PulserOutlierMap(AliTPCCalPad *pulOut, const AliTPCCalPa
 //_____________________________________________________________________________________
 AliTPCCalPad* AliTPCcalibDButil::CreatePadTime0(Int_t model, Double_t &gyA, Double_t &gyC, Double_t &chi2A, Double_t &chi2C )
 {
-  //
-  // Create pad time0 object from pulser and/or CE data, depending on the selected model
-  // Model 0: normalise each readout chamber to its mean, outlier cutted, only Pulser
-  // Model 1: normalise IROCs/OROCs of each readout side to its mean, only Pulser
-  // Model 2: use CE data and a combination CE fit + pulser in the outlier regions.
-  //
-  // In case model 2 is invoked - gy arival time gradient is also returned
-  //
+  /// Create pad time0 object from pulser and/or CE data, depending on the selected model
+  /// Model 0: normalise each readout chamber to its mean, outlier cutted, only Pulser
+  /// Model 1: normalise IROCs/OROCs of each readout side to its mean, only Pulser
+  /// Model 2: use CE data and a combination CE fit + pulser in the outlier regions.
+  ///
+  /// In case model 2 is invoked - gy arival time gradient is also returned
+
   gyA=0;
   gyC=0;
   AliTPCCalPad *padTime0=new AliTPCCalPad("PadTime0",Form("PadTime0-Model_%d",model));
@@ -1026,9 +1000,8 @@ AliTPCCalPad* AliTPCcalibDButil::CreatePadTime0(Int_t model, Double_t &gyA, Doub
 //_____________________________________________________________________________________
 Float_t AliTPCcalibDButil::GetMeanAltro(const AliTPCCalROC *roc, const Int_t row, const Int_t pad, AliTPCCalROC *const rocOut)
 {
-  //
-  // GetMeanAlto information
-  //
+  /// GetMeanAlto information
+
   if (roc==0) return 0.;
   const Int_t sector=roc->GetSector();
   AliTPCROC *tpcRoc=AliTPCROC::Instance();
@@ -1055,9 +1028,8 @@ Float_t AliTPCcalibDButil::GetMeanAltro(const AliTPCCalROC *roc, const Int_t row
 //_____________________________________________________________________________________
 void AliTPCcalibDButil::SetRefFile(const char* filename)
 {
-  //
-  // load cal pad objects form the reference file
-  //
+  /// load cal pad objects form the reference file
+
   TDirectory *currDir=gDirectory;
   TFile f(filename);
   fRefPedestals=(AliTPCCalPad*)f.Get("Pedestals");
@@ -1082,9 +1054,8 @@ void AliTPCcalibDButil::SetRefFile(const char* filename)
 //_____________________________________________________________________________________
 void AliTPCcalibDButil::UpdateRefDataFromOCDB()
 {
-  //
-  // set reference data from OCDB Reference map
-  //
+  /// set reference data from OCDB Reference map
+
   if (!fRefMap) {
     AliWarning("Referenc map not set!");
     return;
@@ -1247,10 +1218,9 @@ void AliTPCcalibDButil::UpdateRefDataFromOCDB()
 //_____________________________________________________________________________________
 AliTPCCalPad* AliTPCcalibDButil::GetRefCalPad(AliCDBEntry *entry, const char* objName)
 {
-  //
-  // TObjArray object type case
-  // find 'objName' in 'arr' cast is to a calPad and store it in 'pad'
-  //
+  /// TObjArray object type case
+  /// find 'objName' in 'arr' cast is to a calPad and store it in 'pad'
+
   AliTPCCalPad *pad=0x0;
   TObjArray *arr=(TObjArray*)entry->GetObject();
   if (!arr){
@@ -1267,10 +1237,9 @@ AliTPCCalPad* AliTPCcalibDButil::GetRefCalPad(AliCDBEntry *entry, const char* ob
 //_____________________________________________________________________________________
 AliTPCCalPad* AliTPCcalibDButil::GetRefCalPad(AliCDBEntry *entry)
 {
-  //
-  // AliTPCCalPad object type case
-  // cast object to a calPad and store it in 'pad'
-  //
+  /// AliTPCCalPad object type case
+  /// cast object to a calPad and store it in 'pad'
+
   AliTPCCalPad *pad=(AliTPCCalPad*)entry->GetObject();
   if (!pad) {
     AliError(Form("Could not get object from entry '%s'\nPlease check!!!",entry->GetId().GetPath().Data()));
@@ -1282,9 +1251,8 @@ AliTPCCalPad* AliTPCcalibDButil::GetRefCalPad(AliCDBEntry *entry)
 //_____________________________________________________________________________________
 AliTPCCalPad* AliTPCcalibDButil::GetAltroMasked(const char* cdbPath, const char* name)
 {
-  //
-  // set altro masked channel map for 'cdbPath'
-  //
+  /// set altro masked channel map for 'cdbPath'
+
   AliTPCCalPad* pad=0x0;
   const Int_t run=GetReferenceRun(cdbPath);
   if (run<0) {
@@ -1304,9 +1272,8 @@ AliTPCCalPad* AliTPCcalibDButil::GetAltroMasked(const char* cdbPath, const char*
 }
 //_____________________________________________________________________________________
 void AliTPCcalibDButil::SetReferenceRun(Int_t run){
-  //
-  // Get Reference map
-  //
+  /// Get Reference map
+
   if (run<0) run=fCalibDB->GetRun();
   TString cdbPath="TPC/Calib/Ref";
   AliCDBEntry *entry=AliCDBManager::Instance()->Get(cdbPath.Data(), run);
@@ -1323,9 +1290,8 @@ void AliTPCcalibDButil::SetReferenceRun(Int_t run){
 //_____________________________________________________________________________________
 Bool_t AliTPCcalibDButil::HasRefChanged(const char *cdbPath)
 {
-  //
-  // check whether a reference cdb entry has changed
-  //
+  /// check whether a reference cdb entry has changed
+
   if (!fCurrentRefMap) return kTRUE;
   if (GetReferenceRun(cdbPath)!=GetCurrentReferenceRun(cdbPath)) return kTRUE;
   return kFALSE;
@@ -1333,9 +1299,8 @@ Bool_t AliTPCcalibDButil::HasRefChanged(const char *cdbPath)
 //_____________________________________________________________________________________
 AliCDBEntry* AliTPCcalibDButil::GetRefEntry(const char* cdbPath)
 {
-  //
-  // get the reference AliCDBEntry for 'cdbPath'
-  //
+  /// get the reference AliCDBEntry for 'cdbPath'
+
   const Int_t run=GetReferenceRun(cdbPath);
   if (run<0) {
     AliError(Form("Could not get reference run number for object '%s'\nPlease check availability!!!",cdbPath));
@@ -1350,9 +1315,8 @@ AliCDBEntry* AliTPCcalibDButil::GetRefEntry(const char* cdbPath)
 }
 //_____________________________________________________________________________________
 Int_t AliTPCcalibDButil::GetCurrentReferenceRun(const char* type) const {
-  //
-  // Get reference run number for the specified OCDB path
-  //
+  /// Get reference run number for the specified OCDB path
+
   if (!fCurrentRefMap) return -2;
   TObjString *str=dynamic_cast<TObjString*>(fCurrentRefMap->GetValue(type));
   if (!str) return -2;
@@ -1360,9 +1324,8 @@ Int_t AliTPCcalibDButil::GetCurrentReferenceRun(const char* type) const {
 }
 //_____________________________________________________________________________________
 Int_t AliTPCcalibDButil::GetReferenceRun(const char* type) const{
-  //
-  // Get reference run number for the specified OCDB path
-  //
+  /// Get reference run number for the specified OCDB path
+
   if (!fRefMap) return -1;
   TObjString *str=dynamic_cast<TObjString*>(fRefMap->GetValue(type));
   if (!str) return -1;
@@ -1370,26 +1333,26 @@ Int_t AliTPCcalibDButil::GetReferenceRun(const char* type) const{
 }
 //_____________________________________________________________________________________
 AliTPCCalPad *AliTPCcalibDButil::CreateCEOutlyerMap( Int_t & noutliersCE, AliTPCCalPad * const ceOut, Float_t minSignal, Float_t cutTrmsMin,  Float_t cutTrmsMax, Float_t cutMaxDistT){
-  //
-  // Author:  marian.ivanov@cern.ch
-  //
-  // Create outlier map for CE study
-  // Parameters:
-  //  Return value - outlyer map
-  //  noutlyersCE  - number of outlyers
-  //  minSignal    - minimal total Q signal
-  //  cutRMSMin    - minimal width of the signal in respect to the median 
-  //  cutRMSMax    - maximal width of the signal in respect to the median 
-  //  cutMaxDistT  - maximal deviation from time median per chamber
-  //
-  // Outlyers criteria:
-  // 0. Exclude masked pads
-  // 1. Exclude first two rows in IROC and last two rows in OROC
-  // 2. Exclude edge pads
-  // 3. Exclude channels with too large variations
-  // 4. Exclude pads with too small signal
-  // 5. Exclude signal with outlyers RMS
-  // 6. Exclude channels to far from the chamber median	
+  /// Author:  marian.ivanov@cern.ch
+  ///
+  /// Create outlier map for CE study
+  /// Parameters:
+  ///  Return value - outlyer map
+  ///  noutlyersCE  - number of outlyers
+  ///  minSignal    - minimal total Q signal
+  ///  cutRMSMin    - minimal width of the signal in respect to the median
+  ///  cutRMSMax    - maximal width of the signal in respect to the median
+  ///  cutMaxDistT  - maximal deviation from time median per chamber
+  ///
+  /// Outlyers criteria:
+  /// 0. Exclude masked pads
+  /// 1. Exclude first two rows in IROC and last two rows in OROC
+  /// 2. Exclude edge pads
+  /// 3. Exclude channels with too large variations
+  /// 4. Exclude pads with too small signal
+  /// 5. Exclude signal with outlyers RMS
+  /// 6. Exclude channels to far from the chamber median
+
   noutliersCE=0;
   //create outlier map
   AliTPCCalPad *out=ceOut;
@@ -1476,21 +1439,21 @@ AliTPCCalPad *AliTPCcalibDButil::CreateCEOutlyerMap( Int_t & noutliersCE, AliTPC
 
 
 AliTPCCalPad *AliTPCcalibDButil::CreatePulserOutlyerMap(Int_t &noutliersPulser, AliTPCCalPad * const pulserOut,Float_t cutTime, Float_t cutnRMSQ, Float_t cutnRMSrms){
-  //
-  // Author: marian.ivanov@cern.ch
-  //
-  // Create outlier map for Pulser
-  // Parameters:
-  //  Return value     - outlyer map
-  //  noutlyersPulser  - number of outlyers
-  //  cutTime          - absolute cut - distance to the median of chamber
-  //  cutnRMSQ         - nsigma cut from median  q distribution per chamber
-  //  cutnRMSrms       - nsigma cut from median  rms distribution 
-  // Outlyers criteria:
-  // 0. Exclude masked pads
-  // 1. Exclude time outlyers (default 3 time bins)
-  // 2. Exclude q outlyers    (default 5 sigma)
-  // 3. Exclude rms outlyers  (default 5 sigma)
+  /// Author: marian.ivanov@cern.ch
+  ///
+  /// Create outlier map for Pulser
+  /// Parameters:
+  ///  Return value     - outlyer map
+  ///  noutlyersPulser  - number of outlyers
+  ///  cutTime          - absolute cut - distance to the median of chamber
+  ///  cutnRMSQ         - nsigma cut from median  q distribution per chamber
+  ///  cutnRMSrms       - nsigma cut from median  rms distribution
+  /// Outlyers criteria:
+  /// 0. Exclude masked pads
+  /// 1. Exclude time outlyers (default 3 time bins)
+  /// 2. Exclude q outlyers    (default 5 sigma)
+  /// 3. Exclude rms outlyers  (default 5 sigma)
+
   noutliersPulser=0;
   AliTPCCalPad *out=pulserOut;
   if (!out)     out= new AliTPCCalPad("outPulser","outPulser");
@@ -1534,40 +1497,37 @@ AliTPCCalPad *AliTPCcalibDButil::CreatePulserOutlyerMap(Int_t &noutliersPulser,
 
 
 AliTPCCalPad *AliTPCcalibDButil::CreatePadTime0CE(TVectorD &fitResultsA, TVectorD&fitResultsC, Int_t &nOut, Double_t &chi2A, Double_t &chi2C, const char *dumpfile){
-  //
-  // Author : Marian Ivanov
-  // Create pad time0 correction map using information from the CE and from pulser
-  //
-  //
-  // Return PadTime0 to be used for time0 relative alignment
-  // if dump file specified intermediat results are dumped to the fiel and can be visualized 
-  // using $ALICE_ROOT/TPC/script/gui application
-  //
-  // fitResultsA - fitParameters A side
-  // fitResultsC - fitParameters C side
-  // chi2A       - chi2/ndf for A side (assuming error 1 time bin)
-  // chi2C       - chi2/ndf for C side (assuming error 1 time bin)
-  //
-  //
-  // Algorithm:
-  // 1. Find outlier map for CE
-  // 2. Find outlier map for Pulser
-  // 3. Replace outlier by median at given sector  (median without outliers)
-  // 4. Substract from the CE data pulser
-  // 5. Fit the CE with formula
-  //    5.1) (IROC-OROC) offset
-  //    5.2) gx
-  //    5.3) gy
-  //    5.4) (lx-xmid)
-  //    5.5) (IROC-OROC)*(lx-xmid)
-  //    5.6) (ly/lx)^2
-  // 6. Substract gy fit dependence from the CE data
-  // 7. Add pulser back to CE data  
-  // 8. Replace outliers by fit value - median of diff per given chamber -GY fit
-  // 9. return CE data
-  //
-  // Time0 <= padCE = padCEin  -padCEfitGy  - if not outlier
-  // Time0 <= padCE = padFitAll-padCEfitGy  - if outlier 
+  /// Author : Marian Ivanov
+  /// Create pad time0 correction map using information from the CE and from pulser
+  ///
+  /// Return PadTime0 to be used for time0 relative alignment
+  /// if dump file specified intermediat results are dumped to the fiel and can be visualized
+  /// using $ALICE_ROOT/TPC/script/gui application
+  ///
+  /// fitResultsA - fitParameters A side
+  /// fitResultsC - fitParameters C side
+  /// chi2A       - chi2/ndf for A side (assuming error 1 time bin)
+  /// chi2C       - chi2/ndf for C side (assuming error 1 time bin)
+  ///
+  /// Algorithm:
+  /// 1. Find outlier map for CE
+  /// 2. Find outlier map for Pulser
+  /// 3. Replace outlier by median at given sector  (median without outliers)
+  /// 4. Substract from the CE data pulser
+  /// 5. Fit the CE with formula
+  ///    5.1) (IROC-OROC) offset
+  ///    5.2) gx
+  ///    5.3) gy
+  ///    5.4) (lx-xmid)
+  ///    5.5) (IROC-OROC)*(lx-xmid)
+  ///    5.6) (ly/lx)^2
+  /// 6. Substract gy fit dependence from the CE data
+  /// 7. Add pulser back to CE data
+  /// 8. Replace outliers by fit value - median of diff per given chamber -GY fit
+  /// 9. return CE data
+  ///
+  /// Time0 <= padCE = padCEin  -padCEfitGy  - if not outlier
+  /// Time0 <= padCE = padFitAll-padCEfitGy  - if outlier
 
   // fit formula
   const char *formulaIn="(-1.+2.*(sector<36))*0.5++gx++gy++(lx-134.)++(-1.+2.*(sector<36))*0.5*(lx-134)++((ly/lx)^2/(0.1763)^2)";
@@ -1695,9 +1655,9 @@ AliTPCCalPad *AliTPCcalibDButil::CreatePadTime0CE(TVectorD &fitResultsA, TVector
 
 
 Int_t AliTPCcalibDButil::GetNearest(TGraph *graph, Double_t xref, Double_t &dx, Double_t &y){
-  //
-  // find the closest point to xref  in x  direction
-  // return dx and value 
+  /// find the closest point to xref  in x  direction
+  /// return dx and value
+
   dx = 0;
   y = 0;
 
@@ -1720,22 +1680,20 @@ Int_t AliTPCcalibDButil::GetNearest(TGraph *graph, Double_t xref, Double_t &dx,
 }
 
 Double_t  AliTPCcalibDButil::GetTriggerOffsetTPC(Int_t run, Int_t timeStamp, Double_t deltaT, Double_t deltaTLaser, Int_t valType){
-  //
-  // Get the correction of the trigger offset
-  // combining information from the laser track calibration 
-  // and from cosmic calibration
-  //
-  // run       - run number
-  // timeStamp - tim stamp in seconds
-  // deltaT    - integration period to calculate offset 
-  // deltaTLaser -max validity of laser data
-  // valType   - 0 - median, 1- mean
-  // 
-  // Integration vaues are just recomendation - if not possible to get points
-  // automatically increase the validity by factor 2  
-  // (recursive algorithm until one month of data taking)
-  //
-  //
+  /// Get the correction of the trigger offset
+  /// combining information from the laser track calibration
+  /// and from cosmic calibration
+  ///
+  /// run       - run number
+  /// timeStamp - tim stamp in seconds
+  /// deltaT    - integration period to calculate offset
+  /// deltaTLaser -max validity of laser data
+  /// valType   - 0 - median, 1- mean
+  ///
+  /// Integration vaues are just recomendation - if not possible to get points
+  /// automatically increase the validity by factor 2
+  /// (recursive algorithm until one month of data taking)
+
   const Float_t kLaserCut=0.0005;
   const Int_t   kMaxPeriod=3600*24*30*12; // one year max
   const Int_t   kMinPoints=20;
@@ -1795,24 +1753,21 @@ Double_t  AliTPCcalibDButil::GetTriggerOffsetTPC(Int_t run, Int_t timeStamp, Dou
 }
 
 Double_t  AliTPCcalibDButil::GetVDriftTPC(Double_t &dist, Int_t run, Int_t timeStamp, Double_t deltaT, Double_t deltaTLaser, Int_t valType){
-  //
-  // Get the correction of the drift velocity
-  // combining information from the laser track calibration 
-  // and from cosmic calibration
-  //
-  // dist      - return value - distance to closest point in graph
-  // run       - run number
-  // timeStamp - tim stamp in seconds
-  // deltaT    - integration period to calculate time0 offset 
-  // deltaTLaser -max validity of laser data
-  // valType   - 0 - median, 1- mean
-  // 
-  // Integration vaues are just recomendation - if not possible to get points
-  // automatically increase the validity by factor 2  
-  // (recursive algorithm until one month of data taking)
-  //
-  //
-  //
+  /// Get the correction of the drift velocity
+  /// combining information from the laser track calibration
+  /// and from cosmic calibration
+  ///
+  /// dist      - return value - distance to closest point in graph
+  /// run       - run number
+  /// timeStamp - tim stamp in seconds
+  /// deltaT    - integration period to calculate time0 offset
+  /// deltaTLaser -max validity of laser data
+  /// valType   - 0 - median, 1- mean
+  ///
+  /// Integration vaues are just recomendation - if not possible to get points
+  /// automatically increase the validity by factor 2
+  /// (recursive algorithm until one month of data taking)
+
   TObjArray *array =AliTPCcalibDB::Instance()->GetTimeVdriftSplineRun(run);
   if (!array) {
     AliTPCcalibDB::Instance()->UpdateRunInformations(run,kFALSE); 
@@ -1853,21 +1808,18 @@ Double_t  AliTPCcalibDButil::GetVDriftTPC(Double_t &dist, Int_t run, Int_t timeS
 
 const char* AliTPCcalibDButil::GetGUIRefTreeDefaultName()
 {
-  //
-  // Create a default name for the gui file
-  //
-  
+  /// Create a default name for the gui file
+
   return Form("guiRefTreeRun%s.root",GetRefValidity());
 }
 
 Bool_t AliTPCcalibDButil::CreateGUIRefTree(const char* filename)
 {
-  //
-  // Create a gui reference tree
-  // if dirname and filename are empty default values will be used
-  // this is the recommended way of using this function
-  // it allows to check whether a file with the given run validity alredy exists
-  //
+  /// Create a gui reference tree
+  /// if dirname and filename are empty default values will be used
+  /// this is the recommended way of using this function
+  /// it allows to check whether a file with the given run validity alredy exists
+
   if (!AliCDBManager::Instance()->GetDefaultStorage()){
     AliError("Default Storage not set. Cannot create reference calibration Tree!");
     return kFALSE;
@@ -1920,28 +1872,28 @@ Bool_t AliTPCcalibDButil::CreateGUIRefTree(const char* filename)
 }
 
 Double_t  AliTPCcalibDButil::GetVDriftTPCLaserTracks(Double_t &dist, Int_t run, Int_t timeStamp, Double_t deltaT, Int_t side){
-  //
-  // Get the correction of the drift velocity using the offline laser tracks calbration
-  //
-  // run       - run number
-  // timeStamp - tim stamp in seconds
-  // deltaT    - integration period to calculate time0 offset 
-  // side      - 0 - A side,  1 - C side, 2 - mean from both sides
-  // Note in case no data form both A and C side - the value from active side used
+  /// Get the correction of the drift velocity using the offline laser tracks calbration
+  ///
+  /// run       - run number
+  /// timeStamp - tim stamp in seconds
+  /// deltaT    - integration period to calculate time0 offset
+  /// side      - 0 - A side,  1 - C side, 2 - mean from both sides
+  /// Note in case no data form both A and C side - the value from active side used
+
   TObjArray *array =AliTPCcalibDB::Instance()->GetTimeVdriftSplineRun(run);
 
   return GetVDriftTPCLaserTracksCommon(dist, timeStamp, deltaT, side, array);
 }
 
 Double_t  AliTPCcalibDButil::GetVDriftTPCLaserTracksOnline(Double_t &dist, Int_t /*run*/, Int_t timeStamp, Double_t deltaT, Int_t side){
-  //
-  // Get the correction of the drift velocity using the online laser tracks calbration
-  //
-  // run       - run number
-  // timeStamp - tim stamp in seconds
-  // deltaT    - integration period to calculate time0 offset
-  // side      - 0 - A side,  1 - C side, 2 - mean from both sides
-  // Note in case no data form both A and C side - the value from active side used
+  /// Get the correction of the drift velocity using the online laser tracks calbration
+  ///
+  /// run       - run number
+  /// timeStamp - tim stamp in seconds
+  /// deltaT    - integration period to calculate time0 offset
+  /// side      - 0 - A side,  1 - C side, 2 - mean from both sides
+  /// Note in case no data form both A and C side - the value from active side used
+
   TObjArray *array =AliTPCcalibDB::Instance()->GetCEfitsDrift();
 
   Double_t dv = GetVDriftTPCLaserTracksCommon(dist, timeStamp, deltaT, side, array);
@@ -1976,9 +1928,8 @@ Double_t  AliTPCcalibDButil::GetVDriftTPCLaserTracksOnline(Double_t &dist, Int_t
 
 Double_t  AliTPCcalibDButil::GetVDriftTPCLaserTracksCommon(Double_t &dist, Int_t timeStamp, Double_t deltaT,
   Int_t side, TObjArray * const array){
-  //
-  // common drift velocity retrieval for online and offline method
-  //
+  /// common drift velocity retrieval for online and offline method
+
   TGraphErrors *grlaserA=0;
   TGraphErrors *grlaserC=0;
   Double_t vlaserA=0, vlaserC=0;
@@ -2006,15 +1957,15 @@ Double_t  AliTPCcalibDButil::GetVDriftTPCLaserTracksCommon(Double_t &dist, Int_t
 
 
 Double_t  AliTPCcalibDButil::GetVDriftTPCCE(Double_t &dist,Int_t run, Int_t timeStamp, Double_t deltaT, Int_t side){
-  //
-  // Get the correction of the drift velocity using the CE laser data
-  // combining information from the CE,  laser track calibration
-  // and P/T calibration 
-  //
-  // run       - run number
-  // timeStamp - tim stamp in seconds
-  // deltaT    - integration period to calculate time0 offset 
-  // side      - 0 - A side,  1 - C side, 2 - mean from both sides
+  /// Get the correction of the drift velocity using the CE laser data
+  /// combining information from the CE,  laser track calibration
+  /// and P/T calibration
+  ///
+  /// run       - run number
+  /// timeStamp - tim stamp in seconds
+  /// deltaT    - integration period to calculate time0 offset
+  /// side      - 0 - A side,  1 - C side, 2 - mean from both sides
+
   TObjArray *arrT     =AliTPCcalibDB::Instance()->GetCErocTtime();
   if (!arrT) return 0;
   AliTPCParam *param  =AliTPCcalibDB::Instance()->GetParameters();
@@ -2061,10 +2012,9 @@ if (driftCalib) corrPTC =  driftCalib->GetPTRelative(timeStamp,0);
 }
 
 Double_t  AliTPCcalibDButil::GetVDriftTPCITS(Double_t &dist, Int_t run, Int_t timeStamp){
-  //
-  // return drift velocity using the TPC-ITS matchin method
-  // return also distance to the closest point
-  //
+  /// return drift velocity using the TPC-ITS matchin method
+  /// return also distance to the closest point
+
   TObjArray *array =AliTPCcalibDB::Instance()->GetTimeVdriftSplineRun(run);
   TGraphErrors *graph=0;
   dist=0;
@@ -2080,14 +2030,13 @@ Double_t  AliTPCcalibDButil::GetVDriftTPCITS(Double_t &dist, Int_t run, Int_t ti
 }
 
 Double_t AliTPCcalibDButil::GetTime0TPCITS(Double_t &dist, Int_t run, Int_t timeStamp){
-  //
-  // Get time dependent time 0 (trigger delay in cm) correction
-  // Arguments:
-  // timestamp - timestamp
-  // run       - run number
-  //
-  // Notice - Extrapolation outside of calibration range  - using constant function
-  //
+  /// Get time dependent time 0 (trigger delay in cm) correction
+  /// Arguments:
+  /// timestamp - timestamp
+  /// run       - run number
+  ///
+  /// Notice - Extrapolation outside of calibration range  - using constant function
+
   TObjArray *array =AliTPCcalibDB::Instance()->GetTimeVdriftSplineRun(run);
   TGraphErrors *graph=0;
   dist=0;
@@ -2106,11 +2055,10 @@ Double_t AliTPCcalibDButil::GetTime0TPCITS(Double_t &dist, Int_t run, Int_t time
 
 
 Int_t  AliTPCcalibDButil::MakeRunList(Int_t startRun, Int_t stopRun){
-  //
-  // VERY obscure method - we need something in framework
-  // Find the TPC runs with temperature OCDB entry
-  // cache the start and end of the run
-  //
+  /// VERY obscure method - we need something in framework
+  /// Find the TPC runs with temperature OCDB entry
+  /// cache the start and end of the run
+
   AliCDBStorage* storage = AliCDBManager::Instance()->GetSpecificStorage("TPC/Calib/Temperature");
   if (!storage) storage = AliCDBManager::Instance()->GetDefaultStorage();
   if (!storage) return 0;
@@ -2161,9 +2109,8 @@ Int_t  AliTPCcalibDButil::MakeRunList(Int_t startRun, Int_t stopRun){
 
 
 Int_t AliTPCcalibDButil::FindRunTPC(Int_t    itime, Bool_t debug){
-  //
-  // binary search - find the run for given time stamp
-  //
+  /// binary search - find the run for given time stamp
+
   Int_t index0  = TMath::BinarySearch(fRuns.fN, fRunsStop.fArray,itime);
   Int_t index1  = TMath::BinarySearch(fRuns.fN, fRunsStart.fArray,itime);
   Int_t cindex  = -1;
@@ -2185,9 +2132,9 @@ Int_t AliTPCcalibDButil::FindRunTPC(Int_t    itime, Bool_t debug){
 
 
 TGraph* AliTPCcalibDButil::FilterGraphMedian(TGraph * graph, Float_t sigmaCut,Double_t &medianY){
-  //
-  // filter outlyer measurement
-  // Only points around median +- sigmaCut filtered 
+  /// filter outlyer measurement
+  /// Only points around median +- sigmaCut filtered
+
   if (!graph) return  0;
   Int_t kMinPoints=2;
   Int_t npoints0 = graph->GetN();
@@ -2221,9 +2168,9 @@ TGraph* AliTPCcalibDButil::FilterGraphMedian(TGraph * graph, Float_t sigmaCut,Do
 
 
 TGraph* AliTPCcalibDButil::FilterGraphMedianAbs(TGraph * graph, Float_t cut,Double_t &medianY){
-  //
-  // filter outlyer measurement
-  // Only points around median +- cut filtered 
+  /// filter outlyer measurement
+  /// Only points around median +- cut filtered
+
   if (!graph) return  0;
   Int_t kMinPoints=2;
   Int_t npoints0 = graph->GetN();
@@ -2258,10 +2205,9 @@ TGraph* AliTPCcalibDButil::FilterGraphMedianAbs(TGraph * graph, Float_t cut,Doub
 
 
 TGraphErrors* AliTPCcalibDButil::FilterGraphMedianErr(TGraphErrors * const graph, Float_t sigmaCut,Double_t &medianY){
-  //
-  // filter outlyer measurement
-  // Only points with normalized errors median +- sigmaCut filtered
-  //
+  /// filter outlyer measurement
+  /// Only points with normalized errors median +- sigmaCut filtered
+
   Int_t kMinPoints=10;
   Int_t npoints0 = graph->GetN();
   Int_t npoints=0;
@@ -2304,9 +2250,8 @@ TGraphErrors* AliTPCcalibDButil::FilterGraphMedianErr(TGraphErrors * const graph
 
 
 void AliTPCcalibDButil::Sort(TGraph *graph){
-  //
-  // sort array - neccessay for approx
-  //
+  /// sort array - neccessay for approx
+
   Int_t npoints = graph->GetN();
   Int_t *indexes=new Int_t[npoints];
   Double_t *outx=new Double_t[npoints];
@@ -2322,9 +2267,8 @@ void AliTPCcalibDButil::Sort(TGraph *graph){
   delete [] outy;
 }
 void AliTPCcalibDButil::SmoothGraph(TGraph *graph, Double_t delta){
-  //
-  // smmoth graph - mean on the interval
-  //
+  /// smmoth graph - mean on the interval
+
   Sort(graph);
   Int_t npoints = graph->GetN();
   Double_t *outy=new Double_t[npoints];
@@ -2366,9 +2310,8 @@ void AliTPCcalibDButil::SmoothGraph(TGraph *graph, Double_t delta){
 }
 
 Double_t AliTPCcalibDButil::EvalGraphConst(TGraph * const graph, Double_t xref){
-  //
-  // Use constant interpolation outside of range 
-  //
+  /// Use constant interpolation outside of range
+
   if (!graph) {
     AliInfoGeneral("AliTPCcalibDButil","AliTPCcalibDButil::EvalGraphConst: 0 pointer\n");
     return 0;
@@ -2393,9 +2336,8 @@ Double_t AliTPCcalibDButil::EvalGraphConst(TGraph * const graph, Double_t xref){
 }
 
 Double_t AliTPCcalibDButil::EvalGraphConst(AliSplineFit *graph, Double_t xref){
-  //
-  // Use constant interpolation outside of range also for spline fits
-  //
+  /// Use constant interpolation outside of range also for spline fits
+
   if (!graph) {
     AliInfoGeneral("AliTPCcalibDButil","AliTPCcalibDButil::EvalGraphConst: 0 pointer\n");
     return 0;
@@ -2410,20 +2352,19 @@ Double_t AliTPCcalibDButil::EvalGraphConst(AliSplineFit *graph, Double_t xref){
 }
 
 Float_t AliTPCcalibDButil::FilterSensor(AliDCSSensor * sensor, Double_t ymin, Double_t ymax, Double_t maxdy,  Double_t sigmaCut){
-  //
-  // Filter DCS sensor information
-  //   ymin     - minimal value
-  //   ymax     - max value
-  //   maxdy    - maximal deirivative
-  //   sigmaCut - cut on values and derivative in terms of RMS distribution
-  // Return value - accepted fraction
-  // 
-  // Algorithm:
-  //
-  // 0. Calculate median and rms of values in specified range
-  // 1. Filter out outliers - median+-sigmaCut*rms
-  //    values replaced by median
-  //
+  /// Filter DCS sensor information
+  ///   ymin     - minimal value
+  ///   ymax     - max value
+  ///   maxdy    - maximal deirivative
+  ///   sigmaCut - cut on values and derivative in terms of RMS distribution
+  /// Return value - accepted fraction
+  ///
+  /// Algorithm:
+  ///
+  /// 0. Calculate median and rms of values in specified range
+  /// 1. Filter out outliers - median+-sigmaCut*rms
+  ///    values replaced by median
+
   AliSplineFit * fit    = sensor->GetFit();
   if (!fit) return 0.;
   Int_t          nknots = fit->GetKnots();
@@ -2484,13 +2425,13 @@ Float_t AliTPCcalibDButil::FilterSensor(AliDCSSensor * sensor, Double_t ymin, Do
 }
 
 Float_t  AliTPCcalibDButil::FilterTemperature(AliTPCSensorTempArray *tempArray, Double_t ymin, Double_t ymax, Double_t sigmaCut){
-  //
-  // Filter temperature array
-  // tempArray    - array of temperatures         -
-  // ymin         - minimal accepted temperature  - default 15
-  // ymax         - maximal accepted temperature  - default 22
-  // sigmaCut     - values filtered on interval median+-sigmaCut*rms - defaut 5
-  // return value - fraction of filtered sensors
+  /// Filter temperature array
+  /// tempArray    - array of temperatures         -
+  /// ymin         - minimal accepted temperature  - default 15
+  /// ymax         - maximal accepted temperature  - default 22
+  /// sigmaCut     - values filtered on interval median+-sigmaCut*rms - defaut 5
+  /// return value - fraction of filtered sensors
+
   const Double_t kMaxDy=0.1;
   Int_t nsensors=tempArray->NumSensors();
   if (nsensors==0) return 0.;
@@ -2511,24 +2452,23 @@ Float_t  AliTPCcalibDButil::FilterTemperature(AliTPCSensorTempArray *tempArray,
 
 
 void AliTPCcalibDButil::FilterCE(Double_t deltaT, Double_t cutAbs, Double_t cutSigma, TTreeSRedirector * const pcstream){
-  //
-  // Filter CE data
-  // Input parameters:
-  //    deltaT   - smoothing window (in seconds)
-  //    cutAbs   - max distance of the time info to the median (in time bins)
-  //    cutSigma - max distance (in the RMS)
-  //    pcstream - optional debug streamer to store original and filtered info
-  // Hardwired parameters:
-  //    kMinPoints =10;       // minimal number of points to define the CE
-  //    kMinSectors=12;       // minimal number of sectors to define sideCE
-  // Algorithm:
-  // 0. Filter almost emty graphs (kMinPoints=10)
-  // 1. calculate median and RMS per side
-  // 2. Filter graphs - in respect with side medians 
-  //                  - cutAbs and cutDelta used
-  // 3. Cut in respect wit the graph median - cutAbs and cutRMS used
-  // 4. Calculate mean for A side and C side
-  //
+  /// Filter CE data
+  /// Input parameters:
+  ///    deltaT   - smoothing window (in seconds)
+  ///    cutAbs   - max distance of the time info to the median (in time bins)
+  ///    cutSigma - max distance (in the RMS)
+  ///    pcstream - optional debug streamer to store original and filtered info
+  /// Hardwired parameters:
+  ///    kMinPoints =10;       // minimal number of points to define the CE
+  ///    kMinSectors=12;       // minimal number of sectors to define sideCE
+  /// Algorithm:
+  /// 0. Filter almost emty graphs (kMinPoints=10)
+  /// 1. calculate median and RMS per side
+  /// 2. Filter graphs - in respect with side medians
+  ///                  - cutAbs and cutDelta used
+  /// 3. Cut in respect wit the graph median - cutAbs and cutRMS used
+  /// 4. Calculate mean for A side and C side
+
   const Int_t kMinPoints =10;       // minimal number of points to define the CE
   const Int_t kMinSectors=12;       // minimal number of sectors to define sideCE
   const Int_t kMinTime   =400;     // minimal arrival time of CE
@@ -2716,12 +2656,10 @@ void AliTPCcalibDButil::FilterCE(Double_t deltaT, Double_t cutAbs, Double_t cutS
 
 
 void AliTPCcalibDButil::FilterTracks(Int_t run, Double_t cutSigma, TTreeSRedirector * const pcstream){
-  //
-  // Filter Drift velocity measurement using the tracks
-  // 0.  remove outlyers - error based
-  //     cutSigma      
-  //
-  //
+  /// Filter Drift velocity measurement using the tracks
+  /// 0.  remove outlyers - error based
+  ///     cutSigma
+
   const Int_t kMinPoints=1;  // minimal number of points to define value
   TObjArray *arrT=AliTPCcalibDB::Instance()->GetTimeVdriftSplineRun(run);
   Double_t medianY=0;
@@ -2771,13 +2709,11 @@ void AliTPCcalibDButil::FilterTracks(Int_t run, Double_t cutSigma, TTreeSRedirec
 
 
 Double_t AliTPCcalibDButil::GetLaserTime0(Int_t run, Int_t timeStamp, Int_t deltaT, Int_t side){
-  //
-  //
-  // get laser time offset 
-  // median around timeStamp+-deltaT   
-  // QA - chi2 needed for later usage - to be added
-  //    - currently cut on error
-  //
+  /// get laser time offset
+  /// median around timeStamp+-deltaT
+  /// QA - chi2 needed for later usage - to be added
+  ///    - currently cut on error
+
   Int_t kMinPoints=1;
   Double_t kMinDelay=0.01;
   Double_t kMinDelayErr=0.0001;
@@ -2827,16 +2763,15 @@ Double_t AliTPCcalibDButil::GetLaserTime0(Int_t run, Int_t timeStamp, Int_t delt
 
 
 void AliTPCcalibDButil::FilterGoofie(AliDCSSensorArray * goofieArray, Double_t deltaT, Double_t cutSigma, Double_t minVd, Double_t maxVd, TTreeSRedirector * const pcstream){
-  //
-  // Filter Goofie data
-  // goofieArray - points will be filtered
-  // deltaT      - smmothing time window 
-  // cutSigma    - outler sigma cut in rms
-  // minVn, maxVd- range absolute cut for variable vd/pt
-  //             - to be tuned
-  //
-  // Ignore goofie if not enough points
-  //
+  /// Filter Goofie data
+  /// goofieArray - points will be filtered
+  /// deltaT      - smmothing time window
+  /// cutSigma    - outler sigma cut in rms
+  /// minVn, maxVd- range absolute cut for variable vd/pt
+  ///             - to be tuned
+  ///
+  /// Ignore goofie if not enough points
+
   const Int_t kMinPoints = 3;
   //
 
@@ -2997,16 +2932,16 @@ void AliTPCcalibDButil::FilterGoofie(AliDCSSensorArray * goofieArray, Double_t d
 
 
 TMatrixD* AliTPCcalibDButil::MakeStatRelKalman(TObjArray * const array, Float_t minFraction, Int_t minStat, Float_t maxvd){
-  //
-  // Make a statistic matrix
-  // Input parameters:
-  //   array        - TObjArray of AliRelKalmanAlign 
-  //   minFraction  - minimal ration of accepted tracks
-  //   minStat      - minimal statistic (number of accepted tracks)
-  //   maxvd        - maximal deviation for the 1
-  // Output matrix:
-  //    columns    - Mean, Median, RMS
-  //    row        - parameter type (rotation[3], translation[3], drift[3])
+  /// Make a statistic matrix
+  /// Input parameters:
+  ///   array        - TObjArray of AliRelKalmanAlign
+  ///   minFraction  - minimal ration of accepted tracks
+  ///   minStat      - minimal statistic (number of accepted tracks)
+  ///   maxvd        - maximal deviation for the 1
+  /// Output matrix:
+  ///    columns    - Mean, Median, RMS
+  ///    row        - parameter type (rotation[3], translation[3], drift[3])
+
   if (!array) return 0;
   if (array->GetEntries()<=0) return 0;
   //  Int_t entries = array->GetEntries();
@@ -3045,13 +2980,13 @@ TMatrixD* AliTPCcalibDButil::MakeStatRelKalman(TObjArray * const array, Float_t
 
 
 TObjArray *AliTPCcalibDButil::SmoothRelKalman(TObjArray * const array, const TMatrixD & stat, Bool_t direction, Float_t sigmaCut){
-  //
-  // Smooth the array of AliRelKalmanAlign - detector alignment and drift calibration)
-  // Input:
-  //   array     - input array
-  //   stat      - mean parameters statistic
-  //   direction - 
-  //   sigmaCut  - maximal allowed deviation from mean in terms of RMS 
+  /// Smooth the array of AliRelKalmanAlign - detector alignment and drift calibration)
+  /// Input:
+  ///   array     - input array
+  ///   stat      - mean parameters statistic
+  ///   direction -
+  ///   sigmaCut  - maximal allowed deviation from mean in terms of RMS
+
   if (!array) return 0;
   if (array->GetEntries()<=0) return 0;
   if (!(&stat)) return 0;
@@ -3104,11 +3039,11 @@ TObjArray *AliTPCcalibDButil::SmoothRelKalman(TObjArray * const array, const TMa
 }
 
 TObjArray *AliTPCcalibDButil::SmoothRelKalman(TObjArray * const arrayP, TObjArray * const arrayM){
-  //
-  // Merge 2 RelKalman arrays
-  // Input:
-  //   arrayP    - rel kalman in direction plus
-  //   arrayM    - rel kalman in direction minus
+  /// Merge 2 RelKalman arrays
+  /// Input:
+  ///   arrayP    - rel kalman in direction plus
+  ///   arrayM    - rel kalman in direction minus
+
   if (!arrayP) return 0;
   if (arrayP->GetEntries()<=0) return 0;
   if (!arrayM) return 0;
@@ -3146,15 +3081,13 @@ TObjArray *AliTPCcalibDButil::SmoothRelKalman(TObjArray * const arrayP, TObjArra
 //_____________________________________________________________________________________
 TTree* AliTPCcalibDButil::ConnectGainTrees(TString baseDir)
 {
-  //
-  // baseDir:   Base directory with the raw Kr calibration trees
-  //            and the trees from the calibQA
-  //            it assumes to following structure below:
-  //            KryptonCalib/<year>/calibKr/calibKr.<year>.<id>.root
-  //            calibQAdEdx/<year>/calibQA.<year>.<perid>.tree.root
-  //            map/treeMapping.root
-  //
-  
+  /// baseDir:   Base directory with the raw Kr calibration trees
+  ///            and the trees from the calibQA
+  ///            it assumes to following structure below:
+  ///            KryptonCalib/<year>/calibKr/calibKr.<year>.<id>.root
+  ///            calibQAdEdx/<year>/calibQA.<year>.<perid>.tree.root
+  ///            map/treeMapping.root
+
   
   // === add main tree, which will be a mapping file ================
   TFile *fin = TFile::Open(Form("%s/map/treeMapping.root",baseDir.Data()));
@@ -3288,11 +3221,11 @@ TTree* AliTPCcalibDButil::ConnectGainTrees(TString baseDir)
 //_____________________________________________________________________________________
 TTree* AliTPCcalibDButil::ConnectPulserTrees(TString baseDir, TTree *tMain)
 {
-  //
-  // baseDir:   Base directory with Pulser information
-  // TTrees are added to the base tree as a friend tree
-  //  
-  // === add the calibPulser trees ======================================
+  /// baseDir:   Base directory with Pulser information
+  /// TTrees are added to the base tree as a friend tree
+  ///
+  /// === add the calibPulser trees ======================================
+
   TString inputTreesPulserCalib       = gSystem->GetFromPipe(Form("ls %s/calibPulser/20*/*.tree.root",baseDir.Data()));
   TObjArray *arrInputTreesPulserCalib = inputTreesPulserCalib.Tokenize("\n");
   for (Int_t itree=0; itree<arrInputTreesPulserCalib->GetEntriesFast(); ++itree) {
@@ -3331,15 +3264,14 @@ TTree* AliTPCcalibDButil::ConnectPulserTrees(TString baseDir, TTree *tMain)
   
 
 TTree* AliTPCcalibDButil::ConnectDistortionTrees(TString baseDir, TString  selection,  TTree *tMain){
-  //
-  // baseDir:   Base directory with Distortion information
-  // TTrees are added to the base tree as a friend tree
-  // If base tree not provide - first tree from list is used as base
-  //  
-  // === add the calibDistortion trees ======================================
-  //TString inputTreesDistortionCalib       = gSystem->GetFromPipe(Form("ls %s/calibDistortion/20*/*.tree.root",baseDir.Data()));
-  // TString baseDir="$NOTES/reconstruction/distortionFit/"; TTree *tMain=0;
-  // AliTPCcalibDButil::ConnectDistortionTrees("$NOTES/reconstruction/distortionFit/", "calibTimeResHisto.root", 0);
+  /// baseDir:   Base directory with Distortion information
+  /// TTrees are added to the base tree as a friend tree
+  /// If base tree not provide - first tree from list is used as base
+  ///
+  /// === add the calibDistortion trees ======================================
+  /// TString inputTreesDistortionCalib       = gSystem->GetFromPipe(Form("ls %s/calibDistortion/20*/*.tree.root",baseDir.Data()));
+  /// TString baseDir="$NOTES/reconstruction/distortionFit/"; TTree *tMain=0;
+  /// AliTPCcalibDButil::ConnectDistortionTrees("$NOTES/reconstruction/distortionFit/", "calibTimeResHisto.root", 0);
 
   TString inputTreesDistortionCalib       = "";
   if (selection.Contains(".list")){    
@@ -3393,13 +3325,12 @@ TTree* AliTPCcalibDButil::ConnectDistortionTrees(TString baseDir, TString  selec
 //_____________________________________________________________________________________
 TTree* AliTPCcalibDButil::ConnectCalPadTrees(TString baseDir, TString pattern, TTree *tMain, Bool_t checkAliases)
 {
-  //
-  // baseDir:   Base directory with per Pad information
-  // TTrees are added to the base tree as a friend tree
-  // Example usage
-  //   TString baseDir="/hera/alice/fsozzi/summarymaps/calib2/";  // prefix directory with calibration with slash at the end
-  //   TString pattern="QA/*/*root";  
-  //   TTree * tree =  AliTPCcalibDButil::ConnectCalPadTrees(baseDir,pattern,0);   //create tree and attach calibration as friends
+  /// baseDir:   Base directory with per Pad information
+  /// TTrees are added to the base tree as a friend tree
+  /// Example usage
+  ///   TString baseDir="/hera/alice/fsozzi/summarymaps/calib2/";  // prefix directory with calibration with slash at the end
+  ///   TString pattern="QA/*/*root";
+  ///   TTree * tree =  AliTPCcalibDButil::ConnectCalPadTrees(baseDir,pattern,0);   //create tree and attach calibration as friends
 
   //  
   // === add the calibPulser trees ======================================
diff --git a/TPC/TPCbase/AliTPCcalibDButil.h b/TPC/TPCbase/AliTPCcalibDButil.h
index 137e6ce7b68..14e1eb24750 100644
--- a/TPC/TPCbase/AliTPCcalibDButil.h
+++ b/TPC/TPCbase/AliTPCcalibDButil.h
@@ -4,12 +4,8 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-///////////////////////////////////////////////////////////////////////////////
-//                                                                           //
-// Class providing the calculation of derived quantities (mean,rms,fits,...) //
-//       of calibration entries                                              //
-//                                                                           //
-///////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCcalibDButil
+/// \brief Class providing the calculation of derived quantities (mean,rms,fits,...) of calibration entries
 
 #include <TObject.h>
 #include <TArrayI.h>
@@ -185,67 +181,67 @@ public:
   static  TTree* ConnectCalPadTrees(TString baseDir, TString pattern,  TTree *tMain, Bool_t checkAliases);
 
 private:
-  AliTPCcalibDB *fCalibDB;            //pointer to calibDB object
-  AliTPCCalPad  *fPadNoise;           //noise information
-  AliTPCCalPad  *fPedestals;          //pedestal information
-  AliTPCCalPad  *fPulserTmean;        //pulser mean time information 
-  AliTPCCalPad  *fPulserTrms;         //pulser rms time information
-  AliTPCCalPad  *fPulserQmean;        //pulser mean q information
-  AliTPCCalPad  *fPulserOutlier;      //pulser outlier map
-  AliTPCCalPad  *fCETmean;            //central electrode mean time information
-  AliTPCCalPad  *fCETrms;             //central electrode rms time information
-  AliTPCCalPad  *fCEQmean;            //central electrode mean q information
-  AliTPCCalPad  *fALTROMasked;        //ALTRO masked channels information
+  AliTPCcalibDB *fCalibDB;            ///< pointer to calibDB object
+  AliTPCCalPad  *fPadNoise;           ///< noise information
+  AliTPCCalPad  *fPedestals;          ///< pedestal information
+  AliTPCCalPad  *fPulserTmean;        ///< pulser mean time information
+  AliTPCCalPad  *fPulserTrms;         ///< pulser rms time information
+  AliTPCCalPad  *fPulserQmean;        ///< pulser mean q information
+  AliTPCCalPad  *fPulserOutlier;      ///< pulser outlier map
+  AliTPCCalPad  *fCETmean;            ///< central electrode mean time information
+  AliTPCCalPad  *fCETrms;             ///< central electrode rms time information
+  AliTPCCalPad  *fCEQmean;            ///< central electrode mean q information
+  AliTPCCalPad  *fALTROMasked;        ///< ALTRO masked channels information
   //
-  AliTPCCalibRaw *fCalibRaw;          //raw calibration object
+  AliTPCCalibRaw *fCalibRaw;          ///< raw calibration object
   //
-  AliTPCdataQA   *fDataQA;            //data qa
+  AliTPCdataQA   *fDataQA;            ///< data qa
   //reference data
-  TMap *fRefMap;                        // latest map to reference information
-  TMap *fCurrentRefMap;                 // reference data map of entries currently loaded
-  TString fRefValidity;                 // validity range of reference data
+  TMap *fRefMap;                        ///< latest map to reference information
+  TMap *fCurrentRefMap;                 ///< reference data map of entries currently loaded
+  TString fRefValidity;                 ///< validity range of reference data
   //  
-  AliTPCCalPad  *fRefPadNoise;           //Reference noise information
-  AliTPCCalPad  *fRefPedestals;          //Reference pedestal information
-  AliTPCCalPad  *fRefPedestalMasked;     //Reference masked channels in pedestal run
-  AliTPCCalPad  *fRefPulserTmean;        //Reference pulser mean time information
-  AliTPCCalPad  *fRefPulserTrms;         //Reference pulser rms time information
-  AliTPCCalPad  *fRefPulserQmean;        //Reference pulser mean q information
-  AliTPCCalPad  *fRefPulserOutlier;      //Reference pulser outlier map
-  AliTPCCalPad  *fRefPulserMasked;       //Reference masked channels in pulser run
-  AliTPCCalPad  *fRefCETmean;            //Reference central electrode mean time information
-  AliTPCCalPad  *fRefCETrms;             //Reference central electrode rms time information
-  AliTPCCalPad  *fRefCEQmean;            //Reference central electrode mean q information
-  AliTPCCalPad  *fRefCEMasked;           //Reference masked channels in laser run
-  AliTPCCalPad  *fRefALTROFPED;          //Reference fixed pedestal value
-  AliTPCCalPad  *fRefALTROZsThr;         //Reference zero suppression threshol
-  AliTPCCalPad  *fRefALTROAcqStart;      //Reference accquistion start time bin
-  AliTPCCalPad  *fRefALTROAcqStop;       //Reference accquistion stop time bin
-  AliTPCCalPad  *fRefALTROMasked;        //Reference ALTRO masked channels information
+  AliTPCCalPad  *fRefPadNoise;           ///< Reference noise information
+  AliTPCCalPad  *fRefPedestals;          ///< Reference pedestal information
+  AliTPCCalPad  *fRefPedestalMasked;     ///< Reference masked channels in pedestal run
+  AliTPCCalPad  *fRefPulserTmean;        ///< Reference pulser mean time information
+  AliTPCCalPad  *fRefPulserTrms;         ///< Reference pulser rms time information
+  AliTPCCalPad  *fRefPulserQmean;        ///< Reference pulser mean q information
+  AliTPCCalPad  *fRefPulserOutlier;      ///< Reference pulser outlier map
+  AliTPCCalPad  *fRefPulserMasked;       ///< Reference masked channels in pulser run
+  AliTPCCalPad  *fRefCETmean;            ///< Reference central electrode mean time information
+  AliTPCCalPad  *fRefCETrms;             ///< Reference central electrode rms time information
+  AliTPCCalPad  *fRefCEQmean;            ///< Reference central electrode mean q information
+  AliTPCCalPad  *fRefCEMasked;           ///< Reference masked channels in laser run
+  AliTPCCalPad  *fRefALTROFPED;          ///< Reference fixed pedestal value
+  AliTPCCalPad  *fRefALTROZsThr;         ///< Reference zero suppression threshol
+  AliTPCCalPad  *fRefALTROAcqStart;      ///< Reference accquistion start time bin
+  AliTPCCalPad  *fRefALTROAcqStop;       ///< Reference accquistion stop time bin
+  AliTPCCalPad  *fRefALTROMasked;        ///< Reference ALTRO masked channels information
   //
-  AliTPCCalibRaw *fRefCalibRaw;          //Reference raw calibration object
+  AliTPCCalibRaw *fRefCalibRaw;          ///< Reference raw calibration object
   //
-  AliTPCdataQA   *fRefDataQA;            //Reference data QA
+  AliTPCdataQA   *fRefDataQA;            ///< Reference data QA
   //
-  AliDCSSensorArray* fGoofieArray;    //Goofie Data
+  AliDCSSensorArray* fGoofieArray;    ///< Goofie Data
   //
-  AliTPCmapper  *fMapper;             //TPC mapping handler
-  Int_t fNpulserOutliers;             //number of outliers from Pulser calibration
+  AliTPCmapper  *fMapper;             ///< TPC mapping handler
+  Int_t fNpulserOutliers;             ///< number of outliers from Pulser calibration
   
-  Float_t fIrocTimeOffset;               //timing offset between IROC and OROC in timebins
-  Float_t fCETmaxLimitAbs;               //maximum variation in CE data before pads will be treated as outliers
-  Float_t fPulTmaxLimitAbs;              //maximum variation of Pulser Signals (time) before pads will be treated as outliers
-  Float_t fPulQmaxLimitAbs;              //maximum variation of Pulser Signals (charge) before pads will be treated as outliers
-  Float_t fPulQminLimit;                 //minimum charge value for Pulser Signals before pads will be treated as outliers
+  Float_t fIrocTimeOffset;               ///< timing offset between IROC and OROC in timebins
+  Float_t fCETmaxLimitAbs;               ///< maximum variation in CE data before pads will be treated as outliers
+  Float_t fPulTmaxLimitAbs;              ///< maximum variation of Pulser Signals (time) before pads will be treated as outliers
+  Float_t fPulQmaxLimitAbs;              ///< maximum variation of Pulser Signals (charge) before pads will be treated as outliers
+  Float_t fPulQminLimit;                 ///< minimum charge value for Pulser Signals before pads will be treated as outliers
 
   //
   // helpers to get the run number for given time stamps
   //
   // filters  
   
-  TArrayI fRuns;                         // run list with OCDB info
-  TArrayI fRunsStart;                    // start time for given run
-  TArrayI fRunsStop;                     // stop time for given run
+  TArrayI fRuns;                         ///< run list with OCDB info
+  TArrayI fRunsStart;                    ///< start time for given run
+  TArrayI fRunsStop;                     ///< stop time for given run
   
   AliTPCcalibDButil (const AliTPCcalibDButil& );
   AliTPCcalibDButil& operator= (const AliTPCcalibDButil& );
@@ -254,7 +250,9 @@ private:
   static Double_t  GetVDriftTPCLaserTracksCommon(Double_t &dist, Int_t timeStamp, Double_t deltaT, Int_t side, TObjArray * const array);
   
   
+  /// \cond CLASSIMP
   ClassDef(AliTPCcalibDButil,0)
+  /// \endcond
 };
 
 
diff --git a/TPC/TPCbase/AliTPCclusterInfo.cxx b/TPC/TPCbase/AliTPCclusterInfo.cxx
index 479677578ea..cf1dfa7556c 100644
--- a/TPC/TPCbase/AliTPCclusterInfo.cxx
+++ b/TPC/TPCbase/AliTPCclusterInfo.cxx
@@ -13,24 +13,22 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-//-------------------------------------------------------
-//          Implementation of the TPC cluster debug information
-//
-//   Origin: Marian Ivanov   Marian.Ivanov@cern.ch
-//   
-//   Additional cluster information to monitor clustering performance
-//   and to extract a features of detector response
-//   Information attached to the default cluster
-//   ONLY in DEBUG MODE
-//    
-//-------------------------------------------------------
-
-/* $Id$ */
+/// \class AliTPCclusterInfo
+/// \brief Implementation of the TPC cluster debug information
+///
+///   Additional cluster information to monitor clustering performance
+///   and to extract a features of detector response
+///   Information attached to the default cluster
+///   ONLY in DEBUG MODE
+///
+/// \author Marian Ivanov   Marian.Ivanov@cern.ch
 
 #include "AliTPCclusterInfo.h"
 #include "AliLog.h"
 
+/// \cond CLASSIMP
 ClassImp(AliTPCclusterInfo)
+/// \endcond
 
 
 AliTPCclusterInfo::AliTPCclusterInfo():
@@ -41,9 +39,9 @@ AliTPCclusterInfo::AliTPCclusterInfo():
 {
   //
   // default constructor
-  //  
+  //
   for (Int_t i=0; i<25;i++){
-    fMatrix[i] = i; 
+    fMatrix[i] = i;
   }
 }
 
@@ -52,14 +50,13 @@ AliTPCclusterInfo::AliTPCclusterInfo(const  AliTPCclusterInfo & info):
   fNPads(info.fNPads),
   fNTimeBins(info.fNTimeBins),
   fNBins(info.fNBins),
-  fGraph(0)    
+  fGraph(0)
 {
-  //
-  // copy constructor
-  //
-  //  AliInfo("Copy constructor\n");
+  /// copy constructor
+
+  // AliInfo("Copy constructor\n");
   for (Int_t i=0; i<25;i++){
-    fMatrix[i] = info.fMatrix[i]; 
+    fMatrix[i] = info.fMatrix[i];
   }
   if (info.fGraph) {
     fGraph = new Float_t[fNBins];
@@ -76,11 +73,10 @@ AliTPCclusterInfo::AliTPCclusterInfo(Bool_t extend):
   fNBins(0),
   fGraph(0)
 {
-  //
-  // allocate dummy graph - neccessary for IO part to use automatic branching
-  //  
+  /// allocate dummy graph - neccessary for IO part to use automatic branching
+
   for (Int_t i=0; i<25;i++){
-    fMatrix[i] = i; 
+    fMatrix[i] = i;
   }
   if (extend){
     fNBins = 1;
@@ -95,9 +91,8 @@ AliTPCclusterInfo::AliTPCclusterInfo(Float_t *matrix, Int_t nbins, Float_t* grap
   fNBins(0),
   fGraph(0)
 {
-  //
-  // constructor of the info
-  //
+  /// constructor of the info
+
   for (Int_t i=0;i<25;i++){
     fMatrix[i]=matrix[i];
   }
@@ -117,12 +112,11 @@ AliTPCclusterInfo::AliTPCclusterInfo(Float_t *matrix, Int_t nbins, Float_t* grap
 }
 
 AliTPCclusterInfo& AliTPCclusterInfo::operator=(const AliTPCclusterInfo& info){
-  //
-  // assignment operator
-  // 
+  /// assignment operator
+
   if (this == &info) return (*this);
   for (Int_t i=0; i<25;i++){
-    fMatrix[i] = info.fMatrix[i]; 
+    fMatrix[i] = info.fMatrix[i];
   }
   if (info.fGraph) {
     if (fGraph) delete []fGraph;
@@ -130,24 +124,23 @@ AliTPCclusterInfo& AliTPCclusterInfo::operator=(const AliTPCclusterInfo& info){
     for (Int_t i=0;i<fNBins; i++){
       fGraph[i] = info.fGraph[i];
     }
-  }  
+  }
   return *this;
 }
 
 
-UChar_t AliTPCclusterInfo::GetNPads(Float_t threshold) const { 
-  //
-  //
+UChar_t AliTPCclusterInfo::GetNPads(Float_t threshold) const {
+  ///
+
   Int_t nPads=0;
   Int_t center = 5+5+2;
   for (Int_t i=-2; i<=2;i++) if (fMatrix[center+i*5]>threshold) nPads++;
   return nPads;
 }
 
-UChar_t AliTPCclusterInfo::GetNTimeBins(Float_t threshold) const { 
-  //
-  //
-  //
+UChar_t AliTPCclusterInfo::GetNTimeBins(Float_t threshold) const {
+  ///
+
   Int_t nTimeBins=0;
   Int_t center = 5+5+2;
   for (Int_t i=-2; i<=2;i++) if (fMatrix[center+i]>threshold) nTimeBins++;
@@ -158,9 +151,8 @@ UChar_t AliTPCclusterInfo::GetNTimeBins(Float_t threshold) const {
 
 
 AliTPCclusterInfo::~AliTPCclusterInfo(){
-  //
-  // destructor
-  //
+  /// destructor
+
   if (fGraph)  delete [] fGraph;
 }
 
diff --git a/TPC/TPCbase/AliTPCclusterInfo.h b/TPC/TPCbase/AliTPCclusterInfo.h
index 84b7e0dbe97..7a7205d9d05 100644
--- a/TPC/TPCbase/AliTPCclusterInfo.h
+++ b/TPC/TPCbase/AliTPCclusterInfo.h
@@ -1,11 +1,12 @@
 #ifndef ALITPCCLUSTERINFO_H
 #define ALITPCCLUSTERINFO_H
 
-//-------------------------------------------------------
-//                    TPC Cluster Class
-//   Information for debugging puposes
-//   Origin: Marian Ivanov
-//-------------------------------------------------------
+/// \class AliTPCclusterInfo
+/// \brief TPC Cluster Class
+///
+/// Information for debugging puposes
+///
+/// \author Marian Ivanov
 
 /* $Id$ */
 
@@ -28,13 +29,16 @@ public:
   void    SetGraph(Float_t * graph, Int_t nbins){ fGraph = graph; fNBins=nbins;}
   void    SetNPadsTimes(UChar_t npads, UChar_t ntimes){ fNPads = npads; fNTimeBins = ntimes;}
  protected:
-  Float_t  fMatrix[25];               // matrix of amplitude arround center pad - time 
-  UChar_t  fNPads;                // number of pads      in cluster
-  UChar_t  fNTimeBins;            // number of time bins in cluster
-  Int_t  fNBins;                // number of bins in graph
-  Float_t *fGraph;               //[fNBins] signal time dependence graph
+  Float_t  fMatrix[25];               ///< matrix of amplitude arround center pad - time
+  UChar_t  fNPads;                ///< number of pads      in cluster
+  UChar_t  fNTimeBins;            ///< number of time bins in cluster
+  Int_t  fNBins;                ///< number of bins in graph
+  /// signal time dependence graph
+  Float_t *fGraph;               //[fNBins]
 private:
-  ClassDef(AliTPCclusterInfo,1)  // Time Projection Chamber clusters Inofrmation 
+  /// \cond CLASSIMP
+  ClassDef(AliTPCclusterInfo,1)  // Time Projection Chamber clusters Inofrmation
+  /// \endcond
 };
 
 
diff --git a/TPC/TPCbase/AliTPCclusterMI.cxx b/TPC/TPCbase/AliTPCclusterMI.cxx
index 90538e154c5..b2b3753f433 100644
--- a/TPC/TPCbase/AliTPCclusterMI.cxx
+++ b/TPC/TPCbase/AliTPCclusterMI.cxx
@@ -13,16 +13,14 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-//-------------------------------------------------------
-//          Implementation of the TPC cluser
-//
-//   Origin: Marian Ivanov   Marian.Ivanov@cern.ch
-// 
-//  AliTPC parallel tracker - 
-//  Description of this class together with its intended usage
-//  will follow shortly
-//  
-//-------------------------------------------------------
+/// \class AliTPCclusterMI
+/// \brief Implementation of the TPC cluser
+///
+/// AliTPC parallel tracker -
+/// Description of this class together with its intended usage
+/// will follow shortly
+///
+/// \author Marian Ivanov   Marian.Ivanov@cern.ch
 
 /* $Id$ */
 
@@ -32,7 +30,9 @@
 #include "AliGeomManager.h"
 #include "AliLog.h"
 
+/// \cond CLASSIMP
 ClassImp(AliTPCclusterMI)
+/// \endcond
 
 
 AliTPCclusterMI::AliTPCclusterMI():
@@ -40,10 +40,10 @@ AliTPCclusterMI::AliTPCclusterMI():
   fInfo(0),
   fTimeBin(0),  //time bin coordinate
   fPad(0),  //pad coordinate
-  fQ(0),       //Q of cluster (in ADC counts)  
+  fQ(0),       //Q of cluster (in ADC counts)
   fMax(0),      //maximal amplitude in cluster
-  fType(0),     //type of the cluster 0 means golden 
-  fUsed(0),     //counter of usage  
+  fType(0),     //type of the cluster 0 means golden
+  fUsed(0),     //counter of usage
   fDetector(0), //detector  number
   fRow(0)      //row number number
 {
@@ -64,19 +64,19 @@ AliTPCclusterMI::AliTPCclusterMI(const AliTPCclusterMI & cluster):
   fDetector(cluster.fDetector),
   fRow(cluster.fRow)
 {
-  //
-  // copy constructor
-  // 
-  //  AliInfo("Copy constructor\n");
+  /// copy constructor
+
+  // AliInfo("Copy constructor\n");
+
   if (cluster.fInfo) fInfo = new AliTPCclusterInfo(*(cluster.fInfo));
 }
 
 AliTPCclusterMI & AliTPCclusterMI::operator = (const AliTPCclusterMI & cluster)
 {
-  //
-  // assignment operator
-  // 
-  //  AliInfo("Asignment operator\n");
+  /// assignment operator
+
+  // AliInfo("Asignment operator\n");
+
   if (this == &cluster) return (*this);
 
   (AliCluster&)(*this) = (AliCluster&)cluster;
@@ -97,29 +97,27 @@ AliTPCclusterMI & AliTPCclusterMI::operator = (const AliTPCclusterMI & cluster)
 
 
 
-AliTPCclusterMI::AliTPCclusterMI(Int_t *lab, Float_t *hit) : 
+AliTPCclusterMI::AliTPCclusterMI(Int_t *lab, Float_t *hit) :
   AliCluster(0,hit,0.,0.,lab),
   fInfo(0),
   fTimeBin(0),  //time bin coordinate
   fPad(0),  //pad coordinate
-  fQ(0),       //Q of cluster (in ADC counts)  
+  fQ(0),       //Q of cluster (in ADC counts)
   fMax(0),      //maximal amplitude in cluster
-  fType(0),     //type of the cluster 0 means golden 
-  fUsed(0),     //counter of usage  
+  fType(0),     //type of the cluster 0 means golden
+  fUsed(0),     //counter of usage
   fDetector(0), //detector  number
   fRow(0)      //row number number
 {
-  //
-  // constructor
-  //
+  /// constructor
+
   fQ = (UShort_t)hit[4];
   fInfo = 0;
 }
 
 AliTPCclusterMI::~AliTPCclusterMI() {
-  //
-  // destructor
-  //
+  /// destructor
+
   if (fInfo) delete fInfo;
   fInfo = 0;
 }
@@ -128,55 +126,50 @@ AliTPCclusterMI::~AliTPCclusterMI() {
 
 Bool_t AliTPCclusterMI::IsSortable() const
 {
-  //
-  //
+  ///
+
   return kTRUE;
 
 }
 
 Int_t AliTPCclusterMI::Compare(const TObject* obj) const
 {
-  //
-  // compare according y
+  /// compare according y
+
   AliTPCclusterMI * o2 = (AliTPCclusterMI*)obj;
-  return (o2->GetY()>GetY())? -1:1; 
+  return (o2->GetY()>GetY())? -1:1;
 }
 
 
 void AliTPCclusterMI::SetDetector(Int_t detector){
-  //
-  // set volume ID 
-  //  
+  /// set volume ID
+
   fDetector = (UChar_t)(detector%72);
-  AliGeomManager::ELayerID id = (fDetector<36) ? 
+  AliGeomManager::ELayerID id = (fDetector<36) ?
     AliGeomManager::kTPC1 :AliGeomManager::kTPC2 ;
   Int_t modId = (fDetector<36)?fDetector: fDetector-36;
-  SetVolumeId(AliGeomManager::LayerToVolUID(id,modId));  
+  SetVolumeId(AliGeomManager::LayerToVolUID(id,modId));
 }
 
 
 void AliTPCclusterMI::SetInfo(AliTPCclusterInfo * info) {
-  //
-  //
-  //
+  ///
+
   if (fInfo) delete fInfo;
   fInfo = info;
 }
 
 
 AliTPCclusterMI* AliTPCclusterMI::MakeCluster(AliTrackPoint* /*point*/) {
-  //
-  // make AliTPCclusterMI out of AliTrackPoint
-  // (not yet implemented)
-  
+  /// make AliTPCclusterMI out of AliTrackPoint
+  /// (not yet implemented)
+
   return NULL;
 }
 
 
 AliTrackPoint* AliTPCclusterMI::MakePoint() {
-  //
-  // make AliTrackPoint out of AliTPCclusterMI
-  //
+  /// make AliTrackPoint out of AliTPCclusterMI
 
   AliTrackPoint* point = new AliTrackPoint();
   Float_t xyz[3]={0.};
@@ -193,10 +186,8 @@ AliTrackPoint* AliTPCclusterMI::MakePoint() {
 //______________________________________________________________________________
 void AliTPCclusterMI::SetGlobalTrackPoint( const AliCluster &cl, AliTrackPoint &point )
 {
-  //
-  // Set global AliTrackPoint
-  //
-  
+  /// Set global AliTrackPoint
+
   Float_t xyz[3]={0.};
   Float_t cov[6]={0.};
   cl.GetGlobalXYZ(xyz);
diff --git a/TPC/TPCbase/AliTPCclusterMI.h b/TPC/TPCbase/AliTPCclusterMI.h
index 3dae8ecc377..10ef3b3b58f 100644
--- a/TPC/TPCbase/AliTPCclusterMI.h
+++ b/TPC/TPCbase/AliTPCclusterMI.h
@@ -1,11 +1,12 @@
 #ifndef ALITPCCLUSTERMI_H
 #define ALITPCCLUSTERMI_H
 
-//-------------------------------------------------------
-//                    TPC Cluster Class
-//   Parallel tracking
-//   Origin: Marian Ivanov
-//-------------------------------------------------------
+/// \class AliTPCclusterMI
+/// \brief TPC Cluster Class
+///
+/// Parallel tracking
+///
+/// \author Marian Ivanov
 
 /* $Id$ */
 
@@ -25,7 +26,7 @@ public:
   AliTPCclusterMI(Int_t *lab, Float_t *hit);
   virtual ~AliTPCclusterMI();
   virtual void	Clear(const Option_t*) { delete fInfo; fInfo=0;}
-  virtual Bool_t IsSortable() const; 
+  virtual Bool_t IsSortable() const;
   virtual Int_t Compare(const TObject* obj) const;
   inline  void Use(Int_t inc=10);
   inline  void Disable(){fUsed=kDisabled;}
@@ -34,7 +35,7 @@ public:
   virtual Int_t GetDetector() const {return fDetector;}
   virtual Int_t GetRow() const {return fRow;}
   virtual void SetDetector(Int_t detector);
-  virtual void SetRow(Int_t row){fRow = (UChar_t)(row%256);}  
+  virtual void SetRow(Int_t row){fRow = (UChar_t)(row%256);}
   virtual void SetTimeBin(Float_t timeBin){ fTimeBin= timeBin;}
   virtual void SetPad(Float_t pad){ fPad = pad;}
   //
@@ -43,7 +44,7 @@ public:
   void SetMax(UShort_t max) {fMax=max;}
   Int_t IsUsed(Int_t th=10) const {return (fUsed>=th) ? 1 : 0;}
   Float_t GetQ() const {return TMath::Abs(fQ);}
-  Float_t GetMax() const {return fMax;} 
+  Float_t GetMax() const {return fMax;}
   Char_t  GetType()const {return fType;}
   Float_t GetTimeBin() const { return fTimeBin;}
   Float_t GetPad() const { return fPad;}
@@ -53,24 +54,26 @@ public:
   AliTPCclusterMI*  MakeCluster(AliTrackPoint* point);
   AliTrackPoint*    MakePoint();
   static void     SetGlobalTrackPoint(const AliCluster &cl, AliTrackPoint &point);
-  
+
 private:
-  AliTPCclusterInfo * fInfo;  // pointer to the cluster debug info
-  Float_t   fTimeBin;  //time bin coordinate
-  Float_t   fPad;  //pad coordinate
-  Short_t   fQ ;       //Q of cluster (in ADC counts)  
-  Short_t   fMax;      //maximal amplitude in cluster
-  Char_t    fType;     //type of the cluster 0 means golden 
-  Char_t    fUsed;     //counter of usage  
-  UChar_t   fDetector; //detector  number
-  UChar_t   fRow;      //row number number
+  AliTPCclusterInfo * fInfo;  ///< pointer to the cluster debug info
+  Float_t   fTimeBin;  ///< time bin coordinate
+  Float_t   fPad;  ///< pad coordinate
+  Short_t   fQ ;       ///< Q of cluster (in ADC counts)
+  Short_t   fMax;      ///< maximal amplitude in cluster
+  Char_t    fType;     ///< type of the cluster 0 means golden
+  Char_t    fUsed;     ///< counter of usage
+  UChar_t   fDetector; ///< detector  number
+  UChar_t   fRow;      ///< row number number
+  /// \cond CLASSIMP
   ClassDef(AliTPCclusterMI,5)  // Time Projection Chamber clusters
+  /// \endcond
 };
 
-void AliTPCclusterMI::Use(Int_t inc) 
-{ 
-  if (inc>0)  fUsed+=inc; 
-  else 
+void AliTPCclusterMI::Use(Int_t inc)
+{
+  if (inc>0)  fUsed+=inc;
+  else
     fUsed=0;
 }
 
diff --git a/TPC/TPCbase/AliTPCdataQA.cxx b/TPC/TPCbase/AliTPCdataQA.cxx
index fbcc9f795c3..4cb1845f2a7 100644
--- a/TPC/TPCbase/AliTPCdataQA.cxx
+++ b/TPC/TPCbase/AliTPCdataQA.cxx
@@ -13,86 +13,84 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-
-/* $Id$ */
-
-/*
-  July 2011:
-
-  Changes to accomodate updates of general DQM/QA changes to have per trigger
-  histograms (for a given event specie).
-
-  AliTPCdataQA has a new flag for only keeping DQM info event by
-  event!
-  The expert/DA functionality has been kept exactly the same!
-  
-
-  June 2010
-
-  This update should solve two problems mainly:
-  * The vs event histograms have been limited to a fixed size for the
-  DQM. The 500k seemed to be a big size but is no longer so, so we
-  need to dynamically expand the range. The non-trivial point is that
-  we also have to do it for the copy owned by AliTPCQADataMakerRec.
-  * The amoreGui now remembers the x-range of the first visualization so
-  the trick of setting the relevant event range as the histogram is
-  filled no longer works.
-
-  The fix is a bit crude but avoids creating a new histogram. Instead
-  the range is expanded (max events and events per bin is doubled) but
-  the number of bins is kept constant! In this way we can change just
-  double the max of the X-axis of the hist and rebin the data. The
-  same can easily be done for the copy owned by AliTPCQADataMakerRec.
-
-  CAUTION:
-  If we change the number of bins we could crash the whole system
-  because ROOT does not create space for extra bins! (but we do not do
-  this). In that way it is a crude solution.
-  The rebinning in the code only works for an even number of bins.
-
-  In addition to the above a bug in the reading of the config file was
-  also found and corrected. fAdcMax was set instead of fEventsPerBin.
-
-  Finally cout was changes to AliInfo.
-
-  February 2008
-
-  The code has been heavily modified so that now the RAW data is
-  "expanded" for each sector and stored in a big signal array. Then a
-  simple version of the code in AliTPCclusterer is used to identify
-  the local maxima and these are then used for QA. This gives a better
-  estimate of the charge (both max and total) and also limits the
-  effect of noise.
-
-  Implementation:
-
-  In Update the RAW signals >= 3 ADC channels are stored in the arrays.
-  
-  There are 3 arrays:
-  Float_t** fAllBins       2d array [row][bin(pad, time)] ADC signal
-  Int_t**   fAllSigBins    2d array [row][signal#] bin(with signal)
-  Int_t*    fAllNSigBins;  1d array [row] Nsignals
-
-  This is done sector by sector.
-
-  When data from a new sector is encountered, the method
-  FindLocalMaxima is called on the data from the previous sector, and
-  the calibration/data objects are updated with the "cluster"
-  info. Finally the arrays are cleared.
-
-  The requirements for a local maxima is:
-  Charge in bin is >= 5 ADC channels.
-  Charge in bin is larger than all the 8 neighboring bins.
-  At least one of the two pad neighbors has a signal.
-  At least one of the two time neighbors has a signal.
-
-  Before accessing the data it is expected that the Analyse method is
-  called. This normalizes some of the data objects to per event or per
-  cluster. 
-  If more data is passed to the class after Analyse has been called
-  the normalization is reversed and Analyse has to be called again.
-*/
-
+/// \class AliTPCdataQA
+///
+/// July 2011:
+///
+/// Changes to accomodate updates of general DQM/QA changes to have per trigger
+/// histograms (for a given event specie).
+///
+/// AliTPCdataQA has a new flag for only keeping DQM info event by
+/// event!
+/// The expert/DA functionality has been kept exactly the same!
+///
+///
+/// June 2010
+///
+/// This update should solve two problems mainly:
+/// * The vs event histograms have been limited to a fixed size for the
+/// DQM. The 500k seemed to be a big size but is no longer so, so we
+/// need to dynamically expand the range. The non-trivial point is that
+/// we also have to do it for the copy owned by AliTPCQADataMakerRec.
+/// * The amoreGui now remembers the x-range of the first visualization so
+/// the trick of setting the relevant event range as the histogram is
+/// filled no longer works.
+///
+/// The fix is a bit crude but avoids creating a new histogram. Instead
+/// the range is expanded (max events and events per bin is doubled) but
+/// the number of bins is kept constant! In this way we can change just
+/// double the max of the X-axis of the hist and rebin the data. The
+/// same can easily be done for the copy owned by AliTPCQADataMakerRec.
+///
+/// CAUTION:
+/// If we change the number of bins we could crash the whole system
+/// because ROOT does not create space for extra bins! (but we do not do
+/// this). In that way it is a crude solution.
+/// The rebinning in the code only works for an even number of bins.
+///
+/// In addition to the above a bug in the reading of the config file was
+/// also found and corrected. fAdcMax was set instead of fEventsPerBin.
+///
+/// Finally cout was changes to AliInfo.
+///
+/// February 2008
+///
+/// The code has been heavily modified so that now the RAW data is
+/// "expanded" for each sector and stored in a big signal array. Then a
+/// simple version of the code in AliTPCclusterer is used to identify
+/// the local maxima and these are then used for QA. This gives a better
+/// estimate of the charge (both max and total) and also limits the
+/// effect of noise.
+///
+/// Implementation:
+///
+/// In Update the RAW signals >= 3 ADC channels are stored in the arrays.
+/// There are 3 arrays:
+///
+/// ~~~{.cpp}
+/// Float_t** fAllBins       2d array [row][bin(pad, time)] ADC signal
+/// Int_t**   fAllSigBins    2d array [row][signal#] bin(with signal)
+/// Int_t*    fAllNSigBins;  1d array [row] Nsignals
+/// ~~~
+///
+/// This is done sector by sector.
+///
+/// When data from a new sector is encountered, the method
+/// FindLocalMaxima is called on the data from the previous sector, and
+/// the calibration/data objects are updated with the "cluster"
+/// info. Finally the arrays are cleared.
+///
+/// The requirements for a local maxima is:
+/// Charge in bin is >= 5 ADC channels.
+/// Charge in bin is larger than all the 8 neighboring bins.
+/// At least one of the two pad neighbors has a signal.
+/// At least one of the two time neighbors has a signal.
+///
+/// Before accessing the data it is expected that the Analyse method is
+/// called. This normalizes some of the data objects to per event or per
+/// cluster.
+/// If more data is passed to the class after Analyse has been called
+/// the normalization is reversed and Analyse has to be called again.
 
 //Root includes
 #include <TH1F.h>
@@ -124,9 +122,11 @@
 #include "AliLog.h"
 
 
+/// \cond CLASSIMP
 ClassImp(AliTPCdataQA)
+/// \endcond
 
-AliTPCdataQA::AliTPCdataQA() : /*FOLD00*/  
+AliTPCdataQA::AliTPCdataQA() : /*FOLD00*/
   fFirstTimeBin(60),
   fLastTimeBin(1000),
   fAdcMin(3),
@@ -233,9 +233,8 @@ AliTPCdataQA::AliTPCdataQA(const AliTPCdataQA &ped) : /*FOLD00*/
   fOccVecFine(0x0),
   fOccMaxVecFine(0x0)
 {
-  //
-  // copy constructor
-  //
+  /// copy constructor
+
   if(ped.GetNLocalMaxima())
     fNLocalMaxima  = new AliTPCCalPad(*ped.GetNLocalMaxima());
   if(ped.GetMaxCharge())
@@ -283,7 +282,7 @@ AliTPCdataQA::AliTPCdataQA(const AliTPCdataQA &ped) : /*FOLD00*/
 }
 
 //_____________________________________________________________________
-AliTPCdataQA::AliTPCdataQA(const TMap *config) : /*FOLD00*/  
+AliTPCdataQA::AliTPCdataQA(const TMap *config) : /*FOLD00*/
   TH1F("TPCRAW","TPCRAW",100,0,100),
   fFirstTimeBin(60),
   fLastTimeBin(1000),
@@ -333,9 +332,8 @@ AliTPCdataQA::AliTPCdataQA(const TMap *config) : /*FOLD00*/
   fOccVecFine(0x0),
   fOccMaxVecFine(0x0)
 {
-  //
-  // default constructor
-  //
+  /// default constructor
+
   if (config->GetValue("FirstTimeBin")) fFirstTimeBin = ((TObjString*)config->GetValue("FirstTimeBin"))->GetString().Atoi();
   if (config->GetValue("LastTimeBin"))  fLastTimeBin = ((TObjString*)config->GetValue("LastTimeBin"))->GetString().Atoi();
   if (config->GetValue("AdcMin"))       fAdcMin = ((TObjString*)config->GetValue("AdcMin"))->GetString().Atoi();
@@ -350,9 +348,8 @@ AliTPCdataQA::AliTPCdataQA(const TMap *config) : /*FOLD00*/
 //_____________________________________________________________________
 AliTPCdataQA& AliTPCdataQA::operator = (const  AliTPCdataQA &source)
 {
-  //
-  // assignment operator
-  //
+  /// assignment operator
+
   if (&source == this) return *this;
   new (this) AliTPCdataQA(source);
 
@@ -363,9 +360,7 @@ AliTPCdataQA& AliTPCdataQA::operator = (const  AliTPCdataQA &source)
 //_____________________________________________________________________
 AliTPCdataQA::~AliTPCdataQA() /*FOLD00*/
 {
-  //
-  // destructor
-  //
+  /// destructor
 
   // do not delete fMapping, because we do not own it.
   // do not delete fMapping, because we do not own it.
@@ -397,11 +392,11 @@ AliTPCdataQA::~AliTPCdataQA() /*FOLD00*/
   delete fOccMaxVec;
   delete fOccVecFine;
   delete fOccMaxVecFine;
-  
+
   for (Int_t iRow = 0; iRow < fRowsMax; iRow++) {
     delete [] fAllBins[iRow];
     delete [] fAllSigBins[iRow];
-  }  
+  }
   delete [] fAllBins;
   delete [] fAllSigBins;
   delete [] fAllNSigBins;
@@ -410,54 +405,53 @@ AliTPCdataQA::~AliTPCdataQA() /*FOLD00*/
 //_____________________________________________________________________
 TH1F* AliTPCdataQA::GetHistOccupancyVsEvent()
 {
-  //
-  // Create Occupancy vs event histogram
-  // (we create this histogram differently then the other histograms
-  //  because this we want to be able to access and copy
-  //  from AliTPCQAMakerRec before it normally would be created)
-  //
+  /// Create Occupancy vs event histogram
+  /// (we create this histogram differently then the other histograms
+  ///  because this we want to be able to access and copy
+  ///  from AliTPCQAMakerRec before it normally would be created)
+
   if(!fHistOccupancyVsEvent) {
 
     Int_t nBins = fMaxEvents/fEventsPerBin;
     fHistOccupancyVsEvent = new TH1F("hOccupancyVsEvent", "Occupancy vs event number (~time); Event number; Occupancy", nBins, 0, nBins*fEventsPerBin);
     fHistOccupancyVsEvent->SetDirectory(0);
   }
-  
+
   return fHistOccupancyVsEvent;
 }
 
 //_____________________________________________________________________
 TH1F* AliTPCdataQA::GetHistNclustersVsEvent()
 {
-  //
-  // Create Nclusters vs event histogram
-  // (we create this histogram differently then the other histograms
-  //  because this we want to be able to access and copy
-  //  from AliTPCQAMakerRec before it normally would be created)
-  //
+  /// Create Nclusters vs event histogram
+  /// (we create this histogram differently then the other histograms
+  ///  because this we want to be able to access and copy
+  ///  from AliTPCQAMakerRec before it normally would be created)
+
   if(!fHistNclustersVsEvent) {
 
     Int_t nBins = fMaxEvents/fEventsPerBin;
     fHistNclustersVsEvent = new TH1F("hNclustersVsEvent", "Nclusters vs event number (~time); Event number; Nclusters per event", nBins, 0, nBins*fEventsPerBin);
     fHistNclustersVsEvent->SetDirectory(0);
   }
-  
+
   return fHistNclustersVsEvent;
 }
 
 //_____________________________________________________________________
 void AliTPCdataQA::UpdateEventHistograms()
 {
-  // Update histograms that display occupancy and 
-  // number of clusters as a function of number of 
-  // events
+  /// Update histograms that display occupancy and
+  /// number of clusters as a function of number of
+  /// events
+
   if (!fHistOccupancyVsEvent)
     GetHistOccupancyVsEvent();
   if (!fHistNclustersVsEvent)
     GetHistNclustersVsEvent();
-  
+
   if(fEventCounter > fMaxEvents) {
-    
+
     // we have to expand the histogram to handle the larger number of
     // events. The way it is done now is to double the range and the
     // number of events per bin (so the number of histogram bins stays
@@ -476,19 +470,19 @@ void AliTPCdataQA::UpdateEventHistograms()
       Int_t newBin = TMath::Nint(Float_t(bin+1)/2.0);
       Float_t newContent = (fHistOccupancyVsEvent->GetBinContent(bin)+
 			    fHistOccupancyVsEvent->GetBinContent(bin+1))/2.0;
-      fHistOccupancyVsEvent->SetBinContent(newBin, newContent); 
+      fHistOccupancyVsEvent->SetBinContent(newBin, newContent);
 
       newContent = (fHistNclustersVsEvent->GetBinContent(bin)+
 		    fHistNclustersVsEvent->GetBinContent(bin+1))/2.0;
-      fHistNclustersVsEvent->SetBinContent(newBin, newContent); 
+      fHistNclustersVsEvent->SetBinContent(newBin, newContent);
     }
 
     // Set the remaining bins to 0
     Int_t lastHalf = nBins/2 +1;
     for(Int_t bin = lastHalf; bin <= nBins; bin++) {
 
-      fHistOccupancyVsEvent->SetBinContent(bin, 0); 
-      fHistNclustersVsEvent->SetBinContent(bin, 0); 
+      fHistOccupancyVsEvent->SetBinContent(bin, 0);
+      fHistNclustersVsEvent->SetBinContent(bin, 0);
     }
 
     // In this case we should nut update but wait untill the new
@@ -503,7 +497,7 @@ void AliTPCdataQA::UpdateEventHistograms()
     / 570132.0; // 570,132 is number of pads
   fHistOccupancyVsEvent->SetBinContent(bin, averageOccupancy);
   fSignalCounter = 0;
-  
+
   Float_t averageNclusters =
     Float_t(fClusterCounter)/fEventsPerBin;
   fHistNclustersVsEvent->SetBinContent(bin, averageNclusters);
@@ -513,19 +507,18 @@ void AliTPCdataQA::UpdateEventHistograms()
 //_____________________________________________________________________
 Bool_t AliTPCdataQA::ProcessEvent(AliTPCRawStreamV3 *const rawStreamV3)
 {
-  //
-  // Event Processing loop - AliTPCRawStreamV3
-  //
+  /// Event Processing loop - AliTPCRawStreamV3
+
   Bool_t withInput = kFALSE;
   Int_t nSignals = 0;
   Int_t lastSector = -1;
 
   Init();
-  
+
   while ( rawStreamV3->NextDDL() ){
 
     while ( rawStreamV3->NextChannel() ){
-    
+
       Int_t iSector = rawStreamV3->GetSector(); //  current sector
       Int_t iRow    = rawStreamV3->GetRow();    //  current row
       Int_t iPad    = rawStreamV3->GetPad();    //  current pad
@@ -534,21 +527,21 @@ Bool_t AliTPCdataQA::ProcessEvent(AliTPCRawStreamV3 *const rawStreamV3)
       if (iRow<0 || iPad<0) continue;
       // Call local maxima finder if the data is in a new sector
       if(iSector != lastSector) {
-        
+
         if(nSignals>0)
           FindLocalMaxima(lastSector);
-        
+
         CleanArrays();
         lastSector = iSector;
         nSignals = 0;
       }
-      
+
       while ( rawStreamV3->NextBunch() ){
 
         Int_t  startTbin    = (Int_t)rawStreamV3->GetStartTimeBin();
         Int_t  bunchlength  = (Int_t)rawStreamV3->GetBunchLength();
         const UShort_t *sig = rawStreamV3->GetSignals();
-        
+
         for (Int_t iTimeBin = 0; iTimeBin<bunchlength; iTimeBin++){
           Float_t signal=(Float_t)sig[iTimeBin];
           nSignals += Update(iSector,iRow,iPad,startTbin--,signal, iPatch, iBranch);
@@ -557,27 +550,26 @@ Bool_t AliTPCdataQA::ProcessEvent(AliTPCRawStreamV3 *const rawStreamV3)
       }
     }
   }
-    
-  if (lastSector>=0&&nSignals>0)  
+
+  if (lastSector>=0&&nSignals>0)
     FindLocalMaxima(lastSector);
 
   CleanArrays();
-  
+
   return withInput;
 }
 
 //_____________________________________________________________________
 Bool_t AliTPCdataQA::ProcessEvent(AliRawReader *const rawReader)
 {
-  //
-  //  Event processing loop - AliRawReader
-  //
+  /// Event processing loop - AliRawReader
+
   AliTPCRawStreamV3 rawStreamV3(rawReader,(AliAltroMapping**)fMapping);
   Bool_t res=ProcessEvent(&rawStreamV3);
   if(res) {
     fEventCounter++; // only increment event counter if there is TPC data
 
-    if(fEventCounter%fEventsPerBin==0) 
+    if(fEventCounter%fEventsPerBin==0)
       UpdateEventHistograms();
   }
   return res;
@@ -586,9 +578,7 @@ Bool_t AliTPCdataQA::ProcessEvent(AliRawReader *const rawReader)
 //_____________________________________________________________________
 Bool_t AliTPCdataQA::ProcessEvent(eventHeaderStruct *const event)
 {
-  //
-  //  process date event
-  //
+  /// process date event
 
   AliRawReaderDate rawReader((void*)event);
   Bool_t result=ProcessEvent(&rawReader);
@@ -600,9 +590,7 @@ Bool_t AliTPCdataQA::ProcessEvent(eventHeaderStruct *const event)
 //_____________________________________________________________________
 void AliTPCdataQA::DumpToFile(const Char_t *filename, const Char_t *dir, Bool_t append) /*FOLD00*/
 {
-  //
-  //  Write class to file
-  //
+  /// Write class to file
 
   TString sDir(dir);
   TString option;
@@ -635,17 +623,15 @@ Int_t AliTPCdataQA::Update(const Int_t iSector, /*FOLD00*/
 			   const Int_t iPatch,
 			   const Int_t iBranch)
 {
-  //
-  // Signal filling method
-  //
-  
+  /// Signal filling method
+
   if (!fActiveChambers[iSector]) return 0;
   //
   // TimeBin cut
   //
   if (iTimeBin<fFirstTimeBin) return 0;
   if (iTimeBin>fLastTimeBin) return 0;
-  
+
   // if pedestal calibrations are loaded subtract pedestals
   if(fPedestal) {
 
@@ -655,7 +641,7 @@ Int_t AliTPCdataQA::Update(const Int_t iSector, /*FOLD00*/
       return 0;
     signal -= ped;
   }
-  
+
   if(fIsDQM) {
 
     fOccVec->GetArray()[iSector] += 1.0;
@@ -674,9 +660,9 @@ Int_t AliTPCdataQA::Update(const Int_t iSector, /*FOLD00*/
 
   // if noise calibrations are loaded require at least 3*sigmaNoise
   if(fNoise) {
-    
+
     Float_t noise = fNoise->GetCalROC(iSector)->GetValue(iRow, iPad);
-    
+
     if(signal < noise*3.0)
       return 0;
   }
@@ -688,25 +674,23 @@ Int_t AliTPCdataQA::Update(const Int_t iSector, /*FOLD00*/
   SetExpandDigit(iRow, iPad, iTimeBin, signal);
 
   fSignalCounter++;
-  
+
   return 1; // signal was accepted
 }
 
 //_____________________________________________________________________
 void AliTPCdataQA::FindLocalMaxima(const Int_t iSector)
 {
-  //
-  // This method is called after the data from each sector has been
-  // exapanded into an array
-  // Loop over the signals and identify local maxima and fill the
-  // calibration objects with the information
-  //
+  /// This method is called after the data from each sector has been
+  /// exapanded into an array
+  /// Loop over the signals and identify local maxima and fill the
+  /// calibration objects with the information
 
   if (!fActiveChambers[iSector]) return;
-  
+
   Int_t nLocalMaxima = 0;
-  const Int_t maxTimeBin = fTimeBinsMax+4; // Used to step between neighboring pads 
-                                           // Because we have tha pad-time data in a 
+  const Int_t maxTimeBin = fTimeBinsMax+4; // Used to step between neighboring pads
+                                           // Because we have tha pad-time data in a
                                            // 1d array
 
   for (Int_t iRow = 0; iRow < fRowsMax; iRow++) {
@@ -714,7 +698,7 @@ void AliTPCdataQA::FindLocalMaxima(const Int_t iSector)
     Float_t* allBins = fAllBins[iRow];
     Int_t* sigBins   = fAllSigBins[iRow];
     const Int_t nSigBins   = fAllNSigBins[iRow];
-    
+
     for (Int_t iSig = 0; iSig < nSigBins; iSig++) {
 
       Int_t bin  = sigBins[iSig];
@@ -727,30 +711,30 @@ void AliTPCdataQA::FindLocalMaxima(const Int_t iSector)
       Float_t qMax = b[0];
 
       // First check that the charge is bigger than the threshold
-      if (qMax<fMinQMax) 
+      if (qMax<fMinQMax)
 	continue;
-      
+
       // Require at least one neighboring pad with signal
       if (fRequireNeighbouringPad && (b[-maxTimeBin]+b[maxTimeBin]<=0) ) continue;
 
       // Require at least one neighboring time bin with signal
       if (b[-1]+b[1]<=0) continue;
-      
+
       //
       // Check that this is a local maximum
       // Note that the checking is done so that if 2 charges has the same
-      // qMax then only 1 cluster is generated 
+      // qMax then only 1 cluster is generated
       // (that is why there is BOTH > and >=)
       //
       if (b[-maxTimeBin]   >= qMax) continue;
-      if (b[-1  ]          >= qMax) continue; 
-      if (b[+maxTimeBin]   > qMax)  continue; 
-      if (b[+1  ]          > qMax)  continue; 
+      if (b[-1  ]          >= qMax) continue;
+      if (b[+maxTimeBin]   > qMax)  continue;
+      if (b[+1  ]          > qMax)  continue;
       if (b[-maxTimeBin-1] >= qMax) continue;
-      if (b[+maxTimeBin-1] >= qMax) continue; 
-      if (b[+maxTimeBin+1] > qMax)  continue; 
+      if (b[+maxTimeBin-1] >= qMax) continue;
+      if (b[+maxTimeBin+1] > qMax)  continue;
       if (b[-maxTimeBin+1] >= qMax) continue;
-      
+
       //
       // Now we accept the local maximum and fill the calibration/data objects
       //
@@ -758,17 +742,17 @@ void AliTPCdataQA::FindLocalMaxima(const Int_t iSector)
 
       Int_t iPad, iTimeBin;
       GetPadAndTimeBin(bin, iPad, iTimeBin);
-      
+
       if(!fIsDQM) {
 	Float_t count = fNLocalMaxima->GetCalROC(iSector)->GetValue(iRow, iPad);
 	fNLocalMaxima->GetCalROC(iSector)->SetValue(iRow, iPad, count+1);
-	
+
 	count = fTimePosition->GetCalROC(iSector)->GetValue(iRow, iPad);
 	fTimePosition->GetCalROC(iSector)->SetValue(iRow, iPad, count+iTimeBin);
-      
+
 	Float_t charge = fMaxCharge->GetCalROC(iSector)->GetValue(iRow, iPad);
 	fMaxCharge->GetCalROC(iSector)->SetValue(iRow, iPad, charge + qMax);
-	
+
 	if(qMax>=10) {
 	  count = fOverThreshold10->GetCalROC(iSector)->GetValue(iRow, iPad);
 	  fOverThreshold10->GetCalROC(iSector)->SetValue(iRow, iPad, count+1);
@@ -801,86 +785,84 @@ void AliTPCdataQA::FindLocalMaxima(const Int_t iSector)
       Float_t qTot = qMax;
       for(Int_t i = -1; i<=1; i++) {
 	for(Int_t j = -1; j<=1; j++) {
-	  
+
 	  if(i==0 && j==0)
 	    continue;
-	  
+
 	  Float_t charge1 = GetQ(b, i, j, maxTimeBin, minT, maxT, minP, maxP);
 	  qTot += charge1;
 	  if(charge1>0) {
 	    // see if the next neighbor is also above threshold
 	    if(i*j==0) {
-	      qTot += GetQ(b, 2*i, 2*j, maxTimeBin, minT, maxT, minP, maxP); 
+	      qTot += GetQ(b, 2*i, 2*j, maxTimeBin, minT, maxT, minP, maxP);
 	    } else {
 	      // we are in a diagonal corner
-	      qTot += GetQ(b,   i, 2*j, maxTimeBin, minT, maxT, minP, maxP); 
-	      qTot += GetQ(b, 2*i,   j, maxTimeBin, minT, maxT, minP, maxP); 
-	      qTot += GetQ(b, 2*i, 2*j, maxTimeBin, minT, maxT, minP, maxP); 
+	      qTot += GetQ(b,   i, 2*j, maxTimeBin, minT, maxT, minP, maxP);
+	      qTot += GetQ(b, 2*i,   j, maxTimeBin, minT, maxT, minP, maxP);
+	      qTot += GetQ(b, 2*i, 2*j, maxTimeBin, minT, maxT, minP, maxP);
 	    }
 	  }
 	}
       }
-      
+
       if(fIsDQM) {
 	fHistQVsSector->Fill(iSector, qTot);
 	fHistQmaxVsSector->Fill(iSector, qMax);
       } else {
 	Float_t charge = fMeanCharge->GetCalROC(iSector)->GetValue(iRow, iPad);
 	fMeanCharge->GetCalROC(iSector)->SetValue(iRow, iPad, charge + qTot);
-	
+
 	Float_t count = fNTimeBins->GetCalROC(iSector)->GetValue(iRow, iPad);
 	fNTimeBins->GetCalROC(iSector)->SetValue(iRow, iPad, count + maxT-minT+1);
-	
+
 	count = fNPads->GetCalROC(iSector)->GetValue(iRow, iPad);
 	fNPads->GetCalROC(iSector)->SetValue(iRow, iPad, count + maxP-minP+1);
-      
+
 	if((iSector%36)<18) { // A side
 	  fHistQVsTimeSideA->Fill(iTimeBin, qTot);
 	  fHistQMaxVsTimeSideA->Fill(iTimeBin, qMax);
 	} else {
 	  fHistQVsTimeSideC->Fill(iTimeBin, qTot);
-	  fHistQMaxVsTimeSideC->Fill(iTimeBin, qMax);      
+	  fHistQMaxVsTimeSideC->Fill(iTimeBin, qMax);
 	}
       }
     } // end loop over signals
   } // end loop over rows
-  
+
   fClusterCounter += nLocalMaxima;
 }
 
 //_____________________________________________________________________
 void AliTPCdataQA::Analyse()
 {
-  //
-  //  Calculate calibration constants
-  //
-  
+  /// Calculate calibration constants
+
   AliInfo("Analyse called");
 
   if(fIsDQM == kTRUE) {
-    
+
     AliInfo("DQM flas is set -> No 2d information to analyze");
     return;
   }
 
   if(fIsAnalysed == kTRUE) {
-    
+
     AliInfo("No new data since Analyse was called last time");
     return;
   }
 
   if(fEventCounter==0) {
-    
+
       AliInfo("EventCounter == 0, Cannot analyse");
     return;
   }
-  
+
   Int_t nTimeBins = fLastTimeBin - fFirstTimeBin +1;
   AliInfo(Form("EventCounter: %d , TimeBins: %d", fEventCounter, nTimeBins));
 
   Float_t normalization = 1.0 / Float_t(fEventCounter * nTimeBins);
-  fNoThreshold->Multiply(normalization);  
-  
+  fNoThreshold->Multiply(normalization);
+
   fMeanCharge->Divide(fNLocalMaxima);
   fMaxCharge->Divide(fNLocalMaxima);
   fNTimeBins->Divide(fNLocalMaxima);
@@ -893,15 +875,14 @@ void AliTPCdataQA::Analyse()
 
 //_____________________________________________________________________
 void AliTPCdataQA::MakeTree(const char *fname) const {
-  //
-  // Export result to the tree -located in the file
-  // This file can be analyzed using AliTPCCalibViewer
-  // 
+  /// Export result to the tree -located in the file
+  /// This file can be analyzed using AliTPCCalibViewer
+
   AliTPCPreprocessorOnline preprocesor;
 
   if (fNLocalMaxima) preprocesor.AddComponent(fNLocalMaxima);
-  if (fMaxCharge) preprocesor.AddComponent(fMaxCharge);  
-  if (fMeanCharge) preprocesor.AddComponent(fMeanCharge);  
+  if (fMaxCharge) preprocesor.AddComponent(fMaxCharge);
+  if (fMeanCharge) preprocesor.AddComponent(fMeanCharge);
   if (fNoThreshold) preprocesor.AddComponent(fNoThreshold);
   if (fNTimeBins) preprocesor.AddComponent(fNTimeBins);
   if (fNPads) preprocesor.AddComponent(fNPads);
@@ -910,39 +891,38 @@ void AliTPCdataQA::MakeTree(const char *fname) const {
   if (fOverThreshold20) preprocesor.AddComponent(fOverThreshold20);
   if (fOverThreshold30) preprocesor.AddComponent(fOverThreshold30);
 
-  preprocesor.DumpToFile(fname);  
+  preprocesor.DumpToFile(fname);
 }
 
 
 //_____________________________________________________________________
 void AliTPCdataQA::MakeArrays(){
-  //
-  // The arrays for expanding the raw data are defined and 
-  // som parameters are intialised
-  //
+  /// The arrays for expanding the raw data are defined and
+  /// som parameters are intialised
+
   AliTPCROC * roc = AliTPCROC::Instance();
   //
-  // To make the array big enough for all sectors we take 
+  // To make the array big enough for all sectors we take
   // the dimensions from the outer row of an OROC (the last sector)
   //
   fRowsMax     = roc->GetNRows(roc->GetNSector()-1);
   fPadsMax     = roc->GetNPads(roc->GetNSector()-1,fRowsMax-1);
-  fTimeBinsMax = fLastTimeBin - fFirstTimeBin +1; 
+  fTimeBinsMax = fLastTimeBin - fFirstTimeBin +1;
 
   //
-  // Since we have added 2 pads (TimeBins) before and after the real pads (TimeBins) 
-  // to make sure that we can always query the exanded table even when the 
+  // Since we have added 2 pads (TimeBins) before and after the real pads (TimeBins)
+  // to make sure that we can always query the exanded table even when the
   // max is on the edge
   //
 
- 
+
   fAllBins = new Float_t*[fRowsMax];
   fAllSigBins = new Int_t*[fRowsMax];
   fAllNSigBins = new Int_t[fRowsMax];
 
   for (Int_t iRow = 0; iRow < fRowsMax; iRow++) {
     //
-    Int_t maxBin = (fTimeBinsMax+4)*(fPadsMax+4);  
+    Int_t maxBin = (fTimeBinsMax+4)*(fPadsMax+4);
     fAllBins[iRow] = new Float_t[maxBin];
     memset(fAllBins[iRow],0,sizeof(Float_t)*maxBin); // set all values to 0
     fAllSigBins[iRow] = new Int_t[maxBin];
@@ -953,9 +933,7 @@ void AliTPCdataQA::MakeArrays(){
 
 //_____________________________________________________________________
 void AliTPCdataQA::CleanArrays(){
-  //
-  //
-  //
+  ///
 
   for (Int_t iRow = 0; iRow < fRowsMax; iRow++) {
 
@@ -964,15 +942,15 @@ void AliTPCdataQA::CleanArrays(){
     // memset is only called if there is more than 1000 signals for a
     // row (of the order 1% occupancy)
     if(fAllNSigBins[iRow]<1000) {
-      
+
       Float_t* allBins = fAllBins[iRow];
       Int_t* sigBins   = fAllSigBins[iRow];
       const Int_t nSignals = fAllNSigBins[iRow];
       for(Int_t i = 0; i < nSignals; i++)
-	allBins[sigBins[i]]=0;      
+	allBins[sigBins[i]]=0;
     } else {
 
-      Int_t maxBin = (fTimeBinsMax+4)*(fPadsMax+4); 
+      Int_t maxBin = (fTimeBinsMax+4)*(fPadsMax+4);
       memset(fAllBins[iRow],0,sizeof(Float_t)*maxBin);
     }
 
@@ -982,10 +960,8 @@ void AliTPCdataQA::CleanArrays(){
 
 //_____________________________________________________________________
 void AliTPCdataQA::GetPadAndTimeBin(Int_t bin, Int_t& iPad, Int_t& iTimeBin){
-  //
-  // Return pad and timebin for a given bin
-  //
-  
+  /// Return pad and timebin for a given bin
+
   //  Int_t bin = iPad*(fTimeBinsMax+4)+iTimeBin;
   iTimeBin  = bin%(fTimeBinsMax+4);
   iPad      = (bin-iTimeBin)/(fTimeBinsMax+4);
@@ -999,20 +975,19 @@ void AliTPCdataQA::GetPadAndTimeBin(Int_t bin, Int_t& iPad, Int_t& iTimeBin){
 }
 
 //_____________________________________________________________________
-void AliTPCdataQA::SetExpandDigit(const Int_t iRow, Int_t iPad, 
-				  Int_t iTimeBin, const Float_t signal) 
+void AliTPCdataQA::SetExpandDigit(const Int_t iRow, Int_t iPad,
+				  Int_t iTimeBin, const Float_t signal)
 {
-  //
-  // 
-  //
+  ///
+
   R__ASSERT(iRow>=0 && iRow<fRowsMax);
   R__ASSERT(iPad>=0 && iPad<=fPadsMax);
   R__ASSERT(iTimeBin>=fFirstTimeBin && iTimeBin<=fLastTimeBin);
-  
+
   iTimeBin -= fFirstTimeBin;
   iPad     += 2;
   iTimeBin += 2;
-  
+
   Int_t bin = iPad*(fTimeBinsMax+4)+iTimeBin;
   fAllBins[iRow][bin] = signal;
   fAllSigBins[iRow][fAllNSigBins[iRow]] = bin;
@@ -1020,30 +995,29 @@ void AliTPCdataQA::SetExpandDigit(const Int_t iRow, Int_t iPad,
 }
 
 //______________________________________________________________________________
-Float_t AliTPCdataQA::GetQ(const Float_t* adcArray, const Int_t time, 
-			   const Int_t pad, const Int_t maxTimeBins, 
-			   Int_t& timeMin, Int_t& timeMax, 
+Float_t AliTPCdataQA::GetQ(const Float_t* adcArray, const Int_t time,
+			   const Int_t pad, const Int_t maxTimeBins,
+			   Int_t& timeMin, Int_t& timeMax,
 			   Int_t& padMin,  Int_t& padMax) const
 {
-  //
-  // This methods return the charge in the bin time+pad*maxTimeBins
-  // If the charge is above 0 it also updates the padMin, padMax, timeMin
-  // and timeMax if necessary
-  //
+  /// This methods return the charge in the bin time+pad*maxTimeBins
+  /// If the charge is above 0 it also updates the padMin, padMax, timeMin
+  /// and timeMax if necessary
+
   Float_t charge = adcArray[time + pad*maxTimeBins];
   if(charge > 0) {
     timeMin = TMath::Min(time, timeMin); timeMax = TMath::Max(time, timeMax);
     padMin = TMath::Min(pad, padMin); padMax = TMath::Max(pad, padMax);
   }
-  return charge; 
+  return charge;
 }
 
 //______________________________________________________________________________
 void AliTPCdataQA::Streamer(TBuffer &xRuub)
 {
-  // Automatic schema evolution was first used from revision 4
-  // Code based on:
-  // http://root.cern.ch/root/roottalk/roottalk02/3207.html
+  /// Automatic schema evolution was first used from revision 4
+  /// Code based on:
+  /// http://root.cern.ch/root/roottalk/roottalk02/3207.html
 
    UInt_t xRuus, xRuuc;
    if (xRuub.IsReading()) {
@@ -1077,10 +1051,11 @@ void AliTPCdataQA::Streamer(TBuffer &xRuub)
 //____________________________________________________________________________________________
 void AliTPCdataQA::FillOccupancyProfile()
 {
-  // This has to be filled at the end of the loop over data
-  if(!fIsDQM) 
+  /// This has to be filled at the end of the loop over data
+
+  if(!fIsDQM)
     AliInfo("Method only meaningful for DQM");
-  
+
   for(Int_t i = 0; i < 72; i++) {
 
     fOccVec->GetArray()[i] /= fOccMaxVec->GetArray()[i];
@@ -1106,9 +1081,9 @@ void AliTPCdataQA::FillOccupancyProfile()
 //____________________________________________________________________________________________
 void AliTPCdataQA::ResetProfiles()
 {
-  if(!fIsDQM) 
+  if(!fIsDQM)
     AliInfo("Method only meaningful for DQM");
-  
+
   if(fHistQVsSector)
     fHistQVsSector->Reset();
   if(fHistQmaxVsSector)
@@ -1129,13 +1104,12 @@ void AliTPCdataQA::ResetProfiles()
 //____________________________________________________________________________________________
 void AliTPCdataQA::Init()
 {
-  //
-  // Define the calibration objects the first time Update is called
-  // NB! This has to be done first even if the data is rejected by the time
-  // cut to make sure that the objects are available in Analyse
-  //
+  /// Define the calibration objects the first time Update is called
+  /// NB! This has to be done first even if the data is rejected by the time
+  /// cut to make sure that the objects are available in Analyse
+
   if(!fIsDQM) {
-    
+
     if (!fNLocalMaxima){
       TObjArray configArr(72);
       fNLocalMaxima = new AliTPCCalPad(ConfigArrRocs(&configArr,"NLocalMaxima"));
@@ -1215,10 +1189,10 @@ void AliTPCdataQA::Init()
     }
   }
   // Make the arrays for expanding the data
-  
+
   if (!fAllBins)
     MakeArrays();
-  
+
   //
   // If Analyse has been previously called we need now to denormalize the data
   // as more data is coming
@@ -1241,11 +1215,10 @@ void AliTPCdataQA::Init()
 //____________________________________________________________________________________________
 void AliTPCdataQA::ResetData()
 {
-  //
-  // reset all data
-  //
+  /// reset all data
+
   if(!fIsDQM) {
-    
+
     if (fNLocalMaxima){
       fNoThreshold->Reset();
       fNLocalMaxima->Reset();
@@ -1257,26 +1230,24 @@ void AliTPCdataQA::ResetData()
       fOverThreshold10->Reset();
       fOverThreshold20->Reset();
       fOverThreshold30->Reset();
-      
+
       fHistQVsTimeSideA->Reset();
       fHistQVsTimeSideC->Reset();
       fHistQMaxVsTimeSideA->Reset();
       fHistQMaxVsTimeSideC->Reset();
 
       fIsAnalysed = kFALSE;
-      
+
     }
   }
-  
+
   fEventCounter=0;
   fClusterCounter=0;
 }
 
 TObjArray *AliTPCdataQA::ConfigArrRocs(TObjArray *arr, const Text_t* name)
 {
-  //
-  // GetArray with confiured ROCs
-  //
+  /// GetArray with confiured ROCs
 
   arr->Clear();
   arr->SetName(name);
@@ -1284,4 +1255,4 @@ TObjArray *AliTPCdataQA::ConfigArrRocs(TObjArray *arr, const Text_t* name)
     if (fActiveChambers[i]) arr->AddAt(new AliTPCCalROC(i),i);
   }
   return arr;
-}
\ No newline at end of file
+}
diff --git a/TPC/TPCbase/AliTPCdataQA.h b/TPC/TPCbase/AliTPCdataQA.h
index 2dae644c743..1bfde5d3087 100644
--- a/TPC/TPCbase/AliTPCdataQA.h
+++ b/TPC/TPCbase/AliTPCdataQA.h
@@ -1,3 +1,5 @@
+/// \class AliTPCdataQA
+
 #ifndef ALITPCDATAQA_H
 #define ALITPCDATAQA_H
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
@@ -48,7 +50,7 @@ public:
 
   void SetMinQMax               (Float_t minQmax  ) { fMinQMax                = minQmax; }
   void SetRequireNeighbouringPad(Bool_t  req=kTRUE) { fRequireNeighbouringPad = req;     }
-  
+
   // DQM methods
   void FillOccupancyProfile();
   void ResetProfiles();
@@ -97,7 +99,7 @@ public:
 
   Float_t GetMinQMax()                const { return fMinQMax;                }
   Bool_t  GetRequireNeighbouringPad() const { return fRequireNeighbouringPad; }
-  
+
   // DQM getter
   Bool_t    GetIsDQM() const { return fIsDQM; }
 
@@ -105,7 +107,7 @@ public:
   void  SetRangeAdc (Int_t aMin, Int_t aMax){ fAdcMin=aMin; fAdcMax=aMax; }  // Set adc range for the pedestal calibration
   void  SetMaxEvents   (Int_t value) { fMaxEvents = value; }
   void  SetEventsPerBin(Int_t value) { fEventsPerBin = value; }
-  
+
   // DQM setter
   void  SetIsDQM(Bool_t value) { fIsDQM = value; }
 
@@ -121,11 +123,11 @@ private:
 
   void MakeArrays();                // Create arrays for random data acces
   void CleanArrays();               // Clean arrays for random data acces
-  void SetExpandDigit(const Int_t iRow, Int_t iPad, Int_t iTimeBin, 
+  void SetExpandDigit(const Int_t iRow, Int_t iPad, Int_t iTimeBin,
 		      const Float_t signal); // Fill arrays with signals
   void GetPadAndTimeBin(Int_t bin, Int_t& iPad, Int_t& iTimeBin); // Get pad and time bin corresponding to the 1d bin
   Float_t GetQ(const Float_t* adcArray, const Int_t time,
-	       const Int_t pad, const Int_t maxTimeBins, 
+	       const Int_t pad, const Int_t maxTimeBins,
 	       Int_t& timeMin,Int_t& timeMax,Int_t& padMin,Int_t& padMax) const;
   void UpdateEventHistograms();
 
@@ -133,71 +135,73 @@ private:
 
   TObjArray *ConfigArrRocs(TObjArray *arr, const Text_t* name);
 
-  Int_t fFirstTimeBin;              //  First Time bin needed for analysis
-  Int_t fLastTimeBin;               //  Last Time bin needed for analysis
-  Int_t fAdcMin;                    //  min adc channel of pedestal value
-  Int_t fAdcMax;                    //  max adc channel of pedestal value
-  Float_t fMinQMax;                 //  Minimun charge for Maximum ADC in cluster
-  Bool_t fRequireNeighbouringPad;   //  If clusterer should require a neighbouring pad to accept it
-  
+  Int_t fFirstTimeBin;              ///< First Time bin needed for analysis
+  Int_t fLastTimeBin;               ///< Last Time bin needed for analysis
+  Int_t fAdcMin;                    ///< min adc channel of pedestal value
+  Int_t fAdcMax;                    ///< max adc channel of pedestal value
+  Float_t fMinQMax;                 ///< Minimun charge for Maximum ADC in cluster
+  Bool_t fRequireNeighbouringPad;   ///< If clusterer should require a neighbouring pad to accept it
+
 
-  AliTPCAltroMapping **fMapping;    //! Altro Mapping object
+  AliTPCAltroMapping **fMapping;    //!< Altro Mapping object
   //
   //
-  AliTPCCalPad * fPedestal;         //! option to set pedestal cal object
-  AliTPCCalPad * fNoise;            //! option to set noise cal object
-  AliTPCCalPad * fNLocalMaxima;     // local maximas found
-  AliTPCCalPad * fMaxCharge;        // max charge
-  AliTPCCalPad * fMeanCharge;       // mean charge
-  AliTPCCalPad * fNoThreshold;      // number of digits
-  AliTPCCalPad * fNTimeBins;        // timebins width of cluster
-  AliTPCCalPad * fNPads;            // pads with of cluster
-  AliTPCCalPad * fTimePosition;     // Time position of local maximum
-  AliTPCCalPad * fOverThreshold10;  //! local maxima with qMax over threshold
-  AliTPCCalPad * fOverThreshold20;  //! local maxima with qMax over threshold
-  AliTPCCalPad * fOverThreshold30;  //! local maxima with qMax over threshold
-
-  TProfile* fHistQVsTimeSideA;      // Q vs time (side A)
-  TProfile* fHistQVsTimeSideC;	    // Q vs time (side C)
-  TProfile* fHistQMaxVsTimeSideA;   // QMax vs time (side A)
-  TProfile* fHistQMaxVsTimeSideC;   // QMax vs time (side C)
-
-  TH1F* fHistOccupancyVsEvent;      // Occupancy vs event number (~time)
-  TH1F* fHistNclustersVsEvent;      // Nclusters vs event number (~time)
-
-  Int_t   fEventCounter;            // event Counter
-  Bool_t  fIsAnalysed;              // Set to true after Analyse has been called
-
-  Int_t fMaxEvents;                 // Max events for event histograms
-  Int_t fEventsPerBin;              // Events per bin for event histograms
-  Int_t fSignalCounter;             // Signal counter
-  Int_t fClusterCounter;            // Cluster counter
-
-  TBits fActiveChambers;           // configured ROCs
+  AliTPCCalPad * fPedestal;         //!< option to set pedestal cal object
+  AliTPCCalPad * fNoise;            //!< option to set noise cal object
+  AliTPCCalPad * fNLocalMaxima;     ///< local maximas found
+  AliTPCCalPad * fMaxCharge;        ///< max charge
+  AliTPCCalPad * fMeanCharge;       ///< mean charge
+  AliTPCCalPad * fNoThreshold;      ///< number of digits
+  AliTPCCalPad * fNTimeBins;        ///< timebins width of cluster
+  AliTPCCalPad * fNPads;            ///< pads with of cluster
+  AliTPCCalPad * fTimePosition;     ///< Time position of local maximum
+  AliTPCCalPad * fOverThreshold10;  //!< local maxima with qMax over threshold
+  AliTPCCalPad * fOverThreshold20;  //!< local maxima with qMax over threshold
+  AliTPCCalPad * fOverThreshold30;  //!< local maxima with qMax over threshold
+
+  TProfile* fHistQVsTimeSideA;      ///< Q vs time (side A)
+  TProfile* fHistQVsTimeSideC;	    ///< Q vs time (side C)
+  TProfile* fHistQMaxVsTimeSideA;   ///< QMax vs time (side A)
+  TProfile* fHistQMaxVsTimeSideC;   ///< QMax vs time (side C)
+
+  TH1F* fHistOccupancyVsEvent;      ///< Occupancy vs event number (~time)
+  TH1F* fHistNclustersVsEvent;      ///< Nclusters vs event number (~time)
+
+  Int_t   fEventCounter;            ///< event Counter
+  Bool_t  fIsAnalysed;              ///< Set to true after Analyse has been called
+
+  Int_t fMaxEvents;                 ///< Max events for event histograms
+  Int_t fEventsPerBin;              ///< Events per bin for event histograms
+  Int_t fSignalCounter;             ///< Signal counter
+  Int_t fClusterCounter;            ///< Cluster counter
+
+  TBits fActiveChambers;           ///< configured ROCs
 
   //
   //  Expand buffer
   //
-  Float_t** fAllBins;              //! array for digit using random access
-  Int_t**   fAllSigBins;           //! array of pointers to the indexes over threshold
-  Int_t*    fAllNSigBins;          //! 
-  Int_t fRowsMax;                  //!  Maximum number of time bins
-  Int_t fPadsMax;                  //!  Maximum number of time bins
-  Int_t fTimeBinsMax;              //!  Maximum number of time bins
+  Float_t** fAllBins;              //!< array for digit using random access
+  Int_t**   fAllSigBins;           //!< array of pointers to the indexes over threshold
+  Int_t*    fAllNSigBins;          //!<
+  Int_t fRowsMax;                  //!< Maximum number of time bins
+  Int_t fPadsMax;                  //!< Maximum number of time bins
+  Int_t fTimeBinsMax;              //!< Maximum number of time bins
 
   // DQM variables
-  Bool_t fIsDQM;                   //!  Is DQM -> Simple output (no 2D!)
-  TProfile* fHistOccVsSector;      //!  Occ vs sector (for DQM only)
-  TProfile2D* fHistOcc2dVsSector;  //!  Occ vs sector 2D (for DQM only)
-  TProfile* fHistQVsSector;        //!  Q vs sector (for DQM only)
-  TProfile* fHistQmaxVsSector;     //!  QMax vs sector (for DQM only)
-  TArrayD* fOccVec;                //!  Occupancy help counter for DQM
-  TArrayD* fOccMaxVec;             //!  Occupancy help normlization for DQM
-  TArrayD* fOccVecFine;            //!  "2D" occupancy help counter for DQM
-  TArrayD* fOccMaxVecFine;         //!  "2D" occupancy help normlization for DQM
-  
-
+  Bool_t fIsDQM;                   //!< Is DQM -> Simple output (no 2D!)
+  TProfile* fHistOccVsSector;      //!< Occ vs sector (for DQM only)
+  TProfile2D* fHistOcc2dVsSector;  //!< Occ vs sector 2D (for DQM only)
+  TProfile* fHistQVsSector;        //!< Q vs sector (for DQM only)
+  TProfile* fHistQmaxVsSector;     //!< QMax vs sector (for DQM only)
+  TArrayD* fOccVec;                //!< Occupancy help counter for DQM
+  TArrayD* fOccMaxVec;             //!< Occupancy help normlization for DQM
+  TArrayD* fOccVecFine;            //!< "2D" occupancy help counter for DQM
+  TArrayD* fOccMaxVecFine;         //!< "2D" occupancy help normlization for DQM
+
+
+  /// \cond CLASSIMP
   ClassDef(AliTPCdataQA, 6)  // Implementation of the TPC Raw QA
+  /// \endcond
 };
 
 
diff --git a/TPC/TPCbase/AliTPCmapper.cxx b/TPC/TPCbase/AliTPCmapper.cxx
index 0b33888e130..b9119c3e5ba 100644
--- a/TPC/TPCbase/AliTPCmapper.cxx
+++ b/TPC/TPCbase/AliTPCmapper.cxx
@@ -13,27 +13,26 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-//-------------------------------------------------------------------------
-//
-// AliTPCmapper
-// Authors: Christian.Lippmann@cern.ch, J.Wiechula@gsi.de
-// Class to map detector coordinates (row, pad, sector, ...) to
-// hardware coordinates (RCU, Branch, FEC, Altro, channel, Equipment ID, ...)
-// 
-// There are two different ways to number padrows:
-// 1) local padrow: for each ROC, 0 ... 62 for an IROC, 0 ... 95 for an OROC,
-// 2) global padrow: for each sector, from 0 ... 158.
-// If the global numbering is used, it is denoted by the variable name
-// globalpadrow in this class.
-//
-// There are two different ways to number sectors:
-// 1) Sectors contain one IROC and one OROC and are counted from 0 to 17 on
-//    each of the two sides (A=0 and C=1),
-// 2) ROCs are numbered from 0 to 71 where the ROCs 0 ... 35 are IROCS and
-//    ROCs 36 ... 71 are OROCs. A ROC is often named "sector" in aliroot,
-//    which can be very confusing!
-//
-//-------------------------------------------------------------------------
+/// \class AliTPCmapper
+/// \brief AliTPCmapper
+///
+/// Class to map detector coordinates (row, pad, sector, ...) to
+/// hardware coordinates (RCU, Branch, FEC, Altro, channel, Equipment ID, ...)
+///
+/// There are two different ways to number padrows:
+/// 1) local padrow: for each ROC, 0 ... 62 for an IROC, 0 ... 95 for an OROC,
+/// 2) global padrow: for each sector, from 0 ... 158.
+/// If the global numbering is used, it is denoted by the variable name
+/// globalpadrow in this class.
+///
+/// There are two different ways to number sectors:
+/// 1) Sectors contain one IROC and one OROC and are counted from 0 to 17 on
+///   each of the two sides (A=0 and C=1),
+/// 2) ROCs are numbered from 0 to 71 where the ROCs 0 ... 35 are IROCS and
+///   ROCs 36 ... 71 are OROCs. A ROC is often named "sector" in aliroot,
+///   which can be very confusing!
+///
+/// \author Christian.Lippmann@cern.ch, J.Wiechula@gsi.de
 
 #include <TMath.h>
 #include <TSystem.h>
@@ -45,7 +44,9 @@
 #include "AliLog.h"
 #include "AliDAQ.h"
 
+/// \cond CLASSIMP
 ClassImp(AliTPCmapper)
+/// \endcond
 //______________________________________________________________
 AliTPCmapper::AliTPCmapper() :
   fNside(0),
@@ -78,18 +79,17 @@ AliTPCmapper::AliTPCmapper(const char * dirname) :
   fNpadrowOROC(0),
   fTpcDdlOffset(0)
 {
-  //
-  // Constructor
-  //
-  // dirname - specify the directory with the ascii Altro mapping files
-  //
+  /// Constructor
+  ///
+  /// dirname - specify the directory with the ascii Altro mapping files
+
   Init(dirname);
 }
 
 //______________________________________________________________
 AliTPCmapper::~AliTPCmapper()
 {
-  // Destructor
+  /// Destructor
 
   for ( Int_t i = 0; i < fNrcu; i++ ) {
     delete fMapping[i];
@@ -112,7 +112,8 @@ AliTPCmapper::AliTPCmapper(const AliTPCmapper& mapper) :
   fNpadrowOROC(mapper.fNpadrowOROC),
   fTpcDdlOffset(mapper.fTpcDdlOffset)
 {
-  // Copy Constructor
+  /// Copy Constructor
+
   for ( Int_t i = 0; i < 6; i++ )  fMapping[i]=0;
   for ( Int_t i = 0; i < fNrcu; i++ ) fMapping[i] = mapper.fMapping[i];
 }
@@ -120,7 +121,7 @@ AliTPCmapper::AliTPCmapper(const AliTPCmapper& mapper) :
 //_____________________________________________________________________________
 AliTPCmapper& AliTPCmapper::operator = (const AliTPCmapper& mapper)
 {
-  // Assignment operator
+  /// Assignment operator
 
   if(&mapper == this) return *this;
   ((TObject *)this)->operator=(mapper);
@@ -144,7 +145,8 @@ AliTPCmapper& AliTPCmapper::operator = (const AliTPCmapper& mapper)
 //______________________________________________________________
 void AliTPCmapper::Init(const char *dirname)
 {
-  // Initialize all
+  /// Initialize all
+
   fNside    = 2;
   fNsector  = 18;
   fNrcu     = 6;
@@ -186,7 +188,8 @@ void AliTPCmapper::Init(const char *dirname)
 //_____________________________________________________________________________
 Int_t AliTPCmapper::GetHWAddress(Int_t roc, Int_t padrow, Int_t pad) const
 {
-  // Get the hardware address from pad coordinates for a given ROC
+  /// Get the hardware address from pad coordinates for a given ROC
+
   Int_t patch = GetPatch(roc, padrow, pad);
   if ( (patch >= fNrcu) || (patch < 0) ) return -1;
   return fMapping[patch]->GetHWAddress(padrow, pad, roc);
@@ -196,7 +199,8 @@ Int_t AliTPCmapper::GetHWAddress(Int_t roc, Int_t padrow, Int_t pad) const
 //_____________________________________________________________________________
 Int_t AliTPCmapper::GetHWAddressSector(Int_t globalpadrow, Int_t pad) const
 {
-  // Get the hardware address from pad coordinates
+  /// Get the hardware address from pad coordinates
+
   Int_t patch = 0;
   Int_t hwAddress=-1;
   if ( globalpadrow < fNpadrowIROC   ) {
@@ -218,8 +222,9 @@ Int_t AliTPCmapper::GetHWAddressSector(Int_t globalpadrow, Int_t pad) const
 //_____________________________________________________________________________
 Int_t AliTPCmapper::GetRcu(Int_t roc, Int_t padrow, Int_t pad) const
 {
-  // Get the patch (rcu) index from the pad coordinates. The Roc index is
-  // needed as well to determine if it is IROC or OROC. 
+  /// Get the patch (rcu) index from the pad coordinates. The Roc index is
+  /// needed as well to determine if it is IROC or OROC.
+
   return GetPatch(roc, padrow, pad);
 }
 
@@ -227,8 +232,8 @@ Int_t AliTPCmapper::GetRcu(Int_t roc, Int_t padrow, Int_t pad) const
 //_____________________________________________________________________________
 Int_t AliTPCmapper::GetPatch(Int_t roc, Int_t padrow, Int_t pad) const
 {
-  // Get the patch (rcu) index from the pad coordinates. The Roc index is
-  // needed as well to determine if it is IROC or OROC. 
+  /// Get the patch (rcu) index from the pad coordinates. The Roc index is
+  /// needed as well to determine if it is IROC or OROC.
 
   if ( (padrow < 0) || (pad < 0) || (roc < 0) ) {
     AliWarning(Form("Pad coordinates outside range (padrow %d, pad %d, roc %d) !", padrow, pad, roc));
@@ -280,7 +285,8 @@ Int_t AliTPCmapper::GetPatch(Int_t roc, Int_t padrow, Int_t pad) const
 //_____________________________________________________________________________
 Int_t AliTPCmapper::GetRcuSector(Int_t globalpadrow, Int_t pad) const
 {
-  // Get the patch (rcu) index from the pad coordinates for a sector
+  /// Get the patch (rcu) index from the pad coordinates for a sector
+
   return GetPatchSector(globalpadrow, pad);
 }
 
@@ -288,7 +294,8 @@ Int_t AliTPCmapper::GetRcuSector(Int_t globalpadrow, Int_t pad) const
 //_____________________________________________________________________________
 Int_t AliTPCmapper::GetPatchSector(Int_t globalpadrow, Int_t pad) const
 {
-  // Get the patch (rcu) index from the pad coordinates for a sector
+  /// Get the patch (rcu) index from the pad coordinates for a sector
+
   if ( globalpadrow >= fNpadrow ) {
     AliWarning(Form("Padrow outside range (globalpadrow %d) !", globalpadrow));
     return -1;
@@ -301,7 +308,8 @@ Int_t AliTPCmapper::GetPatchSector(Int_t globalpadrow, Int_t pad) const
 //_____________________________________________________________________________
 Int_t AliTPCmapper::GetPadRow(Int_t patch, Int_t hwAddress) const
 {
-  // Get Pad Row (for a ROC) from the hardware address
+  /// Get Pad Row (for a ROC) from the hardware address
+
   if ( (patch >= fNrcu) || (patch < 0) ) {
     AliWarning(Form("Patch index outside range (patch %d) !", patch));
     return -1;
@@ -313,7 +321,8 @@ Int_t AliTPCmapper::GetPadRow(Int_t patch, Int_t hwAddress) const
 //_____________________________________________________________________________
   Int_t AliTPCmapper::GetGlobalPadRow(Int_t patch, Int_t hwAddress) const
 {
-  // Get Pad Row (for full sector) from the hardware address
+  /// Get Pad Row (for full sector) from the hardware address
+
   if ( patch < 2 ) return GetPadRow(patch, hwAddress);
   else             return GetPadRow(patch, hwAddress) + fNpadrowIROC;
 }
@@ -322,7 +331,8 @@ Int_t AliTPCmapper::GetPadRow(Int_t patch, Int_t hwAddress) const
 //_____________________________________________________________________________
 Int_t AliTPCmapper::GetPad(Int_t patch, Int_t hwAddress) const
 {
-  // Get Pad index from the hardware address
+  /// Get Pad index from the hardware address
+
   if ( (patch >= fNrcu) || (patch < 0) ) {
     AliWarning(Form("Patch index outside range (patch %d) !", patch));
     return -1;
@@ -335,7 +345,8 @@ Int_t AliTPCmapper::GetPad(Int_t patch, Int_t hwAddress) const
 Int_t AliTPCmapper::GetPadRow(Int_t patch, Int_t branch, Int_t fec, Int_t chip,
 			      Int_t channel) const
 {
-  // Get pad row (for a ROC) from hardware coordinates
+  /// Get pad row (for a ROC) from hardware coordinates
+
   if ( (patch >= fNrcu) || (branch >= fNbranch) || (chip >= fNaltro) || (channel >= fNchannel)
        || (patch < 0) || (branch < 0) || (chip < 0) || (channel < 0) ) {
     AliWarning(Form("Coordinates outside range (patch %d, branch %d, fec %d, chip %d, channel %d)) !",
@@ -350,7 +361,8 @@ Int_t AliTPCmapper::GetPadRow(Int_t patch, Int_t branch, Int_t fec, Int_t chip,
 Int_t AliTPCmapper::GetGlobalPadRow(Int_t patch, Int_t branch, Int_t fec, Int_t chip,
 				    Int_t channel) const
 {
-  // Get Pad Row (for full sector) from the hardware address
+  /// Get Pad Row (for full sector) from the hardware address
+
   if ( (patch >= fNrcu) || (branch >= fNbranch) || (chip >= fNaltro) || (channel >= fNchannel)
        || (patch < 0) || (branch < 0) || (chip < 0) || (channel < 0) ) {
     AliWarning(Form("Coordinates outside range (patch %d, branch %d, fec %d, chip %d, channel %d)) !",
@@ -365,7 +377,8 @@ Int_t AliTPCmapper::GetGlobalPadRow(Int_t patch, Int_t branch, Int_t fec, Int_t
 //_____________________________________________________________________________
   Int_t AliTPCmapper::GetPad(Int_t patch, Int_t branch, Int_t fec, Int_t chip, Int_t channel) const
 {
-  // Get pad from hardware coordinates
+  /// Get pad from hardware coordinates
+
   if ( (patch >= fNrcu) || (branch >= fNbranch) || (chip >= fNaltro) || (channel >= fNchannel)
        || (patch < 0) || (branch < 0) || (chip < 0) || (channel < 0) ) {
     AliWarning(Form("Coordinates outside range (patch %d, branch %d, fec %d, chip %d, channel %d)) !",
@@ -379,9 +392,10 @@ Int_t AliTPCmapper::GetGlobalPadRow(Int_t patch, Int_t branch, Int_t fec, Int_t
 //_____________________________________________________________________________
 Int_t AliTPCmapper::GetBranch(Int_t roc, Int_t padrow, Int_t pad) const
 {
-  // Get the branch to which this pad is connected. The FECs connected to
-  // one RCU are divided into two branches: A(=0) and B(=1). This information
-  // can be extracted from the hardware address.
+  /// Get the branch to which this pad is connected. The FECs connected to
+  /// one RCU are divided into two branches: A(=0) and B(=1). This information
+  /// can be extracted from the hardware address.
+
   return DecodedHWAddressBranch(GetHWAddress(roc, padrow, pad));
 }
 
@@ -389,8 +403,9 @@ Int_t AliTPCmapper::GetBranch(Int_t roc, Int_t padrow, Int_t pad) const
 //_____________________________________________________________________________
 Int_t AliTPCmapper::GetBranchSector(Int_t globalpadrow, Int_t pad) const
 {
-  // Get Branch from pad coordinates, where globalpadrow is counted
-  // for a full sector (0 ... 158)
+  /// Get Branch from pad coordinates, where globalpadrow is counted
+  /// for a full sector (0 ... 158)
+
   return DecodedHWAddressBranch(GetHWAddressSector(globalpadrow, pad));
 }
 
@@ -398,10 +413,11 @@ Int_t AliTPCmapper::GetBranchSector(Int_t globalpadrow, Int_t pad) const
 //_____________________________________________________________________________
 Int_t AliTPCmapper::GetFEChw(Int_t roc, Int_t padrow, Int_t pad) const
 {
-  // Get the FEC number in hardware numbering. The FECs are numbered from 0 (in the
-  // center of the partition) to 8 (partition 3, 4, 5), 9 (partition 0, 2), 11
-  // (partition 1, branch A) or 12 (partition 1, branch B). This information
-  // can be extracted from the hardware address.
+  /// Get the FEC number in hardware numbering. The FECs are numbered from 0 (in the
+  /// center of the partition) to 8 (partition 3, 4, 5), 9 (partition 0, 2), 11
+  /// (partition 1, branch A) or 12 (partition 1, branch B). This information
+  /// can be extracted from the hardware address.
+
   return DecodedHWAddressFECaddr(GetHWAddress(roc, padrow, pad));
 }
 
@@ -409,8 +425,9 @@ Int_t AliTPCmapper::GetFEChw(Int_t roc, Int_t padrow, Int_t pad) const
 //_____________________________________________________________________________
 Int_t AliTPCmapper::GetFEChwSector(Int_t globalpadrow, Int_t pad) const
 {
-  // Get the FEC number in hardware numbering from pad coordinates, where 
-  // globalpadrow is counted for a full sector (0 ... 158)
+  /// Get the FEC number in hardware numbering from pad coordinates, where
+  /// globalpadrow is counted for a full sector (0 ... 158)
+
   return DecodedHWAddressFECaddr(GetHWAddressSector(globalpadrow, pad));
 }
 
@@ -418,8 +435,9 @@ Int_t AliTPCmapper::GetFEChwSector(Int_t globalpadrow, Int_t pad) const
 //_____________________________________________________________________________
 Int_t AliTPCmapper::GetFEC(Int_t roc, Int_t padrow, Int_t pad) const
 {
-  // Get the FEC number in offline-oriented numbering. The FECs are numbered from 0
-  // 17 (partition 3, 4, 5), 19 (partition 0, 2) or 24 (partition 1).
+  /// Get the FEC number in offline-oriented numbering. The FECs are numbered from 0
+  /// 17 (partition 3, 4, 5), 19 (partition 0, 2) or 24 (partition 1).
+
   Int_t patch  = GetPatch(roc, padrow, pad);
   Int_t fec    = DecodedHWAddressFECaddr(GetHWAddress(roc, padrow, pad));
   Int_t branch = DecodedHWAddressBranch(GetHWAddress(roc, padrow, pad));
@@ -431,8 +449,9 @@ Int_t AliTPCmapper::GetFEC(Int_t roc, Int_t padrow, Int_t pad) const
 //_____________________________________________________________________________
 Int_t AliTPCmapper::GetFECSector(Int_t globalpadrow, Int_t pad) const
 {
-  // Get the FEC number in offline-oriented numbering. globalpadrow is
-  // counted for a full sector (0 ... 158)
+  /// Get the FEC number in offline-oriented numbering. globalpadrow is
+  /// counted for a full sector (0 ... 158)
+
   Int_t patch  = GetPatchSector(globalpadrow, pad);
   Int_t fec    = DecodedHWAddressFECaddr(GetHWAddressSector(globalpadrow, pad));
   Int_t branch = DecodedHWAddressBranch(GetHWAddressSector(globalpadrow, pad));
@@ -444,7 +463,8 @@ Int_t AliTPCmapper::GetFECSector(Int_t globalpadrow, Int_t pad) const
 //_____________________________________________________________________________
 Int_t AliTPCmapper::GetChip(Int_t roc, Int_t padrow, Int_t pad) const
 {
-  // Get Chip (ALTRO) index (0 ... 7) from pad coordinates
+  /// Get Chip (ALTRO) index (0 ... 7) from pad coordinates
+
   return DecodedHWAddressChipaddr(GetHWAddress(roc, padrow, pad));
 }
 
@@ -452,8 +472,9 @@ Int_t AliTPCmapper::GetChip(Int_t roc, Int_t padrow, Int_t pad) const
 //_____________________________________________________________________________
 Int_t AliTPCmapper::GetChipSector(Int_t globalpadrow, Int_t pad) const
 {
-  // Get Chip (ALTRO) index (0 ... 7) from pad coordinates, where 
-  // globalpadrow is counted for a full sector (0 ... 158)
+  /// Get Chip (ALTRO) index (0 ... 7) from pad coordinates, where
+  /// globalpadrow is counted for a full sector (0 ... 158)
+
   return DecodedHWAddressChipaddr(GetHWAddressSector(globalpadrow, pad));
 }
 
@@ -461,7 +482,8 @@ Int_t AliTPCmapper::GetChipSector(Int_t globalpadrow, Int_t pad) const
 //_____________________________________________________________________________
 Int_t AliTPCmapper::GetChannel(Int_t roc, Int_t padrow, Int_t pad) const
 {
-  // Get Channel index (0 ... 15) from pad coordinates
+  /// Get Channel index (0 ... 15) from pad coordinates
+
   return DecodedHWAddressChanneladdr(GetHWAddress(roc, padrow, pad));
 }
 
@@ -469,8 +491,9 @@ Int_t AliTPCmapper::GetChannel(Int_t roc, Int_t padrow, Int_t pad) const
 //_____________________________________________________________________________
 Int_t AliTPCmapper::GetChannelSector(Int_t globalpadrow, Int_t pad) const
 {
-  // Get Channel index (0 ... 15) from pad coordinates, where 
-  // globalpadrow is counted for a full sector (0 ... 158)
+  /// Get Channel index (0 ... 15) from pad coordinates, where
+  /// globalpadrow is counted for a full sector (0 ... 158)
+
   return DecodedHWAddressChanneladdr(GetHWAddressSector(globalpadrow, pad));
 }
 
@@ -478,7 +501,8 @@ Int_t AliTPCmapper::GetChannelSector(Int_t globalpadrow, Int_t pad) const
 //_____________________________________________________________________________
 Int_t AliTPCmapper::CodeHWAddress(Int_t branch, Int_t fec, Int_t chip, Int_t channel) const
 {
-  // Get Hardware address from channel, altro, fec and branch coordinates
+  /// Get Hardware address from channel, altro, fec and branch coordinates
+
   return ((branch&1)<<11) + ((fec&0xf)<<7) + ((chip&0x7)<<4) + (channel&0xf);
 }
 
@@ -486,7 +510,8 @@ Int_t AliTPCmapper::CodeHWAddress(Int_t branch, Int_t fec, Int_t chip, Int_t cha
 //_____________________________________________________________________________
 Int_t AliTPCmapper::DecodedHWAddressBranch(Int_t hwAddress) const
 {
-  // Get branch index (0, 1) from hardware address
+  /// Get branch index (0, 1) from hardware address
+
   if ( hwAddress < 0 ) return -1;
   return ((hwAddress>>11)&1);
 }
@@ -495,7 +520,8 @@ Int_t AliTPCmapper::DecodedHWAddressBranch(Int_t hwAddress) const
 //_____________________________________________________________________________
 Int_t AliTPCmapper::DecodedHWAddressFECaddr(Int_t hwAddress) const
 {
-  // Get FEC index (0 ... 12) from hardware address
+  /// Get FEC index (0 ... 12) from hardware address
+
   if ( hwAddress < 0 ) return -1;
   return ((hwAddress>>7)&0xf);
 }
@@ -504,7 +530,8 @@ Int_t AliTPCmapper::DecodedHWAddressFECaddr(Int_t hwAddress) const
 //_____________________________________________________________________________
 Int_t AliTPCmapper::DecodedHWAddressChipaddr(Int_t hwAddress) const
 {
-  // Get ALTRO index (0 ... 7) from hardware address
+  /// Get ALTRO index (0 ... 7) from hardware address
+
   if ( hwAddress < 0 ) return -1;
   return ((hwAddress>>4)&0x7);
 }
@@ -513,7 +540,8 @@ Int_t AliTPCmapper::DecodedHWAddressChipaddr(Int_t hwAddress) const
 //_____________________________________________________________________________
 Int_t AliTPCmapper::DecodedHWAddressChanneladdr(Int_t hwAddress) const
 {
-  // Get channel index (0 ... 15) from hardware address
+  /// Get channel index (0 ... 15) from hardware address
+
   if ( hwAddress < 0 ) return -1;
   return ((hwAddress&0xf));
 }
@@ -521,7 +549,8 @@ Int_t AliTPCmapper::DecodedHWAddressChanneladdr(Int_t hwAddress) const
 
 //______________________________________________________________
 Int_t AliTPCmapper::GetNpads(Int_t roc, Int_t padrow) const{
-  // Get number of pads in padrow for this ROC.
+  /// Get number of pads in padrow for this ROC.
+
   AliTPCROC *fROC = AliTPCROC::Instance();
   Int_t retval = fROC->GetNPads((UInt_t)roc, (UInt_t)padrow);
   return retval;
@@ -530,7 +559,7 @@ Int_t AliTPCmapper::GetNpads(Int_t roc, Int_t padrow) const{
 
 //______________________________________________________________
 Int_t AliTPCmapper::GetNpads(Int_t globalpadrow) const{
-  // Get number of pads in padrow, where globalpadrow is counted for a full sector (0 ... 158)
+  /// Get number of pads in padrow, where globalpadrow is counted for a full sector (0 ... 158)
 
   if ( globalpadrow >= fNpadrow ) {
     AliWarning(Form("Padrow outside range (globalpadrow %d) !", globalpadrow));
@@ -546,7 +575,8 @@ Int_t AliTPCmapper::GetNpads(Int_t globalpadrow) const{
 //______________________________________________________________
 Int_t AliTPCmapper::GetNpadrows(Int_t roc) const
 {
-  // Get number of padrows
+  /// Get number of padrows
+
   if      (roc < 36) return fNpadrowIROC;
   else if (roc < 72) return fNpadrowOROC;
   return -1;
@@ -687,7 +717,8 @@ Double_t AliTPCmapper::GetPadLength(Int_t globalpadrow) const
 //_____________________________________________________________________________
 Int_t AliTPCmapper::GetNfec(Int_t patch) const
 {
-  // Get size of readout partition (number of FECs) for this rcu (patch) index (0 ... 5)
+  /// Get size of readout partition (number of FECs) for this rcu (patch) index (0 ... 5)
+
   Int_t retval = 0;
   switch(patch){
   case(0):
@@ -716,7 +747,8 @@ Int_t AliTPCmapper::GetNfec(Int_t patch) const
 //_____________________________________________________________________________
 Int_t AliTPCmapper::GetNfec(Int_t patch, Int_t branch) const
 {
-  // Get size of readout partition (number of FECs) for this branch
+  /// Get size of readout partition (number of FECs) for this branch
+
   Int_t retval = 0;
   switch(patch){
   case(0):
@@ -738,7 +770,7 @@ Int_t AliTPCmapper::GetNfec(Int_t patch, Int_t branch) const
     retval = 10;
     break;
   };
-  
+
   if( (branch == 1) && (patch == 1) ){
     retval = 12;
   }
@@ -750,7 +782,7 @@ Int_t AliTPCmapper::GetNfec(Int_t patch, Int_t branch) const
 //_____________________________________________________________________________
 Int_t AliTPCmapper::OfflineToHwFec(Int_t patch, Int_t fec) const
 {
-  // Convert FEC position in offline-like numbering to hardware numbering (fec).
+  /// Convert FEC position in offline-like numbering to hardware numbering (fec).
 
   if ( (patch < 0) || (fec < 0) ) {
     AliWarning(Form("Patch (%d) or Fec number (%d) outside range !", patch, fec));
@@ -774,7 +806,7 @@ Int_t AliTPCmapper::OfflineToHwFec(Int_t patch, Int_t fec) const
 //_____________________________________________________________________________
 Int_t AliTPCmapper::OfflineToHwBranch(Int_t patch, Int_t fec) const
 {
-  // Convert fec position in offline-like numbering to hardware numbering (branch).
+  /// Convert fec position in offline-like numbering to hardware numbering (branch).
 
   if ( (patch < 0) || (fec < 0) ) {
     AliWarning(Form("Patch (%d) or Fec number (%d) outside range !", patch, fec));
@@ -794,7 +826,7 @@ Int_t AliTPCmapper::OfflineToHwBranch(Int_t patch, Int_t fec) const
 //_____________________________________________________________________________
 Int_t AliTPCmapper::HwToOffline(Int_t patch, Int_t branch, Int_t fec) const
 {
-  // Convert hardware FEC position (branch, fec) to the offline-oriented numbering
+  /// Convert hardware FEC position (branch, fec) to the offline-oriented numbering
 
   if ( (patch < 0) || (fec < 0) || (branch < 0) ) {
     AliWarning(Form("Patch (%d), branch (%d) or Fec number (%d) outside range !", patch, branch, fec));
@@ -817,8 +849,8 @@ Int_t AliTPCmapper::HwToOffline(Int_t patch, Int_t branch, Int_t fec) const
 //_____________________________________________________________________________
 Int_t AliTPCmapper::GetEquipmentID(Int_t roc, Int_t padrow, Int_t pad) const
 {
-  // Get EqID from pad coordinate. The Roc index is
-  // needed as well to determine if it is IROC or OROC. 
+  /// Get EqID from pad coordinate. The Roc index is
+  /// needed as well to determine if it is IROC or OROC.
 
   Int_t side = GetSideFromRoc(roc);
   if ( side < 0 ) return -1;
@@ -833,7 +865,8 @@ Int_t AliTPCmapper::GetEquipmentID(Int_t roc, Int_t padrow, Int_t pad) const
 //_____________________________________________________________________________
 Int_t AliTPCmapper::GetEquipmentIDsector(Int_t side, Int_t sector, Int_t globalpadrow, Int_t pad) const
 {
-  // Get EqID from pad coordinate, where padrow is counted for a full sector (0 ... 158)
+  /// Get EqID from pad coordinate, where padrow is counted for a full sector (0 ... 158)
+
   Int_t patch = GetPatchSector(globalpadrow, pad);
   if ( patch < 0 ) return -1;
   Int_t roc = GetRocFromPatch(side, sector, patch);
@@ -849,7 +882,7 @@ Int_t AliTPCmapper::GetEquipmentIDsector(Int_t side, Int_t sector, Int_t globalp
 //_____________________________________________________________________________
 Int_t AliTPCmapper::GetEquipmentIDfromPatch(Int_t side, Int_t sector, Int_t patch) const
 {
-  // Get EqID from patch (rcu).
+  /// Get EqID from patch (rcu).
 
   Int_t roc = GetRocFromPatch(side, sector, patch);
   Int_t ddl = 0;
@@ -865,7 +898,8 @@ Int_t AliTPCmapper::GetEquipmentIDfromPatch(Int_t side, Int_t sector, Int_t patc
 //_____________________________________________________________________________
 Int_t AliTPCmapper::GetPatchFromEquipmentID(Int_t equipmentID) const
 {
-  // Get rcu (patch) index (0 ... 5) from equipment ID
+  /// Get rcu (patch) index (0 ... 5) from equipment ID
+
   Int_t retval = 0;
 
   if ( (equipmentID < fTpcDdlOffset) || (equipmentID > 983) ) {
@@ -881,7 +915,8 @@ Int_t AliTPCmapper::GetPatchFromEquipmentID(Int_t equipmentID) const
 //_____________________________________________________________________________
 Int_t AliTPCmapper::GetSideFromEquipmentID(Int_t equipmentID) const
 {
-  // Get side from Eq ID
+  /// Get side from Eq ID
+
   if ( equipmentID < fTpcDdlOffset ) {
     AliWarning(Form("Equipment ID (%d) outside range !", equipmentID));
     return -1;
@@ -900,7 +935,8 @@ Int_t AliTPCmapper::GetSideFromEquipmentID(Int_t equipmentID) const
 //_____________________________________________________________________________
 Int_t AliTPCmapper::GetSectorFromEquipmentID(Int_t equipmentID) const
 {
-  // Get sector index (0 ... 17) from equipment ID
+  /// Get sector index (0 ... 17) from equipment ID
+
   Int_t retval = 0;
   if ( (equipmentID < fTpcDdlOffset) || (equipmentID >= fTpcDdlOffset+216) ) {
     AliWarning(Form("Equipment ID (%d) outside range !", equipmentID));
@@ -923,7 +959,8 @@ Int_t AliTPCmapper::GetSectorFromEquipmentID(Int_t equipmentID) const
 //_____________________________________________________________________________
 Int_t AliTPCmapper::GetRocFromEquipmentID(Int_t equipmentID) const
 {
-  // Get ROC index (0 ... 71) from equipment ID
+  /// Get ROC index (0 ... 71) from equipment ID
+
   Int_t side   = GetSideFromEquipmentID(equipmentID);
   if ( side < 0 ) return -1;
   Int_t sector = GetSectorFromEquipmentID(equipmentID);
@@ -938,7 +975,7 @@ Int_t AliTPCmapper::GetRocFromEquipmentID(Int_t equipmentID) const
 //_____________________________________________________________________________
 Int_t AliTPCmapper::GetSectorFromRoc(Int_t roc) const
 {
-  // get the sector number (0 ... 17) from the roc number (0 ... 71)
+  /// get the sector number (0 ... 17) from the roc number (0 ... 71)
 
   if ( roc < 0 ) {
     AliWarning(Form("Roc outside range (roc %d) !", roc));
@@ -961,7 +998,7 @@ Int_t AliTPCmapper::GetSectorFromRoc(Int_t roc) const
 //_____________________________________________________________________________
 Int_t AliTPCmapper::GetSideFromRoc(Int_t roc) const
 {
-  // get the side (0, 1) from the roc number (0 ... 71)
+  /// get the side (0, 1) from the roc number (0 ... 71)
 
   if ( roc < 0 ) {
     AliWarning(Form("Roc outside range (roc %d) !", roc));
@@ -974,17 +1011,17 @@ Int_t AliTPCmapper::GetSideFromRoc(Int_t roc) const
     return 0;
   } else if ( roc < 72 ) {   // outer sector, C side
     return 1;
-  } else { 
+  } else {
     AliWarning(Form("Roc outside range (roc %d) !", roc));
     return -1;
-  } 
+  }
 }
 
 
 //_____________________________________________________________________________
 Int_t AliTPCmapper::GetRocFromPatch(Int_t side, Int_t sector, Int_t patch) const
 {
-  // Get Roc (0 ... 71) from side (0, 1), sector (0 ... 17) and patch (0 ... 5)
+  /// Get Roc (0 ... 71) from side (0, 1), sector (0 ... 17) and patch (0 ... 5)
 
   if ( (side < 0) || (side >= fNside) ) {
     AliWarning(Form("Side outside range (side %d) !", side));
@@ -1012,7 +1049,7 @@ Int_t AliTPCmapper::GetRocFromPatch(Int_t side, Int_t sector, Int_t patch) const
 //_____________________________________________________________________________
 Int_t AliTPCmapper::GetRoc(Int_t side, Int_t sector, Int_t globalpadrow, Int_t pad) const
 {
-  // Get Roc (0 ... 71) from side (0, 1), sector (0 ... 17) and pad coordinates
+  /// Get Roc (0 ... 71) from side (0, 1), sector (0 ... 17) and pad coordinates
 
   Int_t patch = GetPatchSector(globalpadrow, pad);
   if ( patch < 0 ) return -1;
@@ -1023,7 +1060,8 @@ Int_t AliTPCmapper::GetRoc(Int_t side, Int_t sector, Int_t globalpadrow, Int_t p
 //_____________________________________________________________________________
   Bool_t AliTPCmapper::IsIROC(Int_t roc) const
 {
-  // Is this ROC an IROC?
+  /// Is this ROC an IROC?
+
   if ( roc < 0 ) {
     AliWarning(Form("Roc outside range (roc %d) !", roc));
     return -1;
@@ -1041,7 +1079,8 @@ Int_t AliTPCmapper::GetRoc(Int_t side, Int_t sector, Int_t globalpadrow, Int_t p
 //_____________________________________________________________________________
   Bool_t AliTPCmapper::IsOROC(Int_t roc) const
 {
-  // Is this ROC an OROC?
+  /// Is this ROC an OROC?
+
   if ( roc < 0 ) {
     AliWarning(Form("Roc outside range (roc %d) !", roc));
     return -1;
diff --git a/TPC/TPCbase/AliTPCmapper.h b/TPC/TPCbase/AliTPCmapper.h
index e14e4f2f446..06619a699d4 100644
--- a/TPC/TPCbase/AliTPCmapper.h
+++ b/TPC/TPCbase/AliTPCmapper.h
@@ -3,13 +3,10 @@
 /* Copyright(c) 1998-2006, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-////////////////////////////////////////////////////////////////////////
-//
-// AliTPCmapper class
-// Class for all mapping functions (hardware coordinates <-> pad coordinates)
-// Author: Christian Lippmann
-//       
-/////////////////////////////////////////////////////////////////////////
+/// \class AliTPCmapper
+/// \brief Class for all mapping functions (hardware coordinates <-> pad coordinates)
+///
+/// \author Christian Lippmann
 
 #include <TObject.h>
 
@@ -101,27 +98,29 @@ public:
   Int_t  GetNfec(Int_t patch) const;
   Bool_t IsIROC(Int_t roc) const;
   Bool_t IsOROC(Int_t roc) const;
-  
+
   Int_t  GetTpcDdlOffset() const {return fTpcDdlOffset;}
   Int_t  GetNumDdl() const {return fNside*fNsector*fNrcu; }
 
  private:
 
-  Int_t fNside;        // TPC has 2 sides
-  Int_t fNsector;      // TPC side has 18 sectors
-  Int_t fNrcu;         // Sector has 6 RCUs (patches)
-  Int_t fNbranch;      // RCU has 2 branches
-  Int_t fNaltro;       // FEC has 8 ALTROs
-  Int_t fNchannel;     // ALTRO has 16 channels
-  Int_t fNpadrow;      // Sector has 159 padrows
-  Int_t fNpadrowIROC;  // IROC has 63 padrows
-  Int_t fNpadrowOROC;  // OROC has 96 padrows
+  Int_t fNside;        ///< TPC has 2 sides
+  Int_t fNsector;      ///< TPC side has 18 sectors
+  Int_t fNrcu;         ///< Sector has 6 RCUs (patches)
+  Int_t fNbranch;      ///< RCU has 2 branches
+  Int_t fNaltro;       ///< FEC has 8 ALTROs
+  Int_t fNchannel;     ///< ALTRO has 16 channels
+  Int_t fNpadrow;      ///< Sector has 159 padrows
+  Int_t fNpadrowIROC;  ///< IROC has 63 padrows
+  Int_t fNpadrowOROC;  ///< OROC has 96 padrows
 
-  Int_t fTpcDdlOffset; // DDL offset for TPC
+  Int_t fTpcDdlOffset; ///< DDL offset for TPC
 
-  AliTPCAltroMapping *fMapping[6];    // The ALTRO mapping for each patch (rcu)
+  AliTPCAltroMapping *fMapping[6];    ///< The ALTRO mapping for each patch (rcu)
 
+  /// \cond CLASSIMP
   ClassDef(AliTPCmapper,2)
+  /// \endcond
 
 };
 
diff --git a/TPC/TPCbase/AliTransform.cxx b/TPC/TPCbase/AliTransform.cxx
index 24bf2b2b4e8..d2f8e3960f0 100644
--- a/TPC/TPCbase/AliTransform.cxx
+++ b/TPC/TPCbase/AliTransform.cxx
@@ -1,4 +1,7 @@
-#include "AliTransform.h"
+/// \class AliTransform
 
+#include "AliTransform.h"
+/// \cond CLASSIMP
 ClassImp(AliTransform)
+/// \endcond
 
diff --git a/TPC/TPCbase/AliTransform.h b/TPC/TPCbase/AliTransform.h
index e075d1cabdd..92a35230c09 100644
--- a/TPC/TPCbase/AliTransform.h
+++ b/TPC/TPCbase/AliTransform.h
@@ -1,3 +1,5 @@
+/// \class AliTransform
+
 #ifndef ALI_TRANSFORM_H
 #define ALI_TRANSFORM_H
 
@@ -9,7 +11,9 @@ public:
   virtual void Transform(Double_t *x,Int_t *i,UInt_t time,
 			 Int_t coordinateType)=0;
 
+  /// \cond CLASSIMP
   ClassDef(AliTransform,0)
+  /// \endcond
 };
 
 #endif
diff --git a/TPC/TPCbase/AliXRDPROOFtoolkit.cxx b/TPC/TPCbase/AliXRDPROOFtoolkit.cxx
index dde16b5b74c..d45885a990d 100644
--- a/TPC/TPCbase/AliXRDPROOFtoolkit.cxx
+++ b/TPC/TPCbase/AliXRDPROOFtoolkit.cxx
@@ -13,24 +13,28 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/*
-  marian.ivanov@cern.ch
-  
-  //TOOLKIT for chain manipulation:  
-  //Example usage:
-  //
-  // 1. Check the list of files
-  AliXRDPROOFtoolkit toolkit;
-  AliXRDPROOFtoolkit::FilterList("pp.txt","AliESDs.root esdTree AliESDfriends.root * Kinematics.root *",0)
-  AliXRDPROOFtoolkit::FilterList("pp.txt","AliESDs.root esdTree AliESDfriends.root * Kinematics.root *",1)
-  //
-  //2. make a chain or random chain form the list of files
-  TChain * chain = toolkit.MakeChain("esd.txt","esdTree",0,10)
-  TChain * chainRandom = toolkit.MakeChainrandom("esd.txt","esdTree",0,10)
-  chain->Draw("fTPCnclsF");
-  
+/// \class AliXRDPROOFtoolkit
+/// \brief TOOLKIT for chain manipulation:
+///
+/// Example usage:
+///
+/// 1. Check the list of files
+///
+/// ~~~{.cxx}
+/// AliXRDPROOFtoolkit toolkit;
+/// AliXRDPROOFtoolkit::FilterList("pp.txt","AliESDs.root esdTree AliESDfriends.root * Kinematics.root *",0)
+/// AliXRDPROOFtoolkit::FilterList("pp.txt","AliESDs.root esdTree AliESDfriends.root * Kinematics.root *",1)
+/// ~~~
+///
+/// ~~~{.cxx}
+/// 2. make a chain or random chain form the list of files
+/// TChain * chain = toolkit.MakeChain("esd.txt","esdTree",0,10)
+/// TChain * chainRandom = toolkit.MakeChainrandom("esd.txt","esdTree",0,10)
+/// chain->Draw("fTPCnclsF");
+/// ~~~
+///
+/// \author Marian Ivanov
 
-*/
 #include <TTree.h>
 #include <TEnv.h>
 #include <TString.h>
@@ -51,22 +55,24 @@
 #include <AliXRDPROOFtoolkit.h>
 
 
+/// \cond CLASSIMP
 ClassImp(AliXRDPROOFtoolkit)
+/// \endcond
 
 
 
 //______________________________________________________________________________
-  AliXRDPROOFtoolkit::AliXRDPROOFtoolkit () : 
+  AliXRDPROOFtoolkit::AliXRDPROOFtoolkit () :
     TObject () ,
-    fVerbose(kFALSE),          // verbso mode  - print command 
+    fVerbose(kFALSE),          // verbso mode  - print command
     fUserName(""),         // user name
     fUserGroup(0)        // user group info
 {
   //
-  // 
+  //
   //
   fUserGroup = gSystem->GetUserInfo();
-  fUserName  = fUserGroup->fUser;       
+  fUserName  = fUserGroup->fUser;
   fVerbose=1;
 }
 
@@ -76,17 +82,16 @@ ClassImp(AliXRDPROOFtoolkit)
 
 TChain* AliXRDPROOFtoolkit::MakeChain(const char*fileIn, const char * treeName, const char *fName, Int_t maxFiles, Int_t startFile)
 {
-  //
-  // Create a chain of files using the file 'fileIn' as input list 
-  // where one line per root file is expected
-  //
-  // treeName : Name of the tree
-  // fName    : file name inside of a zip file, will add '#fName'
-  //            to the file name
-  // maxFiles : maximum number of files in the chain
-  //            -1 (default) add all possible files starting from 'startFile'
-  // startFile: position of the first file, starting with 0
-  //
+  /// Create a chain of files using the file 'fileIn' as input list
+  /// where one line per root file is expected
+  ///
+  /// treeName : Name of the tree
+  /// fName    : file name inside of a zip file, will add '#fName'
+  /// to the file name
+  /// maxFiles : maximum number of files in the chain
+  /// -1 (default) add all possible files starting from 'startFile'
+  /// startFile: position of the first file, starting with 0
+
   TChain* chain = new TChain(treeName);
 
   // Open the input stream
@@ -104,7 +109,7 @@ TChain* AliXRDPROOFtoolkit::MakeChain(const char*fileIn, const char * treeName,
     }
     if (!currentFile.Contains("root")) continue; // protection
     ++counter;
-    if (counter<=startFile) continue; 
+    if (counter<=startFile) continue;
     if ((maxFiles>0) && (counter>maxFiles+startFile)) break;
 
     TFile * f = TFile::Open(currentFile.Data());
@@ -122,15 +127,14 @@ TChain* AliXRDPROOFtoolkit::MakeChain(const char*fileIn, const char * treeName,
 
 TChain* AliXRDPROOFtoolkit::MakeChainRandom(const char*fileIn, const char * treeName,const char *fName, Int_t maxFiles, Int_t startFile)
 {
-  //
-  // Create a TDSet - files are in random order
-  //
-  // filein    - input list text file
-  // treename  - containg tree 
-  // maxFiles  - maximum number of files included
+  /// Create a TDSet - files are in random order
+  ///
+  /// filein    - input list text file
+  /// treename  - containg tree
+  /// maxFiles  - maximum number of files included
 
   TObjArray array(10000);
-  
+
   TChain* chain = new TChain(treeName);
 
   // Open the input stream
@@ -160,11 +164,11 @@ TChain* AliXRDPROOFtoolkit::MakeChainRandom(const char*fileIn, const char * tree
   Double_t *randomI = new Double_t[entries];
   Int_t *indexes = new Int_t[entries];
   for (Int_t i=0;i<entries; i++) randomI[i]=gRandom->Rndm();
-  TMath::Sort(entries,randomI,indexes); 
-  
+  TMath::Sort(entries,randomI,indexes);
+
   for (Int_t i=startFile; (i<startFile+maxFiles) && (i<entries); i++){
     Int_t ifile = indexes[i];
-    if (ifile<entries && (array.At(ifile)) &&  array.At(ifile)->TestBit(TObject::kCannotPick)==kFALSE){ 
+    if (ifile<entries && (array.At(ifile)) &&  array.At(ifile)->TestBit(TObject::kCannotPick)==kFALSE){
       printf("%d\t%d\t%s\n",i, ifile, array.At(ifile)->GetName());
       chain->Add(array.At(ifile)->GetName());
       array.At(ifile)->SetBit(TObject::kCannotPick);
@@ -177,11 +181,10 @@ TChain* AliXRDPROOFtoolkit::MakeChainRandom(const char*fileIn, const char * tree
 
 TDSet* AliXRDPROOFtoolkit::MakeSet(const char*fileIn, const char * treeName, const char *fName, Int_t maxFiles)
 {
-  //
-  // Create the TDSet out of list
-  // filein    - input list text file
-  // treename  - containg tree 
-  // maxFiles  - maximum number of files included
+  /// Create the TDSet out of list
+  /// filein    - input list text file
+  /// treename  - containg tree
+  /// maxFiles  - maximum number of files included
 
   TDSet* chain = new TDSet(treeName);
 
@@ -212,15 +215,14 @@ TDSet* AliXRDPROOFtoolkit::MakeSet(const char*fileIn, const char * treeName, con
 
 TDSet* AliXRDPROOFtoolkit::MakeSetRandom(const char*fileIn, const char * treeName, const char *fName, Int_t maxFiles)
 {
-  //
-  // Create a TDSet - files are in random order
-  //
-  // filein    - input list text file
-  // treename  - containg tree 
-  // maxFiles  - maximum number of files included
+  /// Create a TDSet - files are in random order
+  ///
+  /// filein    - input list text file
+  /// treename  - containg tree
+  /// maxFiles  - maximum number of files included
 
   TObjArray array(10000);
-  
+
   TDSet* chain = new TDSet(treeName);
 
   // Open the input stream
@@ -248,7 +250,7 @@ TDSet* AliXRDPROOFtoolkit::MakeSetRandom(const char*fileIn, const char * treeNam
   if (maxFiles>entries) maxFiles=entries;
   for (Int_t i=0; i<maxFiles; i++){
     Int_t ifile = TMath::Nint(gRandom->Rndm()*Float_t(entries));
-    if (ifile<entries && (array.At(ifile)) &&  array.At(ifile)->TestBit(TObject::kCannotPick)==kFALSE){ 
+    if (ifile<entries && (array.At(ifile)) &&  array.At(ifile)->TestBit(TObject::kCannotPick)==kFALSE){
       printf("%d\t%d\t%s\n",i, ifile, array.At(ifile)->GetName());
       chain->Add(array.At(ifile)->GetName());
       array.At(ifile)->SetBit(TObject::kCannotPick);
@@ -267,18 +269,18 @@ TDSet* AliXRDPROOFtoolkit::MakeSetRandom(const char*fileIn, const char * treeNam
 
 
 Int_t  AliXRDPROOFtoolkit::CheckTreeInFile(const char*fileName,const char*treeName, Int_t debugLevel, const char *branchName){
-  //
-  // Check the tree in file 
-  // fileName   - the name of the file with tree
-  // treeName   - the name of file
-  // debugLevel - 0 check the existance of the file -  1 make loop over entries
-  // branchName - if debugLevel>0 the branch is chcecked
-  //              if brnachName =0 the content of full tree is chcecked
-  // return value = 0 - Check things  OK
-  //               -1 - file not exist or not accesible
-  //               -2 - file is zombie
-  //		   -3 - tree not present
-  //               -4 - branch not present
+  /// Check the tree in file
+  /// fileName   - the name of the file with tree
+  /// treeName   - the name of file
+  /// debugLevel - 0 check the existance of the file -  1 make loop over entries
+  /// branchName - if debugLevel>0 the branch is chcecked
+  /// if brnachName =0 the content of full tree is chcecked
+  /// return value = 0 - Check things  OK
+  /// -1 - file not exist or not accesible
+  /// -2 - file is zombie
+  /// 		   -3 - tree not present
+  /// -4 - branch not present
+
   TFile * file = TFile::Open(fileName);
   if (!file) { return -1;}
   if (file->IsZombie()) {file->Close(); delete file; return -2;};
@@ -286,7 +288,7 @@ Int_t  AliXRDPROOFtoolkit::CheckTreeInFile(const char*fileName,const char*treeNa
   TString TrName(treeName);
   if (TrName=="*") {
     //cout <<"        treename ==== *"<<endl;;
-    file->Close(); delete file; 
+    file->Close(); delete file;
     return 0;
   }
   TTree * tree = (TTree*)file->Get(treeName);
@@ -297,7 +299,7 @@ Int_t  AliXRDPROOFtoolkit::CheckTreeInFile(const char*fileName,const char*treeNa
     if (!branch) {file->Close(); delete file; return -4;}
   }
   //
-  if (debugLevel==1 &&  tree->GetEntries()==0 ) return 1; //empty 
+  if (debugLevel==1 &&  tree->GetEntries()==0 ) return 1; //empty
 
   tree->SetBranchStatus("*",1);
   try {
@@ -305,11 +307,11 @@ Int_t  AliXRDPROOFtoolkit::CheckTreeInFile(const char*fileName,const char*treeNa
       Int_t entries = tree->GetEntries();
       for (Int_t i=0;i<entries; i++){
 	if (branch) branch->GetEntry(i);
-	else tree->GetEntry();      
+	else tree->GetEntry();
       }
     }
   }catch ( ... ) {
-    printf("PROBLEM\n");  
+    printf("PROBLEM\n");
     // never catched  - as there is no exception in the ROOT IO
     file->Close(); delete file;
     return 1 ;
@@ -321,22 +323,22 @@ Int_t  AliXRDPROOFtoolkit::CheckTreeInFile(const char*fileName,const char*treeNa
 
 
 Bool_t  AliXRDPROOFtoolkit::FilterList(const char*inputList, const char*fileList, Int_t checkLevel){
-  //
-  // Filter the list  
-  // inputList - list of original file names
-  // fileList  - list of file to be checked
-  //           - 0 - fileName
-  //           - 1 - treeName (if * not checked)
-  //           - 2 - fileName 
-  //                 ....
-  // checkLevel - 0 - check only existance of the files and tree's + 
-  //                  simple file corruption
-  //            > 1 - check the content of the tree - 
-  //                  (can crash as there do not exest exception handling in ROOT)
-  // Output -  two streams are created - file with good entries
-  // "%s.Good a,d file with bad entries %s.Bad
-  //EXAMPLE:
-  // AliXRDPROOFtoolkit::FilterList("ppgrid2.txt","AliESDs.root esdTree AliESDfriends.root * Kinematics.root *",1) 
+  /// Filter the list
+  /// inputList - list of original file names
+  /// fileList  - list of file to be checked
+  /// - 0 - fileName
+  /// - 1 - treeName (if * not checked)
+  /// - 2 - fileName
+  /// ....
+  /// checkLevel - 0 - check only existance of the files and tree's +
+  /// simple file corruption
+  /// > 1 - check the content of the tree -
+  /// (can crash as there do not exest exception handling in ROOT)
+  /// Output -  two streams are created - file with good entries
+  /// "%s.Good a,d file with bad entries %s.Bad
+  /// EXAMPLE:
+  /// AliXRDPROOFtoolkit::FilterList("ppgrid2.txt","AliESDs.root esdTree AliESDfriends.root * Kinematics.root *",1)
+
   gEnv->SetValue("TFile.Recover", 0);
   //
   fstream finput;
@@ -388,7 +390,7 @@ Bool_t  AliXRDPROOFtoolkit::FilterList(const char*inputList, const char*fileList
       Int_t cstatus = CheckTreeInFile(fname, array->At(i+1)->GetName(), checkLevel,0);
       //printf("  CheckTreeInFile returns %d",cstatus);
       if (cstatus!=0) {
-	status = cstatus; 
+	status = cstatus;
 	break;
       }
     }
@@ -397,7 +399,7 @@ Bool_t  AliXRDPROOFtoolkit::FilterList(const char*inputList, const char*fileList
     }else{
       focBad<<currentFile<<endl;
     }
-    counter++;    
+    counter++;
   }
   finput.close();
   delete array;
@@ -406,22 +408,21 @@ Bool_t  AliXRDPROOFtoolkit::FilterList(const char*inputList, const char*fileList
 
 
 Bool_t  AliXRDPROOFtoolkit::FilterListZip(const char*inputList, const char*fileList, Int_t checkLevel){
-  //
-  // Filter the list  
-  // inputList - list of original file names
-  // fileList  - list of file to be checked
-  //           - 0 - fileName
-  //           - 1 - treeName (if * not checked)
-  //           - 2 - fileName 
-  //                 ....
-  // checkLevel - 0 - check only existance of the files and tree's + 
-  //                  simple file corruption
-  //            > 1 - check the content of the tree - 
-  //                  (can crash as there do not exest exception handling in ROOT)
-  // Output -  two streams are created - file with good entries
-  // "%s.Good a,d file with bad entries %s.Bad
-  //EXAMPLE:
-  // AliXRDPROOFtoolkit::FilterList("ppgrid2.txt","AliESDs.root esdTree AliESDfriends.root * Kinematics.root *",1) 
+  /// Filter the list
+  /// inputList - list of original file names
+  /// fileList  - list of file to be checked
+  /// - 0 - fileName
+  /// - 1 - treeName (if * not checked)
+  /// - 2 - fileName
+  /// ....
+  /// checkLevel - 0 - check only existance of the files and tree's +
+  /// simple file corruption
+  /// > 1 - check the content of the tree -
+  /// (can crash as there do not exest exception handling in ROOT)
+  /// Output -  two streams are created - file with good entries
+  /// "%s.Good a,d file with bad entries %s.Bad
+  /// EXAMPLE:
+  /// AliXRDPROOFtoolkit::FilterList("ppgrid2.txt","AliESDs.root esdTree AliESDfriends.root * Kinematics.root *",1)
 
   fstream finput;
   finput.open(inputList, ios_base::in);
@@ -462,7 +463,7 @@ Bool_t  AliXRDPROOFtoolkit::FilterListZip(const char*inputList, const char*fileL
       Int_t cstatus = CheckTreeInFile(fname, array->At(i+1)->GetName(), checkLevel,0);
       //printf("  CheckTreeInFile returns %d",cstatus);
       if (cstatus!=0) {
-	status = cstatus; 
+	status = cstatus;
 	break;
       }
     }
@@ -471,7 +472,7 @@ Bool_t  AliXRDPROOFtoolkit::FilterListZip(const char*inputList, const char*fileL
     }else{
       focBad<<currentFile<<endl;
     }
-    counter++;    
+    counter++;
   }
   finput.close();
   return kTRUE;
@@ -482,19 +483,19 @@ Bool_t  AliXRDPROOFtoolkit::FilterListZip(const char*inputList, const char*fileL
 
 
 Bool_t  AliXRDPROOFtoolkit::XRDCopyDir(const char * idir, const char * files, const char *odir, Bool_t /*zip*/){
-  //
-  // idir  - input directory
-  // odir  - output directory
-  // files - the list of files to be coppied
-  // zip   - not supported yet
-  //
-  // Example :									
-  //
-  // idir ="root://gsiaf.gsi.de:1094//sma/sim/v4-05-Rev-03/pp/0000";
-  // odir ="root://lxgrid2.gsi.de:1094//miranov/test/pp/0000"; 
-  // char *files="AliESDs.root AliESDfriend.root Kinematics.root";
+  /// idir  - input directory
+  /// odir  - output directory
+  /// files - the list of files to be coppied
+  /// zip   - not supported yet
+  ///
+  /// Example :
+  ///
+  /// idir ="root://gsiaf.gsi.de:1094//sma/sim/v4-05-Rev-03/pp/0000";
+  /// odir ="root://lxgrid2.gsi.de:1094//miranov/test/pp/0000";
+  /// char *files="AliESDs.root AliESDfriend.root Kinematics.root";
+
   TString str(files);
-  TObjArray * array = str.Tokenize(" "); 
+  TObjArray * array = str.Tokenize(" ");
   Int_t nfiles = array->GetEntries();
   char infile[1000];
   char outfile[1000];
@@ -503,7 +504,7 @@ Bool_t  AliXRDPROOFtoolkit::XRDCopyDir(const char * idir, const char * files, co
     snprintf(infile,1000,"%s/%s", idir, array->At(ifile)->GetName());
     snprintf(outfile,1000,"%s/%s", odir, array->At(ifile)->GetName());
     printf("%s - %s\n",infile, outfile);
-    Bool_t result = TFile::Cp(infile,outfile); 
+    Bool_t result = TFile::Cp(infile,outfile);
     succes &= result;
   }
   delete array;
@@ -513,50 +514,51 @@ Bool_t  AliXRDPROOFtoolkit::XRDCopyDir(const char * idir, const char * files, co
 
 
 void AliXRDPROOFtoolkit::JoinTreesIndex(const char * outputFile, const char * outputTree, const char *indexName, const char *inputTrees, Int_t debugLevel){
-  //
-  // Join together several tree according to the index
-  // 
-  // Parameters:
-  // Output:
-  //     outputFile : name of the output file
-  //     outputTree : name of the output Tree
-  //     indexName  : name of the branch to be used as an index
-  // Input:
-  //     inputTrees : decription of the input trees setup
-  /*
-    Example usage:
-    
-    AliXRDPROOFtoolkit::JoinTreesIndex("outAll.root","joinAll","run","1#CPass1#run#tpcQA#TPCCPass1.root+1#VPass1#run#tpcQA#TPCVPass1.root+1#Pass1#run#tpcQA#TPCPass1.root+0#DAQ#run#joinTree#fproductionJoin.root+0#C#run#dcs#OCDBscan.root+0#CE#run#Fits#CEtrend.root");
-    ==>
-    Combine information form the Cpass1,VPass, and Pass1QA, calibration tree, DAQ information, trigger information 
-    Make a File "outAll.root",  with tree "joinAll", index of tree with name "run"
-    //
-    // Input tree configuration string:
-    //
-    const char *inputTrees="1#CPass1#run#tpcQA#TPCCPass1.root+1#VPass1#run#tpcQA#TPCVPass1.root+1#Pass1#run#tpcQA#TPCPass1.root+0#DAQ#run#joinTree#/home/miranov/test/dbQueries/fproductionJoin.root+0#C#run#dcs#OCDBscan.root+0#CE#run#Fits#CEtrend.root"
-    Describe 6 trees to be merged (string separated be +):
-      TObjArray *arrayInput = TString(inputTrees).Tokenize("+");
-      TObjString = 1#CPass1#run#tpcQA#TPCCPass1.root
-      TObjString = 1#VPass1#run#tpcQA#TPCVPass1.root
-      TObjString = 1#Pass1#run#tpcQA#TPCPass1.root
-      TObjString = 0#DAQ#run#joinTree#/home/miranov/test/dbQueries/fproductionJoin.root
-      TObjString = 0#C#run#dcs#OCDBscan.root
-      TObjString = 0#CE#run#Fits#CEtrend.root
-    //  
-    Each tree is characterize by 5 parameters - separate by #
-       description="1#CPass1#run#tpcQA#TPCCPass1.root"
-       TString(description)->Tokenize("#").Print()
-       Collection name='TObjArray', class='TObjArray', size=16
-       TObjString = 1                    ==> (0/1) index is used 
-       TObjString = CPass1               ==> name of output branch  in output tree
-       TObjString = run                  ==> name of the index
-       TObjString = tpcQA                ==> name of the input tree in the input file
-       TObjString = TPCCPass1.root       ==> name of the input file
-  */
-  //
-  //
-  //
-                
+  /// Join together several tree according to the index
+  ///
+  /// Parameters:
+  ///
+  /// Output:
+  ///   - outputFile : name of the output file
+  ///   - outputTree : name of the output Tree
+  ///   - indexName  : name of the branch to be used as an index
+  ///
+  /// Input:
+  ///    - inputTrees : decription of the input trees setup
+  ///
+  /// Example usage:
+  ///
+  /// ~~~{.cxx}
+  /// AliXRDPROOFtoolkit::JoinTreesIndex("outAll.root","joinAll","run","1#CPass1#run#tpcQA#TPCCPass1.root+1#VPass1#run#tpcQA#TPCVPass1.root+1#Pass1#run#tpcQA#TPCPass1.root+0#DAQ#run#joinTree#fproductionJoin.root+0#C#run#dcs#OCDBscan.root+0#CE#run#Fits#CEtrend.root");
+  /// ~~~
+  /// Combine information form the Cpass1,VPass, and Pass1QA, calibration tree, DAQ information, trigger information
+  /// Make a File "outAll.root",  with tree "joinAll", index of tree with name "run"
+  ///
+  /// ~~~{.cxx}
+  /// //
+  /// // Input tree configuration string:
+  /// //
+  /// const char *inputTrees="1#CPass1#run#tpcQA#TPCCPass1.root+1#VPass1#run#tpcQA#TPCVPass1.root+1#Pass1#run#tpcQA#TPCPass1.root+0#DAQ#run#joinTree#/home/miranov/test/dbQueries/fproductionJoin.root+0#C#run#dcs#OCDBscan.root+0#CE#run#Fits#CEtrend.root"
+  /// // Describe 6 trees to be merged (string separated be +):
+  ///   TObjArray *arrayInput = TString(inputTrees).Tokenize("+");
+  ///   TObjString = 1#CPass1#run#tpcQA#TPCCPass1.root
+  ///   TObjString = 1#VPass1#run#tpcQA#TPCVPass1.root
+  ///   TObjString = 1#Pass1#run#tpcQA#TPCPass1.root
+  ///   TObjString = 0#DAQ#run#joinTree#/home/miranov/test/dbQueries/fproductionJoin.root
+  ///   TObjString = 0#C#run#dcs#OCDBscan.root
+  ///   TObjString = 0#CE#run#Fits#CEtrend.root
+  ///
+  /// // Each tree is characterize by 5 parameters - separate by #
+  ///    description="1#CPass1#run#tpcQA#TPCCPass1.root"
+  ///    TString(description)->Tokenize("#").Print()
+  ///    Collection name='TObjArray', class='TObjArray', size=16
+  ///    TObjString = 1                    ==> (0/1) index is used
+  ///    TObjString = CPass1               ==> name of output branch  in output tree
+  ///    TObjString = run                  ==> name of the index
+  ///    TObjString = tpcQA                ==> name of the input tree in the input file
+  ///    TObjString = TPCCPass1.root       ==> name of the input file
+  /// ~~~
+
   TFile * fout = new TFile(outputFile,"recreate");
   fout->cd();
   TTree *joinTree=new TTree(outputTree,outputTree);
@@ -566,10 +568,10 @@ void AliXRDPROOFtoolkit::JoinTreesIndex(const char * outputFile, const char * ou
   TObjArray *arrayInput = TString(inputTrees).Tokenize("+");
   Int_t nTrees = arrayInput->GetEntries();
   TObjArray * arrayFile  = new TObjArray(nTrees);    // array of TFiles with trees
-  TObjArray * arrayTrees = new TObjArray(nTrees);    // array of trees 
+  TObjArray * arrayTrees = new TObjArray(nTrees);    // array of trees
   TObjArray * arrayNames = new TObjArray(nTrees);    // name of tree
   TObjArray * arrayRunID = new TObjArray(nTrees);    // name of tree
-  TArrayI arrayEnableTree(nTrees);  
+  TArrayI arrayEnableTree(nTrees);
   for (Int_t i=0; i<2; i++) printf("\n");
   printf("Joing query\n");
   arrayInput->Print();
@@ -595,15 +597,15 @@ void AliXRDPROOFtoolkit::JoinTreesIndex(const char * outputFile, const char * ou
 	return;
       }
       tree->SetCacheSize(400000000);
-      //    
+      //
       arrayTrees->AddAt(tree,itree);
       //
       arrayRunID->AddAt(new TObjString(description->At(2)->GetName()),itree);
       arrayNames->AddAt(new TObjString(description->At(1)->GetName()),itree);
-      arrayEnableTree[itree]=atoi(description->At(0)->GetName());    
+      arrayEnableTree[itree]=atoi(description->At(0)->GetName());
 
     }}
-  //  
+  //
   delete arrayInput;
   // 2. Make the run list
   //
@@ -616,7 +618,7 @@ void AliXRDPROOFtoolkit::JoinTreesIndex(const char * outputFile, const char * ou
       Int_t entries=tree->GetEntries();
       char query[2000];
       snprintf(query,2000,"%s:Entry$", arrayRunID->At(itree)->GetName());
-      entries = tree->Draw(query,"","goff");      
+      entries = tree->Draw(query,"","goff");
       for (Int_t ientry=0;ientry<entries; ientry++){
 	Int_t irun=Int_t(tree->GetV1()[ientry]);
 	//	Int_t entryNr=Int_t(tree->GetV2()[ientry]);
@@ -636,9 +638,9 @@ void AliXRDPROOFtoolkit::JoinTreesIndex(const char * outputFile, const char * ou
   char *brName = new char[10000];
   char *brTitle= new char[10000];
   //
-  
+
   {for (Int_t itree=0; itree<nTrees; itree++){
-      TTree * tree = (TTree*)arrayTrees->At(itree);      
+      TTree * tree = (TTree*)arrayTrees->At(itree);
       tree->GetEntry(1);
       TString treeName=arrayNames->At(itree)->GetName();
       if (treeName.Length()>0){
@@ -672,10 +674,10 @@ void AliXRDPROOFtoolkit::JoinTreesIndex(const char * outputFile, const char * ou
 	  TObject **addrClass =  new TObject *;
 	  (*addrClass)=0;
 	  printf("%s\t%s\n",br->GetName(), className.Data());
-	  br->SetAddress(addrClass);	  
-	  br->GetEntry(0);	  
-	  joinTree->Branch(brName,addrClass);	  	  
-	}	
+	  br->SetAddress(addrClass);
+	  br->GetEntry(0);
+	  joinTree->Branch(brName,addrClass);
+	}
       }
     }
   }
@@ -683,12 +685,12 @@ void AliXRDPROOFtoolkit::JoinTreesIndex(const char * outputFile, const char * ou
   //
   // 4. Fill the trees
   //
-  map<int, int>::iterator riter;   
+  map<int, int>::iterator riter;
   {for (riter=runMap.begin(); riter != runMap.end(); ++riter){
       printf("%d\t%d\t", riter->first, riter->second);
       jrun=riter->first;
       for (Int_t itree=0; itree<nTrees; itree++){
-	TTree * tree = (TTree*)arrayTrees->At(itree); 
+	TTree * tree = (TTree*)arrayTrees->At(itree);
 	Int_t entry= runMapTree[itree][jrun];
 	status[itree]=(entry>0)?1:0;
 	if (entry>=0) tree->GetEntry(entry);
@@ -707,23 +709,22 @@ void AliXRDPROOFtoolkit::JoinTreesIndex(const char * outputFile, const char * ou
 
 
 void AliXRDPROOFtoolkit::CacheFileList(const char * fileIn, const char* cachePrefix){
-  //
-  // cache the list of file locally, cache valeus are stored in the location
-  // specified by optional argumen prefix 
-  // 2 new files are created 
-  //       <fileIn>.cache    - file with the location of cahe files
-  //       <fileIn>.cacheLog - log file +list of files which can not be cached 
-  //      
+  /// cache the list of file locally, cache valeus are stored in the location
+  /// specified by optional argumen prefix
+  /// 2 new files are created
+  ///       <fileIn>.cache    - file with the location of cahe files
+  ///       <fileIn>.cacheLog - log file +list of files which can not be cached
+
   /*
     fileIn = "TPCCPass1.list";
     cachePrefix = "";
   */
   ifstream fin;
-  fin.open(fileIn);  
+  fin.open(fileIn);
   ofstream fout;
-  fout.open(Form("%s.cache",fileIn));  
+  fout.open(Form("%s.cache",fileIn));
   ofstream foutLog;
-  foutLog.open(Form("%s.cacheLog",fileIn));  
+  foutLog.open(Form("%s.cacheLog",fileIn));
   // Read the input list of files and add them to the chain
   TString currentFile;
   TString cacheFile;
@@ -755,27 +756,28 @@ void AliXRDPROOFtoolkit::CacheFileList(const char * fileIn, const char* cachePre
 
 
 void   AliXRDPROOFtoolkit::MakeTreeFromList(const char *fout, const char * treeOut, const char * treeIn, const char * flist, Bool_t debug){
-  //
-  // join trees from the list  and make a common tree - stored in the file 
-  // 
-  /*
-    Example:
-    const char * fout="TPCCpass1.root";
-    const char *treeOut="tpcQA"
-    const char *treeIn="tpcQA"
-    const char * flist="TPCCPass1.list"    
-  */
+  /// join trees from the list  and make a common tree - stored in the file
+  ///
+  /// Example:
+  ///
+  /// ~~~{.cxx}
+  /// const char * fout="TPCCpass1.root";
+  /// const char *treeOut="tpcQA"
+  /// const char *treeIn="tpcQA"
+  /// const char * flist="TPCCPass1.list"
+  /// ~~~
+
   if (debug>0){
     printf("MakeTreeFromList\n");
     printf("fout=%s\n",fout);
     printf("treeOut=%s\n",treeOut);
     printf("treeIn=%s\n",treeIn);
     printf("fileList=%s\n",flist);
-  } 
+  }
   ifstream fin;
-  fin.open(flist);  
+  fin.open(flist);
   ofstream foutLog;
-  foutLog.open(Form("%s.chainLog",flist));  
+  foutLog.open(Form("%s.chainLog",flist));
   // Read the input list of files and add them to the chain
   TString currentFile;
   Int_t counter=0;
@@ -793,7 +795,7 @@ void   AliXRDPROOFtoolkit::MakeTreeFromList(const char *fout, const char * treeO
       if (!tree) {
 	foutLog<<"Error opening tree\t"<<currentFile<<treeIn<<"\n";
 	cout<<"Error opening tree\t"<<currentFile<<treeIn<<"\n";
-	f->ls();	
+	f->ls();
 	continue;
       }
       if (tree->GetListOfBranches()==0){
@@ -806,7 +808,7 @@ void   AliXRDPROOFtoolkit::MakeTreeFromList(const char *fout, const char * treeO
       if ( nbranches!=nbranchesCurrent){
 	foutLog<<"Error  tree layout\t"<<currentFile<<"   \t"<<treeIn<<"  \t"<<nbranches<<"  \t"<<nbranchesCurrent<<"\n";
 	cout<<"Error tree layout\t"   <<currentFile<<"   \t"<<treeIn<<"  \t"<<nbranches<<"  \t"<<nbranchesCurrent<<"\n";
-      }     
+      }
       counter++;
     }
   }
@@ -827,6 +829,6 @@ void   AliXRDPROOFtoolkit::MakeTreeFromList(const char *fout, const char * treeO
   fileOut->cd();
   tree->Write(treeOut);
   delete tree;
-  fileOut->Close(); 
+  fileOut->Close();
   delete fileOut;
 }
diff --git a/TPC/TPCbase/AliXRDPROOFtoolkit.h b/TPC/TPCbase/AliXRDPROOFtoolkit.h
index 8cd4082176b..6dfae52dc8e 100644
--- a/TPC/TPCbase/AliXRDPROOFtoolkit.h
+++ b/TPC/TPCbase/AliXRDPROOFtoolkit.h
@@ -1,3 +1,5 @@
+/// \class AliXRDPROOFtoolkit
+
 #ifndef _AliXRDPROOFtoolkit
 #define _AliXRDPROOFtoolkit
 
@@ -27,17 +29,19 @@ class AliXRDPROOFtoolkit : public TObject
   TDSet  * MakeSetRandom(const char*fileIn, const char * treeName,const char *fName=0, Int_t maxFiles=-1);
   static Bool_t FilterList(const char*inputList, const char*fileList, Int_t checkLevel);
   static Bool_t FilterListZip(const char*inputList, const char*fileList, Int_t checkLevel);
-  Bool_t  XRDCopyDir(const char * idir, const char * files, const char *odir, Bool_t zip); 
+  Bool_t  XRDCopyDir(const char * idir, const char * files, const char *odir, Bool_t zip);
   static Int_t  CheckTreeInFile(const char*fileName,const char*treeName, Int_t debugLevel=0, const char *branchName=0);
   static void JoinTreesIndex(const char * outputFile, const char * outputTree, const char *indexName, const char *inputTrees, Int_t debugLevel);
   static void   MakeTreeFromList(const char *fout, const char * treeOut, const char * treeIn, const char * flist, Bool_t debug);
-  static void CacheFileList(const char * fileIn, const char* cachePrefix); 
+  static void CacheFileList(const char * fileIn, const char* cachePrefix);
  private:
-  Int_t         fVerbose;          // verbso mode  - print command 
-  TString       fUserName;         // user name
-  UserGroup_t  *fUserGroup;        // user group info
+  Int_t         fVerbose;          ///< verbso mode  - print command
+  TString       fUserName;         ///< user name
+  UserGroup_t  *fUserGroup;        ///< user group info
   AliXRDPROOFtoolkit(const AliXRDPROOFtoolkit&);
   AliXRDPROOFtoolkit&operator=(const AliXRDPROOFtoolkit&);
-  ClassDef(AliXRDPROOFtoolkit, 0); 
+  /// \cond CLASSIMP
+  ClassDef(AliXRDPROOFtoolkit, 0);
+  /// \endcond
 };
 #endif
diff --git a/TPC/TPCbase/imgdoc/AliTPCBoundaryVoltError_cxx_1511bb7.C b/TPC/TPCbase/imgdoc/AliTPCBoundaryVoltError_cxx_1511bb7.C
new file mode 100644
index 00000000000..09a093823f5
--- /dev/null
+++ b/TPC/TPCbase/imgdoc/AliTPCBoundaryVoltError_cxx_1511bb7.C
@@ -0,0 +1,17 @@
+/// \file AliTPCBoundaryVoltError_cxx_1511bb7.C
+
+   {
+   gROOT->SetStyle("Plain"); gStyle->SetPalette(1);
+   TCanvas *c2 = new TCanvas("cAliTPCBoundaryVoltError","cAliTPCBoundaryVoltError",500,300);
+   AliTPCBoundaryVoltError bve;
+   Float_t val = 40;// [Volt]; 40V corresponds to 1mm
+   /* IFC shift, CE follows, ROC follows by factor half */
+   Float_t boundA[8] = { val, val, val,0,0,0,0,val}; // voltages A-side
+   Float_t boundC[6] = {-val,-val,-val,0,0,0};       // voltages C-side
+   bve.SetBoundariesA(boundA);
+   bve.SetBoundariesC(boundC);
+   bve.SetOmegaTauT1T2(-0.32,1,1);
+   bve.SetROCDisplacement(kTRUE); // include the chamber offset in z when calculating the dz distortions
+   bve.CreateHistoDRinZR(0)->Draw("surf2");
+   return c2;
+   }
diff --git a/TPC/TPCbase/imgdoc/AliTPCBoundaryVoltError_cxx_1511bb7.png b/TPC/TPCbase/imgdoc/AliTPCBoundaryVoltError_cxx_1511bb7.png
new file mode 100644
index 00000000000..3bc776ad16a
Binary files /dev/null and b/TPC/TPCbase/imgdoc/AliTPCBoundaryVoltError_cxx_1511bb7.png differ
diff --git a/TPC/TPCbase/imgdoc/AliTPCCorrection_cxx_e4df765.C b/TPC/TPCbase/imgdoc/AliTPCCorrection_cxx_e4df765.C
new file mode 100644
index 00000000000..581480bb1c5
--- /dev/null
+++ b/TPC/TPCbase/imgdoc/AliTPCCorrection_cxx_e4df765.C
@@ -0,0 +1,16 @@
+   {
+   gROOT->SetStyle("Plain"); gStyle->SetPalette(1);
+   TCanvas *c2 = new TCanvas("cAliTPCCorrection","cAliTPCCorrection",700,1050);  c2->Divide(2,3);
+   AliTPCROCVoltError3D roc; // EXAMPLE PLOTS - SEE BELOW
+   roc.SetROCDataFileName("$ALICE_ROOT/TPC/Calib/maps/TPCROCdzSurvey.root");
+   roc.SetOmegaTauT1T2(0,1,1); // B=0
+   Float_t z0 = 1; // at +1 cm -> A side
+   c2->cd(1); roc.CreateHistoDRinXY(1.,300,300)->Draw("cont4z");
+   c2->cd(3);roc.CreateHistoDRPhiinXY(1.,300,300)->Draw("cont4z");
+   c2->cd(5);roc.CreateHistoDZinXY(1.,300,300)->Draw("cont4z");
+   Float_t phi0=0.5;
+   c2->cd(2);roc.CreateHistoDRinZR(phi0)->Draw("surf2");
+   c2->cd(4);roc.CreateHistoDRPhiinZR(phi0)->Draw("surf2");
+   c2->cd(6);roc.CreateHistoDZinZR(phi0)->Draw("surf2");
+   return c2;
+   }
diff --git a/TPC/TPCbase/imgdoc/AliTPCCorrection_cxx_e4df765.png b/TPC/TPCbase/imgdoc/AliTPCCorrection_cxx_e4df765.png
new file mode 100644
index 00000000000..3ff2c666f44
Binary files /dev/null and b/TPC/TPCbase/imgdoc/AliTPCCorrection_cxx_e4df765.png differ
diff --git a/TPC/TPCbase/imgdoc/AliTPCExBBShape_h_32a8c9f.C b/TPC/TPCbase/imgdoc/AliTPCExBBShape_h_32a8c9f.C
new file mode 100644
index 00000000000..d38f1de0a00
--- /dev/null
+++ b/TPC/TPCbase/imgdoc/AliTPCExBBShape_h_32a8c9f.C
@@ -0,0 +1,10 @@
+   {
+   gROOT->SetStyle("Plain"); gStyle->SetPalette(1);
+   TCanvas *c2 = new TCanvas("cAliTPCExBBShape","cAliTPCExBBShape",500,300);
+   AliTPCExBBShape exb;
+   AliMagF mag("mag","mag");        // 0.5 Tesla (solenoid)
+   exb.SetBField(&mag);             // use Bfield from AliMagF
+   exb.SetOmegaTauT1T2(-0.32,1.,1.); // values ideally from OCDB
+   exb.CreateHistoDRPhiinZR(0,100,100)->Draw("surf2");
+   return c2;
+   }
diff --git a/TPC/TPCbase/imgdoc/AliTPCExBBShape_h_32a8c9f.png b/TPC/TPCbase/imgdoc/AliTPCExBBShape_h_32a8c9f.png
new file mode 100644
index 00000000000..7cea4a81f8f
Binary files /dev/null and b/TPC/TPCbase/imgdoc/AliTPCExBBShape_h_32a8c9f.png differ
diff --git a/TPC/TPCbase/imgdoc/AliTPCExBTwist_h_76e03fd.C b/TPC/TPCbase/imgdoc/AliTPCExBTwist_h_76e03fd.C
new file mode 100644
index 00000000000..30f07d9991c
--- /dev/null
+++ b/TPC/TPCbase/imgdoc/AliTPCExBTwist_h_76e03fd.C
@@ -0,0 +1,10 @@
+   {
+   gROOT->SetStyle("Plain"); gStyle->SetPalette(1);
+   TCanvas *c2 = new TCanvas("cAliTPCExBTwist","cAliTPCExBTwist",500,300);
+   AliTPCExBTwist twist;
+   twist.SetXTwist(0.001);  // x angle in [rad]
+   twist.SetXTwist(0.0005); // y angle in [rad]
+   twist.SetOmegaTauT1T2(0.32,1,1);
+   twist.CreateHistoDRPhiinXY(1.)->Draw("surf2"); // A side
+   return c2;
+   }
diff --git a/TPC/TPCbase/imgdoc/AliTPCExBTwist_h_76e03fd.png b/TPC/TPCbase/imgdoc/AliTPCExBTwist_h_76e03fd.png
new file mode 100644
index 00000000000..cccd956d226
Binary files /dev/null and b/TPC/TPCbase/imgdoc/AliTPCExBTwist_h_76e03fd.png differ
diff --git a/TPC/TPCbase/imgdoc/AliTPCFCVoltError3D_cxx_ee7b060.C b/TPC/TPCbase/imgdoc/AliTPCFCVoltError3D_cxx_ee7b060.C
new file mode 100644
index 00000000000..fe873676a49
--- /dev/null
+++ b/TPC/TPCbase/imgdoc/AliTPCFCVoltError3D_cxx_ee7b060.C
@@ -0,0 +1,12 @@
+   {
+   gROOT->SetStyle("Plain"); gStyle->SetPalette(1);
+   TCanvas *c2 = new TCanvas("cAliTPCVoltError3D","cAliTPCVoltError3D",500,450);
+   AliTPCFCVoltError3D fc;
+   fc.SetOmegaTauT1T2(0,1,1);
+   fc.SetRotatedClipVoltA(0,40);
+   fc.SetRodVoltShiftA(3,40);
+   fc.SetCopperRodShiftA(7+18,40);
+   fc.SetRodVoltShiftA(15+18,40);
+   fc.CreateHistoDRPhiinXY(10)->Draw("cont4z");
+   return c2;
+   }
diff --git a/TPC/TPCbase/imgdoc/AliTPCFCVoltError3D_cxx_ee7b060.png b/TPC/TPCbase/imgdoc/AliTPCFCVoltError3D_cxx_ee7b060.png
new file mode 100644
index 00000000000..fc20b527691
Binary files /dev/null and b/TPC/TPCbase/imgdoc/AliTPCFCVoltError3D_cxx_ee7b060.png differ
diff --git a/TPC/TPCbase/imgdoc/AliTPCGGVoltError_h_359f7ec.C b/TPC/TPCbase/imgdoc/AliTPCGGVoltError_h_359f7ec.C
new file mode 100644
index 00000000000..bd005d986ca
--- /dev/null
+++ b/TPC/TPCbase/imgdoc/AliTPCGGVoltError_h_359f7ec.C
@@ -0,0 +1,10 @@
+   {
+   gROOT->SetStyle("Plain"); gStyle->SetPalette(1);
+   TCanvas *c2 = new TCanvas("cAliTPCGGVoltError","cAliTPCGGVoltError",500,300);
+   AliTPCGGVoltError gg;
+   gg.SetDeltaVGGA(-40); gg.SetDeltaVGGC(-40); // 40 Volt offset
+   gg.InitGGVoltErrorDistortion();
+   gg.SetOmegaTauT1T2(0,1,1); // B=0
+   gg.CreateHistoDRinZR(0)->Draw("surf2");
+   return c2;
+   }
diff --git a/TPC/TPCbase/imgdoc/AliTPCGGVoltError_h_359f7ec.png b/TPC/TPCbase/imgdoc/AliTPCGGVoltError_h_359f7ec.png
new file mode 100644
index 00000000000..01ce8369268
Binary files /dev/null and b/TPC/TPCbase/imgdoc/AliTPCGGVoltError_h_359f7ec.png differ
diff --git a/TPC/TPCbase/imgdoc/AliTPCROCVoltError3D_cxx_99b6733.C b/TPC/TPCbase/imgdoc/AliTPCROCVoltError3D_cxx_99b6733.C
new file mode 100644
index 00000000000..9535e1625f3
--- /dev/null
+++ b/TPC/TPCbase/imgdoc/AliTPCROCVoltError3D_cxx_99b6733.C
@@ -0,0 +1,11 @@
+   {
+   gROOT->SetStyle("Plain"); gStyle->SetPalette(1);
+   TCanvas *c2 = new TCanvas("cAliTPCROCVoltError3D","cAliTPCROCVoltError3D",500,400);
+   AliTPCROCVoltError3D roc;
+   roc.SetROCDataFileName("$ALICE_ROOT/TPC/TPCcalib/maps/TPCROCdzSurvey.root");
+   roc.SetElectronArrivalCorrection(kFALSE);  // Correction for electron arrival offset, IROC vs OROC
+   roc.SetROCDisplacement(kTRUE);   // include the chamber offset in z when calculating the dz
+   roc.SetOmegaTauT1T2(0,1,1); // B=0
+   roc.CreateHistoDZinXY(1.,300,300)->Draw("colz");
+   return c2;
+   }
diff --git a/TPC/TPCbase/imgdoc/AliTPCROCVoltError3D_cxx_99b6733.png b/TPC/TPCbase/imgdoc/AliTPCROCVoltError3D_cxx_99b6733.png
new file mode 100644
index 00000000000..849a51f2df8
Binary files /dev/null and b/TPC/TPCbase/imgdoc/AliTPCROCVoltError3D_cxx_99b6733.png differ
diff --git a/TPC/TPCbase/imgdoc/AliTPCSpaceCharge_cxx_82e9c78.C b/TPC/TPCbase/imgdoc/AliTPCSpaceCharge_cxx_82e9c78.C
new file mode 100644
index 00000000000..d72ead17a8b
--- /dev/null
+++ b/TPC/TPCbase/imgdoc/AliTPCSpaceCharge_cxx_82e9c78.C
@@ -0,0 +1,9 @@
+   {
+   gROOT->SetStyle("Plain"); gStyle->SetPalette(1);
+   TCanvas *c2 = new TCanvas("cAliTPCSpaceCharge","cAliTPCSpaceCharge",500,300);
+   AliTPCSpaceCharge sc;
+   sc.SetOmegaTauT1T2(-0.32,1,1); // B=0.5 Tesla
+   sc.SetCorrectionFactor(0.0015);
+   sc.CreateHistoDRinZR(0.)->Draw("surf2");
+   return c2;
+   }
diff --git a/TPC/TPCbase/imgdoc/AliTPCSpaceCharge_cxx_82e9c78.png b/TPC/TPCbase/imgdoc/AliTPCSpaceCharge_cxx_82e9c78.png
new file mode 100644
index 00000000000..f054c454cf0
Binary files /dev/null and b/TPC/TPCbase/imgdoc/AliTPCSpaceCharge_cxx_82e9c78.png differ