doxy: TPC/TPCbase converted
authordberzano <dario.berzano@cern.ch>
Thu, 5 Feb 2015 15:37:40 +0000 (16:37 +0100)
committerdberzano <dario.berzano@cern.ch>
Tue, 10 Feb 2015 15:40:30 +0000 (16:40 +0100)
158 files changed:
TPC/TPCbase/AliClusters.cxx
TPC/TPCbase/AliClusters.h
TPC/TPCbase/AliComplexCluster.cxx
TPC/TPCbase/AliComplexCluster.h
TPC/TPCbase/AliDetectorParam.cxx
TPC/TPCbase/AliDetectorParam.h
TPC/TPCbase/AliDigits.cxx
TPC/TPCbase/AliDigits.h
TPC/TPCbase/AliDigitsArray.cxx
TPC/TPCbase/AliDigitsArray.h
TPC/TPCbase/AliH2F.cxx
TPC/TPCbase/AliH2F.h
TPC/TPCbase/AliSegmentArray.cxx
TPC/TPCbase/AliSegmentArray.h
TPC/TPCbase/AliSegmentID.cxx
TPC/TPCbase/AliSegmentID.h
TPC/TPCbase/AliSimDigits.cxx
TPC/TPCbase/AliSimDigits.h
TPC/TPCbase/AliTPCAltroMapping.cxx
TPC/TPCbase/AliTPCAltroMapping.h
TPC/TPCbase/AliTPCBoundaryVoltError.cxx
TPC/TPCbase/AliTPCBoundaryVoltError.h
TPC/TPCbase/AliTPCCalPad.cxx
TPC/TPCbase/AliTPCCalPad.h
TPC/TPCbase/AliTPCCalROC.cxx
TPC/TPCbase/AliTPCCalROC.h
TPC/TPCbase/AliTPCCalibCE.cxx
TPC/TPCbase/AliTPCCalibCE.h
TPC/TPCbase/AliTPCCalibGlobalMisalignment.cxx
TPC/TPCbase/AliTPCCalibGlobalMisalignment.h
TPC/TPCbase/AliTPCCalibPedestal.cxx
TPC/TPCbase/AliTPCCalibPedestal.h
TPC/TPCbase/AliTPCCalibPulser.cxx
TPC/TPCbase/AliTPCCalibPulser.h
TPC/TPCbase/AliTPCCalibRaw.cxx
TPC/TPCbase/AliTPCCalibRaw.h
TPC/TPCbase/AliTPCCalibRawBase.cxx
TPC/TPCbase/AliTPCCalibRawBase.h
TPC/TPCbase/AliTPCCalibVdrift.cxx
TPC/TPCbase/AliTPCCalibVdrift.h
TPC/TPCbase/AliTPCCalibViewer.cxx
TPC/TPCbase/AliTPCCalibViewer.h
TPC/TPCbase/AliTPCCalibViewerGUI.cxx
TPC/TPCbase/AliTPCCalibViewerGUI.h
TPC/TPCbase/AliTPCCalibViewerGUItime.cxx
TPC/TPCbase/AliTPCCalibViewerGUItime.h
TPC/TPCbase/AliTPCClusterParam.cxx
TPC/TPCbase/AliTPCClusterParam.h
TPC/TPCbase/AliTPCClustersRow.cxx
TPC/TPCbase/AliTPCClustersRow.h
TPC/TPCbase/AliTPCComposedCorrection.cxx
TPC/TPCbase/AliTPCComposedCorrection.h
TPC/TPCbase/AliTPCConfigDA.cxx
TPC/TPCbase/AliTPCConfigDA.h
TPC/TPCbase/AliTPCConfigParser.cxx
TPC/TPCbase/AliTPCConfigParser.h
TPC/TPCbase/AliTPCCorrection.cxx
TPC/TPCbase/AliTPCCorrection.h
TPC/TPCbase/AliTPCCorrectionDrift.cxx
TPC/TPCbase/AliTPCCorrectionDrift.h
TPC/TPCbase/AliTPCCorrectionLookupTable.cxx
TPC/TPCbase/AliTPCCorrectionLookupTable.h
TPC/TPCbase/AliTPCDigitsArray.cxx
TPC/TPCbase/AliTPCDigitsArray.h
TPC/TPCbase/AliTPCExB.cxx
TPC/TPCbase/AliTPCExB.h
TPC/TPCbase/AliTPCExBBShape.cxx
TPC/TPCbase/AliTPCExBBShape.h
TPC/TPCbase/AliTPCExBEffective.cxx
TPC/TPCbase/AliTPCExBEffective.h
TPC/TPCbase/AliTPCExBEffectiveSector.cxx
TPC/TPCbase/AliTPCExBEffectiveSector.h
TPC/TPCbase/AliTPCExBExact.cxx
TPC/TPCbase/AliTPCExBExact.h
TPC/TPCbase/AliTPCExBFirst.cxx
TPC/TPCbase/AliTPCExBFirst.h
TPC/TPCbase/AliTPCExBTwist.cxx
TPC/TPCbase/AliTPCExBTwist.h
TPC/TPCbase/AliTPCFCVoltError3D.cxx
TPC/TPCbase/AliTPCFCVoltError3D.h
TPC/TPCbase/AliTPCGGVoltError.cxx
TPC/TPCbase/AliTPCGGVoltError.h
TPC/TPCbase/AliTPCInverseCorrection.cxx
TPC/TPCbase/AliTPCInverseCorrection.h
TPC/TPCbase/AliTPCLaserTrack.cxx
TPC/TPCbase/AliTPCLaserTrack.h
TPC/TPCbase/AliTPCLoader.cxx
TPC/TPCbase/AliTPCLoader.h
TPC/TPCbase/AliTPCPRF2D.cxx
TPC/TPCbase/AliTPCPRF2D.h
TPC/TPCbase/AliTPCParam.cxx
TPC/TPCbase/AliTPCParam.h
TPC/TPCbase/AliTPCParamSR.cxx
TPC/TPCbase/AliTPCParamSR.h
TPC/TPCbase/AliTPCPointCorrection.cxx
TPC/TPCbase/AliTPCPointCorrection.h
TPC/TPCbase/AliTPCPreprocessor.cxx
TPC/TPCbase/AliTPCPreprocessor.h
TPC/TPCbase/AliTPCPreprocessorOnline.cxx
TPC/TPCbase/AliTPCPreprocessorOnline.h
TPC/TPCbase/AliTPCQAChecker.cxx
TPC/TPCbase/AliTPCQAChecker.h
TPC/TPCbase/AliTPCQADataMakerRec.cxx
TPC/TPCbase/AliTPCQADataMakerRec.h
TPC/TPCbase/AliTPCRF1D.cxx
TPC/TPCbase/AliTPCRF1D.h
TPC/TPCbase/AliTPCROC.cxx
TPC/TPCbase/AliTPCROC.h
TPC/TPCbase/AliTPCROCVoltError3D.cxx
TPC/TPCbase/AliTPCROCVoltError3D.h
TPC/TPCbase/AliTPCRawStreamV3.cxx
TPC/TPCbase/AliTPCRawStreamV3.h
TPC/TPCbase/AliTPCRecoParam.cxx
TPC/TPCbase/AliTPCRecoParam.h
TPC/TPCbase/AliTPCSensorTemp.cxx
TPC/TPCbase/AliTPCSensorTemp.h
TPC/TPCbase/AliTPCSensorTempArray.cxx
TPC/TPCbase/AliTPCSensorTempArray.h
TPC/TPCbase/AliTPCSpaceCharge.cxx
TPC/TPCbase/AliTPCSpaceCharge.h
TPC/TPCbase/AliTPCSpaceCharge3D.cxx
TPC/TPCbase/AliTPCSpaceCharge3D.h
TPC/TPCbase/AliTPCTempMap.cxx
TPC/TPCbase/AliTPCTempMap.h
TPC/TPCbase/AliTPCTransform.cxx
TPC/TPCbase/AliTPCTransform.h
TPC/TPCbase/AliTPCcalibDB.cxx
TPC/TPCbase/AliTPCcalibDB.h
TPC/TPCbase/AliTPCcalibDButil.cxx
TPC/TPCbase/AliTPCcalibDButil.h
TPC/TPCbase/AliTPCclusterInfo.cxx
TPC/TPCbase/AliTPCclusterInfo.h
TPC/TPCbase/AliTPCclusterMI.cxx
TPC/TPCbase/AliTPCclusterMI.h
TPC/TPCbase/AliTPCdataQA.cxx
TPC/TPCbase/AliTPCdataQA.h
TPC/TPCbase/AliTPCmapper.cxx
TPC/TPCbase/AliTPCmapper.h
TPC/TPCbase/AliTransform.cxx
TPC/TPCbase/AliTransform.h
TPC/TPCbase/AliXRDPROOFtoolkit.cxx
TPC/TPCbase/AliXRDPROOFtoolkit.h
TPC/TPCbase/imgdoc/AliTPCBoundaryVoltError_cxx_1511bb7.C [new file with mode: 0644]
TPC/TPCbase/imgdoc/AliTPCBoundaryVoltError_cxx_1511bb7.png [new file with mode: 0644]
TPC/TPCbase/imgdoc/AliTPCCorrection_cxx_e4df765.C [new file with mode: 0644]
TPC/TPCbase/imgdoc/AliTPCCorrection_cxx_e4df765.png [new file with mode: 0644]
TPC/TPCbase/imgdoc/AliTPCExBBShape_h_32a8c9f.C [new file with mode: 0644]
TPC/TPCbase/imgdoc/AliTPCExBBShape_h_32a8c9f.png [new file with mode: 0644]
TPC/TPCbase/imgdoc/AliTPCExBTwist_h_76e03fd.C [new file with mode: 0644]
TPC/TPCbase/imgdoc/AliTPCExBTwist_h_76e03fd.png [new file with mode: 0644]
TPC/TPCbase/imgdoc/AliTPCFCVoltError3D_cxx_ee7b060.C [new file with mode: 0644]
TPC/TPCbase/imgdoc/AliTPCFCVoltError3D_cxx_ee7b060.png [new file with mode: 0644]
TPC/TPCbase/imgdoc/AliTPCGGVoltError_h_359f7ec.C [new file with mode: 0644]
TPC/TPCbase/imgdoc/AliTPCGGVoltError_h_359f7ec.png [new file with mode: 0644]
TPC/TPCbase/imgdoc/AliTPCROCVoltError3D_cxx_99b6733.C [new file with mode: 0644]
TPC/TPCbase/imgdoc/AliTPCROCVoltError3D_cxx_99b6733.png [new file with mode: 0644]
TPC/TPCbase/imgdoc/AliTPCSpaceCharge_cxx_82e9c78.C [new file with mode: 0644]
TPC/TPCbase/imgdoc/AliTPCSpaceCharge_cxx_82e9c78.png [new file with mode: 0644]

index fa30eb6..0ad8aca 100644 (file)
  * 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>
 #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();
   }
 }
-
index e756b7c..c73e233 100644 (file)
@@ -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
 };
 
index 68fb8d5..2ada85e 100644 (file)
  * 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
index 097cd54..90fa2e6 100644 (file)
@@ -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
 };
 
 
index 8b94098..e769a45 100644 (file)
  * 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);
index 11e61fe..7e95e9d 100644 (file)
@@ -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
 };
index bdae6ba..8ea0006 100644 (file)
           -- 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
index 4943dce..531bedb 100644 (file)
@@ -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);
index f579aac..e44534f 100644 (file)
  * 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"
 
 
 
+/// \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;
 }
index d0e69fc..32dd423 100644 (file)
@@ -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  
 };
   
index ec6143c..3ea1888 100644 (file)
 
 /* $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();
index 552a011..0769db3 100644 (file)
@@ -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 */
index 5b7166d..5d8b792 100644 (file)
 
 /* $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();
index dd39573..9f2909c 100644 (file)
@@ -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));
 }
index c93259b..f39e81d 100644 (file)
 
 /* $Id$ */
 
-///////////////////////////////////////////////////////////////////////////////
-//                                                                           //
-//  Alice  AliSementID   object                                             //
-//                                
-//                                                                           //
-//                                                                          //
-///////////////////////////////////////////////////////////////////////////////
+/// \class AliSegmentID
+///
+///  Alice  AliSementID   object
 
 
 #include "AliSegmentID.h"
index 8fd0ea8..08c3d19 100644 (file)
@@ -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
index b51c304..dd3a355 100644 (file)
  * 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
index 1244b30..6e68994 100644 (file)
@@ -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; 
index 546b3c3..54b838c 100644 (file)
  * 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;
   }
index c97726b..d3be510 100644 (file)
@@ -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:
 
index dfa621d..75d5572 100644 (file)
  * 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];  
index b1bf6d3..666fb41 100644 (file)
@@ -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
index 5d47877..eec4b60 100644 (file)
 
 /* $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);
index af89f28..4391fd2 100644 (file)
@@ -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
index 6c70e40..22960a3 100644 (file)
  **************************************************************************/
 
 
-///////////////////////////////////////////////////////////////////////////////
-//                                                                           //
-//     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};
index 361b291..64f5b57 100644 (file)
@@ -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
 
 };
 
index 32befce..fc4071a 100644 (file)
  * 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;
 }
index 5f0b347..19c2587 100644 (file)
@@ -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;
index b1f98fe..4bf1486 100644 (file)
  **************************************************************************/
 
 
-////////////////////////////////////////////////////////////////////////////
-//                                                                        //
-// 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;
   //
index e6d9bf8..bdb3a60 100644 (file)
@@ -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
index 690f7eb..9b13b1c 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
+/// \class AliTPCCalibPedestal
 
-/* $Id$ */
-
-
-//Root includes
+// Root includes
 #include <TH1F.h>
 #include <TH2F.h>
 #include <TString.h>
 //
 
 
+/// \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 ) {
index a78c373..8350fc5 100644 (file)
@@ -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,
index 4d91349..bb5d4df 100644 (file)
  * 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