doxy: converted TPC/ main dir macros
authordberzano <dario.berzano@cern.ch>
Fri, 9 Jan 2015 15:58:16 +0000 (16:58 +0100)
committerdberzano <dario.berzano@cern.ch>
Fri, 9 Jan 2015 17:25:34 +0000 (18:25 +0100)
29 files changed:
TPC/AliBarrelRec_TPCparam.C
TPC/AliL1Delay.C
TPC/AliTPCAltro.C
TPC/AliTPCCmpNG.C
TPC/AliTPCCompareTracks.C
TPC/AliTPCComparison.C
TPC/AliTPCComparison2.C
TPC/AliTPCCreatePRF.C
TPC/AliTPCCreatePRFGEM.C
TPC/AliTPCDDL.C
TPC/AliTPCDDLRawData.C
TPC/AliTPCDisplayDigits.C
TPC/AliTPCMonitorExec.C [changed mode: 0755->0644]
TPC/AliTPCSavePID.C
TPC/AliTPCScanPID.C
TPC/AliTPCTestMerge.C
TPC/AnalyzeESDtracks.C
TPC/ClassTree.C
TPC/ConfigKr.C
TPC/FindKrClusters.C
TPC/FindKrClustersRaw.C
TPC/LandauTest.C
TPC/MakeTPCAltroMapping.C
TPC/MakeTPCFullMisAlignment.C
TPC/MakeTPCResMisAlignment.C
TPC/MakeTPCZeroMisAlignment.C
TPC/SetTPCParamOptional.C
TPC/TestAnalisys.C
TPC/recTPC.C

index 30e429c..2b2b170 100644 (file)
@@ -1,18 +1,16 @@
-void AliBarrelRec_TPCparam(Int_t firstEvent=0,Int_t lastEvent=0) {
-  //
-  // Macro to create AliESDs.root using parametrized TPC tracking
-  // and AliITStrackerSA (MI + SA)
-  //
-  // Input files:
-  // - galice.root
-  // - Kinematics.root
-  // - TrackReferences.root
-  // - ITS.RecPoints.root (use AliRecontruction class)
-  // - ITS.Vertex.root (use $ALICE_ROOT/ITS/AliITSVertexerZTest.C)
-  //
-  // A. Dainese - INFN Legnaro
-  //
+/// \file AliBarrelRec_TPCparam.C
+/// \brief Macro to create AliESDs.root using parametrized TPC tracking and AliITStrackerSA (MI + SA)
+/// 
+/// Input files:
+/// - galice.root
+/// - Kinematics.root
+/// - TrackReferences.root
+/// - ITS.RecPoints.root (use AliRecontruction class)
+/// - ITS.Vertex.root (use $ALICE_ROOT/ITS/AliITSVertexerZTest.C)
+/// 
+/// \author A. Dainese - INFN Legnaro
 
+void AliBarrelRec_TPCparam(Int_t firstEvent=0,Int_t lastEvent=0) {
 
   Int_t  collcode = 1; // pp collisions
   Bool_t useMeanVtx = kFALSE;
index 8dc9373..a4b670d 100644 (file)
@@ -1,24 +1,20 @@
-
-/////////////////////////////////////////////////////////////////////////////
-//                                                                         //
-// This is a macro which measures the time delay of L1 trigger in TPC      //
-//                                                                         //
-// It reads the ESD tracks and fills histograms with the distance          //
-// between the primary vertex and the Z position                           //
-// of the point of closest approach between the track and the beam axis.   //
-// The processing of forward and backward tracks is done separately.       //
-// The corresponding histograms are fitted with gaussian and the           //
-// shifts of the Z positions are extracted.                                //
-// The L1 time delay is taken as an average of the forward and backward    //
-// (with opposite sign) shifts divided by the drift velocity.              //
-// We assume that the ESD tracks are obtained by the TPC tracking stand    //
-// alone.                                                                  //
-// The propagation to the vertex can be done either with or without        //
-// TGeoManager.                                                            //
-//                                                                         //
-// Cvetan.Cheshkov@cern.ch                                                 //
-//                                                                         //
-/////////////////////////////////////////////////////////////////////////////
+/// \file AliL1Delay.C
+/// \brief Macro that measures the time delay of L1 trigger in TPC
+/// 
+/// It reads the ESD tracks and fills histograms with the distance
+/// between the primary vertex and the Z position
+/// of the point of closest approach between the track and the beam axis.
+/// The processing of forward and backward tracks is done separately.
+/// The corresponding histograms are fitted with gaussian and the
+/// shifts of the Z positions are extracted.
+/// The L1 time delay is taken as an average of the forward and backward
+/// (with opposite sign) shifts divided by the drift velocity.
+/// We assume that the ESD tracks are obtained by the TPC tracking stand
+/// alone.
+/// The propagation to the vertex can be done either with or without
+/// TGeoManager.
+/// 
+/// \author Cvetan Cheshkov <Cvetan.Cheshkov@cern.ch>
 
 #if !defined(__CINT__) || defined(__MAKECINT__)
   #include <TMath.h>
index d14b2c8..a33691b 100644 (file)
@@ -8,20 +8,24 @@
 #include "AliTPCBuffer160.h"
 #endif
 
+/// \file AliTPCAltro.C
+
 int AliTPCAltro(Int_t eth=0){
-  //eth is a threshold.
-  //Digits stored into a file have an amplitude value greater than "eth"
-  Int_t offset=1; //this should be equal to the threshold
+
+  /// eth is a threshold.
+  /// Digits stored into a file have an amplitude value greater than "eth"
+
+  Int_t offset=1; ///< this should be equal to the threshold
   /*
     NB the amplitude values stored in the ALTRO file are shifted  by offset 
     because the range for each word goes from 0 to 1023, now due to zero suppression 
     values lower that the threshold never appear.
    */
 
-  Int_t PSecNumber=-1;  //Previous Sector number
-  Int_t PRowNumber=-1;  //Previous Row number  
-  Int_t PPadNumber=-1;  //Previous Pad number
-  Int_t PTimeBin=-1;    //Previous Time-Bin
+  Int_t PSecNumber=-1;  ///< Previous Sector number
+  Int_t PRowNumber=-1;  ///< Previous Row number
+  Int_t PPadNumber=-1;  ///< Previous Pad number
+  Int_t PTimeBin=-1;    ///< Previous Time-Bin
   Int_t BunchLength=0;
   //AliTPCBuffer160 is used in write mode to generate AltroFormat.dat file
   AliTPCBuffer160 Buffer("AltroFormat.dat",1); 
@@ -58,7 +62,7 @@ int AliTPCAltro(Int_t eth=0){
   digarr->ConnectTree(digitsTree);
   //ofstream ftxt("Data.txt");
   for (Int_t n=0; n<nrows; n++) {
-    Int_t sec,row; // sector and row number (in the TPC)
+    Int_t sec,row; ///< sector and row number (in the TPC)
     AliSimDigits *digrow=(AliSimDigits*)digarr->LoadEntry(n);
     param->AdjustSectorRow(digrow->GetID(),sec,row);   
 
index fd2723e..08ce290 100644 (file)
-////////////////////////////////////////////////////////////////////////
-//
-// name: AliTPCCmpNG.C 
-//
-// date: 24.09.2002
-// author: Jiri Chudoba
-// version: 1.0
-// description: 
-//        define a class TPCGenTrack
-//        save TPC related properties of tracks into a single tree
-//
-// input: 
-//        Int_t nEvents      ... nr of events to process
-//        Int_t firstEventNr ... first event number (starts from 0)
-//        char* fnRecTracks .. name of file with reconstructed tracks
-//        char* fnHits ... name of file with hits and Kine Tree
-//        char* fnDigits  ... name of file with digits
-//        char* fnTracks .. output file name, default genTracks.root
-//
-// How to use:
-//  Typical usage:
-//    .L AliTPCCmpNG.C+
-//    TPCFindGenTracks *t = new TPCFindGenTracks("galice.root","tpc.digits.root")
-//    t->Exec();
-//    .q
-//    aliroot
-//    .L  AliTPCCmpNG.C+
-//    TPCCmpTr *t2 = new TPCCmpTr("tpc.tracks.root","genTracks.root","cmpTracks.root");
-//    t2->Exec();
-//
-//  Details:
-//  ========
-//
-//  Step 1 - summurize information from simulation
-//  ===============================================
-//  Compile macro with ACLIC:
-//     .L AliTPCCmpNG.C+
-//  create an object TPCFindGenTracks, which processes information
-//  from simulations. As input it needs:
-//     object gAlice: to get magnetic field
-//     TreeK: to get parameters of generated particles
-//     TreeTR: to get track parameters at the TPC entry
-//     TreeD: to get number of digits and digits pattern
-//                for a given track in TPC
-//  These input objects can be in different files, gAlice, TreeK and
-//  TreeTR are in the file fnHits, TreeD in the file fnDigits (can be
-//  the same as fnHits. Output is written to the file fnRes 
-//  ("genTracks.root" by default). Use can specify number of 
-//  events to process and the first event number:
-//    TPCFindGenTracks *t = new TPCFindGenTracks("galice.root","tpc.digits.root","genTracks.root",1,0)
-//  The filenames in the example on previous line are defaults, user can 
-//  specify just the file name with gAlice object (and TreeTR and TreeK), 
-//  so equivalent shorter initialization is:
-//    TPCFindGenTracks *t = new TPCFindGenTracks("galice.root")
-//  The task is done by calling Exec() method:
-//    t->Exec();
-//  User can set different debug levels by invoking:
-//    t->SetDebug(debugLevel)
-//  Number of events to process and the first event number can be
-//  specified as parameters to Exec:
-//    t->Exec(nEvents, firstEvent)
-//  Then you have to quit root to get rid of problems with deleting gAlice
-//  object (it is not deleted, but read again in the following step):
-//
-//  Step 2 - compare reconstructed tracks with simulated
-//  ====================================================
-//
-//  Load (and compile) the macro:
-//   .L AliTPCCmpNG.C+
-//  Create object TPCCmpTr, which does the comparison. As input it requires 
-//  name of the file with reconstructed TPC tracks. You can specify 
-//  name of the file with genTrack tree (summarized info about simulation),
-//  file with gAlice object, output file name, number of events to process
-//  and first event number:
-//  TPCCmpTr *t2 = new TPCCmpTr("tpc.tracks.root","genTracks.root","cmpTracks.root","galice.root",1,0);
-//  The interface is quite similar to the TPCFindGenTracks class.
-//  Then just invoke Exec() method:
-//  t2->Exec();
-//
-//  Step 3 - study the results
-//  ==========================
-//  Load the outoput TTree and you can do Draw(), Scan() or other
-//  usual things to do with TTree:
-//  TFile *f = new TFile("cmpTracks.root")
-//  TTree *t = (TTree*)f->Get("TPCcmpTracks")
-//  t->Draw("fVDist[3]","fReconstructed")
-//
-// History:
-//
-// 24.09.02 - first version
-// 24.01.03 - v7, before change from TPC Special Hits to TrackReferences
-// 26.01.03 - change from TPC Special Hits to TrackReferences
-//            (loop over TreeTR instead of TreeH)
-// 28.01.03 - v8 last version before removing TPC special point
-// 28.01.03 - remove TPC special point, loop over TreeH 
-//            store TParticle and AliTrack
-// 29.01.03 - v9 last version before moving the loop over rec. tracks
-//            into separate step
-// 03.02.03 - rename to AliTPCCmpNG.C, remove the part with rec. tracks
-//            (will be addded in a macro AliTPCCmpTr.C
-//
-//
-////////////////////////////////////////////////////////////////////////
+/// \file AliTPCCmpNG.C
+/// 
+/// version: 1.0
+/// description:
+///        define a class TPCGenTrack
+///        save TPC related properties of tracks into a single tree
+/// 
+/// input:
+///        Int_t nEvents      ... nr of events to process
+///        Int_t firstEventNr ... first event number (starts from 0)
+///        char* fnRecTracks .. name of file with reconstructed tracks
+///        char* fnHits ... name of file with hits and Kine Tree
+///        char* fnDigits  ... name of file with digits
+///        char* fnTracks .. output file name, default genTracks.root
+/// 
+/// How to use:
+///  Typical usage:
+///    .L AliTPCCmpNG.C+
+///    TPCFindGenTracks *t = new TPCFindGenTracks("galice.root","tpc.digits.root")
+///    t->Exec();
+///    .q
+///    aliroot
+///    .L  AliTPCCmpNG.C+
+///    TPCCmpTr *t2 = new TPCCmpTr("tpc.tracks.root","genTracks.root","cmpTracks.root");
+///    t2->Exec();
+/// 
+///  Details:
+/// 
+///  Step 1 - summurize information from simulation
+/// 
+///  Compile macro with ACLIC:
+///     .L AliTPCCmpNG.C+
+///  create an object TPCFindGenTracks, which processes information
+///  from simulations. As input it needs:
+///     object gAlice: to get magnetic field
+///     TreeK: to get parameters of generated particles
+///     TreeTR: to get track parameters at the TPC entry
+///     TreeD: to get number of digits and digits pattern
+///                for a given track in TPC
+///  These input objects can be in different files, gAlice, TreeK and
+///  TreeTR are in the file fnHits, TreeD in the file fnDigits (can be
+///  the same as fnHits. Output is written to the file fnRes
+///  ("genTracks.root" by default). Use can specify number of
+///  events to process and the first event number:
+///    TPCFindGenTracks *t = new TPCFindGenTracks("galice.root","tpc.digits.root","genTracks.root",1,0)
+///  The filenames in the example on previous line are defaults, user can
+///  specify just the file name with gAlice object (and TreeTR and TreeK),
+///  so equivalent shorter initialization is:
+///    TPCFindGenTracks *t = new TPCFindGenTracks("galice.root")
+///  The task is done by calling Exec() method:
+///    t->Exec();
+///  User can set different debug levels by invoking:
+///    t->SetDebug(debugLevel)
+///  Number of events to process and the first event number can be
+///  specified as parameters to Exec:
+///    t->Exec(nEvents, firstEvent)
+///  Then you have to quit root to get rid of problems with deleting gAlice
+///  object (it is not deleted, but read again in the following step):
+/// 
+///  Step 2 - compare reconstructed tracks with simulated
+/// 
+///  Load (and compile) the macro:
+///   .L AliTPCCmpNG.C+
+///  Create object TPCCmpTr, which does the comparison. As input it requires
+///  name of the file with reconstructed TPC tracks. You can specify
+///  name of the file with genTrack tree (summarized info about simulation),
+///  file with gAlice object, output file name, number of events to process
+///  and first event number:
+///  TPCCmpTr *t2 = new TPCCmpTr("tpc.tracks.root","genTracks.root","cmpTracks.root","galice.root",1,0);
+///  The interface is quite similar to the TPCFindGenTracks class.
+///  Then just invoke Exec() method:
+///  t2->Exec();
+/// 
+///  Step 3 - study the results
+/// 
+///  Load the outoput TTree and you can do Draw(), Scan() or other
+///  usual things to do with TTree:
+///  TFile *f = new TFile("cmpTracks.root")
+///  TTree *t = (TTree*)f->Get("TPCcmpTracks")
+///  t->Draw("fVDist[3]","fReconstructed")
+/// 
+/// History:
+/// 
+/// 24.09.02 - first version
+/// 24.01.03 - v7, before change from TPC Special Hits to TrackReferences
+/// 26.01.03 - change from TPC Special Hits to TrackReferences
+///            (loop over TreeTR instead of TreeH)
+/// 28.01.03 - v8 last version before removing TPC special point
+/// 28.01.03 - remove TPC special point, loop over TreeH
+///            store TParticle and AliTrack
+/// 29.01.03 - v9 last version before moving the loop over rec. tracks
+///            into separate step
+/// 03.02.03 - rename to AliTPCCmpNG.C, remove the part with rec. tracks
+///            (will be addded in a macro AliTPCCmpTr.C
+/// 
+/// \author Jiri Chudoba
+/// \date 24.09.2002
 
 #if !defined(__CINT__) || defined(__MAKECINT__)
 #include "iostream.h"
@@ -246,14 +240,14 @@ class TPCGenInfo: public TObject {
 
 public:
   TPCGenInfo();
-  AliTrackReference *fTrackRef;   // track reference saved in the output tree
-  TParticle *fParticle;           // generated particle 
-  Int_t fLabel;                   // track label
+  AliTrackReference *fTrackRef;   ///< track reference saved in the output tree
+  TParticle *fParticle;           ///< generated particle
+  Int_t fLabel;                   ///< track label
 
-  Int_t fRowsWithDigitsInn;    // number of rows with digits in the inner sectors
-  Int_t fRowsWithDigits;       // number of rows with digits in the outer sectors
-  Int_t fRowsTrackLength;      // last - first row with digit
-  Int_t fDigitsInSeed;         // digits in the default seed rows
+  Int_t fRowsWithDigitsInn;    ///< number of rows with digits in the inner sectors
+  Int_t fRowsWithDigits;       ///< number of rows with digits in the outer sectors
+  Int_t fRowsTrackLength;      ///< last - first row with digit
+  Int_t fDigitsInSeed;         ///< digits in the default seed rows
 
   ClassDef(TPCGenInfo,1)  // container for 
 };
@@ -327,9 +321,8 @@ void digitRow::SetRow(Int_t row)
 ////////////////////////////////////////////////////////////////////////
 Bool_t digitRow::TestRow(Int_t row)
 {
-//
-// return kTRUE if row is on
-//
+/// return kTRUE if row is on
+
   Int_t iC = row/8;
   Int_t iB = row%8;
   return TESTBIT(fDig[iC],iB);
@@ -337,10 +330,9 @@ Bool_t digitRow::TestRow(Int_t row)
 ////////////////////////////////////////////////////////////////////////
 Int_t digitRow::RowsOn(Int_t upto)
 {
-//
-// returns number of rows with a digit  
-// count only rows less equal row number upto
-//
+/// returns number of rows with a digit
+/// count only rows less equal row number upto
+
   Int_t total = 0;
   for (Int_t i = 0; i<kgRowBytes; i++) {
     for (Int_t j = 0; j < 8; j++) {
@@ -353,9 +345,8 @@ Int_t digitRow::RowsOn(Int_t upto)
 ////////////////////////////////////////////////////////////////////////
 void digitRow::Reset()
 {
-//
-// resets all rows to zero
-//
+/// resets all rows to zero
+
   for (Int_t i = 0; i<kgRowBytes; i++) {
     fDig[i] <<= 8;
   }
@@ -363,10 +354,9 @@ void digitRow::Reset()
 ////////////////////////////////////////////////////////////////////////
 Int_t digitRow::Last()
 {
-//
-// returns the last row number with a digit
-// returns -1 if now digits 
-//
+/// returns the last row number with a digit
+/// returns -1 if now digits
+
   for (Int_t i = kgRowBytes-1; i>=0; i--) {
     for (Int_t j = 7; j >= 0; j--) {
       if TESTBIT(fDig[i],j) return i*8+j;
@@ -377,10 +367,9 @@ Int_t digitRow::Last()
 ////////////////////////////////////////////////////////////////////////
 Int_t digitRow::First()
 {
-//
-// returns the first row number with a digit
-// returns -1 if now digits 
-//
+/// returns the first row number with a digit
+/// returns -1 if now digits
+
   for (Int_t i = 0; i<kgRowBytes; i++) {
     for (Int_t j = 0; j < 8; j++) {
       if (TESTBIT(fDig[i],j)) return i*8+j;
@@ -425,50 +414,50 @@ public:
                    AliTPCParam *paramTPC);
 
 public:
-  Int_t fDebug;                   //! debug flag  
-  Int_t fEventNr;                 //! current event number
-  Int_t fLabel;                   //! track label
-  Int_t fNEvents;                 //! number of events to process
-  Int_t fFirstEventNr;            //! first event to process
-  Int_t fNParticles;              //! number of particles in TreeK
-  TTree *fTreeGenTracks;          //! output tree with generated tracks
-  char *fFnRes;                   //! output file name with stored tracks
-  char *fFnHits;                  //! input file name with hits
-  char *fFnDigits;                //! input file name with digits
-  TFile *fFileGenTracks;             //! output file with stored fTreeGenTracks
-  TFile *fFileHits;               //! input file with hits
-  TFile *fFileTreeD;              //! input file with digits
-  digitRow *fDigitRow;            //! pointer to the object saved in Branch
-  digitRow *fContainerDigitRow;   //! big container for partial information
-  AliTrackReference *fTrackRef;   //! track reference saved in the output tree
-  AliTrackReference *fContainerTR;//! big container for partial information
-  Int_t *fIndexTR;                //! index of particle label in the fContainerTR
-  Int_t fLastIndexTR;             //! last used index in fIndexTR
-
-  AliTPCParam* fParamTPC;         //! AliTPCParam
-
-  Double_t fVPrim[3];             //! primary vertex position
-  Double_t fVDist[4];             //! distance of the particle vertex from primary vertex
+  Int_t fDebug;                   //!< debug flag
+  Int_t fEventNr;                 //!< current event number
+  Int_t fLabel;                   //!< track label
+  Int_t fNEvents;                 //!< number of events to process
+  Int_t fFirstEventNr;            //!< first event to process
+  Int_t fNParticles;              //!< number of particles in TreeK
+  TTree *fTreeGenTracks;          //!< output tree with generated tracks
+  char *fFnRes;                   //!< output file name with stored tracks
+  char *fFnHits;                  //!< input file name with hits
+  char *fFnDigits;                //!< input file name with digits
+  TFile *fFileGenTracks;             //!< output file with stored fTreeGenTracks
+  TFile *fFileHits;               //!< input file with hits
+  TFile *fFileTreeD;              //!< input file with digits
+  digitRow *fDigitRow;            //!< pointer to the object saved in Branch
+  digitRow *fContainerDigitRow;   //!< big container for partial information
+  AliTrackReference *fTrackRef;   //!< track reference saved in the output tree
+  AliTrackReference *fContainerTR;//!< big container for partial information
+  Int_t *fIndexTR;                //!< index of particle label in the fContainerTR
+  Int_t fLastIndexTR;             //!< last used index in fIndexTR
+
+  AliTPCParam* fParamTPC;         //!< AliTPCParam
+
+  Double_t fVPrim[3];             //!< primary vertex position
+  Double_t fVDist[4];             //!< distance of the particle vertex from primary vertex
                                   // the fVDist[3] contains size of the 3-vector
-  TParticle *fParticle;           //! generated particle 
+  TParticle *fParticle;           //!< generated particle
 
-  Int_t fRowsWithDigitsInn;       //! number of rows with digits in the inner sectors
-  Int_t fRowsWithDigits;          //! number of rows with digits in the outer sectors
-  Int_t fRowsTrackLength;         //! last - first row with digit
-  Int_t fDigitsInSeed;            //! digits in the default seed rows
+  Int_t fRowsWithDigitsInn;       //!< number of rows with digits in the inner sectors
+  Int_t fRowsWithDigits;          //!< number of rows with digits in the outer sectors
+  Int_t fRowsTrackLength;         //!< last - first row with digit
+  Int_t fDigitsInSeed;            //!< digits in the default seed rows
 
 private:
 
 // some constants for the original non-pareller tracking (by Y.Belikov)
-  static const Int_t seedRow11 = 158;  // nRowUp - 1
-  static const Int_t seedRow12 = 139;  // nRowUp - 1 - (Int_t) 0.125*nRowUp
-  static const Int_t seedRow21 = 149;  // seedRow11 - shift
-  static const Int_t seedRow22 = 130;  // seedRow12 - shift
+  static const Int_t seedRow11 = 158;  ///< nRowUp - 1
+  static const Int_t seedRow12 = 139;  ///< nRowUp - 1 - (Int_t) 0.125*nRowUp
+  static const Int_t seedRow21 = 149;  ///< seedRow11 - shift
+  static const Int_t seedRow22 = 130;  ///< seedRow12 - shift
   static const Double_t kRaddeg = 180./TMath::Pi();
 
-  static const Int_t fgMaxIndexTR = 50000; // maximum number of tracks with a track ref
-  static const Int_t fgMaxParticles = 2000000; // maximum number of generated particles
-  static const Double_t fgPtCut = .001; // do not store particles with generated pT less than this
+  static const Int_t fgMaxIndexTR = 50000; ///< maximum number of tracks with a track ref
+  static const Int_t fgMaxParticles = 2000000; ///< maximum number of generated particles
+  static const Double_t fgPtCut = .001; ///< do not store particles with generated pT less than this
   static const Float_t fgTrackRefLocalXMax = 82.95;
   static const Float_t fgTrackRefLocalXMaxDelta = 500.; 
 
@@ -642,11 +631,9 @@ void TPCFindGenTracks::CloseOutputFile()
 ////////////////////////////////////////////////////////////////////////
 Int_t TPCFindGenTracks::TreeKLoop()
 {
-//
-// open the file with treeK
-// loop over all entries there and save information about some tracks
-//
-  
+/// open the file with treeK
+/// loop over all entries there and save information about some tracks
+
   fFileHits->cd();
   if (fDebug > 0) {
     cout<<"There are "<<fNParticles<<" primary and secondary particles in event "
@@ -714,10 +701,8 @@ Int_t TPCFindGenTracks::TreeKLoop()
 ////////////////////////////////////////////////////////////////////////
 Int_t TPCFindGenTracks::TreeDLoop()
 {
-//
-// open the file with treeD
-// loop over all entries there and save information about some tracks
-//
+/// open the file with treeD
+/// loop over all entries there and save information about some tracks
 
 
 //  Int_t nrow_up=fParamTPC->GetNRowUp();
@@ -783,10 +768,8 @@ Int_t TPCFindGenTracks::TreeDLoop()
 ////////////////////////////////////////////////////////////////////////
 Int_t TPCFindGenTracks::TreeTRLoop()
 {
-//
-// loop over TrackReferences and store the first one for each track
-//
-  
+/// loop over TrackReferences and store the first one for each track
+
   TTree *treeTR=gAlice->TreeTR();
   if (!treeTR) {
     cerr<<"TreeTR not found"<<endl;
@@ -893,51 +876,51 @@ public:
                    AliTPCParam *paramTPC);
 
 private:
-  digitRow *fDigitRow;            //! pointer to the object saved in Branch
-  Int_t fEventNr;                 //! current event number
-  Int_t fLabel;                   //! track label
-  Int_t fNEvents;                 //! number of events to process
-  Int_t fFirstEventNr;            //! first event to process
+  digitRow *fDigitRow;            //!< pointer to the object saved in Branch
+  Int_t fEventNr;                 //!< current event number
+  Int_t fLabel;                   //!< track label
+  Int_t fNEvents;                 //!< number of events to process
+  Int_t fFirstEventNr;            //!< first event to process
 
-  char *fFnCmp;                   //! output file name with cmp tracks
-  TFile *fFileCmp;                //! output file with cmp tracks
-  TTree *fTreeCmp;                //! output tree with cmp tracks
+  char *fFnCmp;                   //!< output file name with cmp tracks
+  TFile *fFileCmp;                //!< output file with cmp tracks
+  TTree *fTreeCmp;                //!< output tree with cmp tracks
 
-  char *fFnGenTracks;             //! input file name with gen tracks
+  char *fFnGenTracks;             //!< input file name with gen tracks
   TFile *fFileGenTracks;
   TTree *fTreeGenTracks;
 
-  char *fFnHits;                  //! input file name with gAlice object (needed for B)
-  TFile *fFileHits;               //! input file with gAlice
+  char *fFnHits;                  //!< input file name with gAlice object (needed for B)
+  TFile *fFileHits;               //!< input file with gAlice
 
-  char *fFnRecTracks;             //! input file name with tpc rec. tracks
-  TFile *fFileRecTracks;          //! input file with reconstructed tracks
-  TTree *fTreeRecTracks;          //! tree with reconstructed tracks
+  char *fFnRecTracks;             //!< input file name with tpc rec. tracks
+  TFile *fFileRecTracks;          //!< input file with reconstructed tracks
+  TTree *fTreeRecTracks;          //!< tree with reconstructed tracks
 
-  AliTPCtrack *fTPCTrack;         //! pointer to TPC track to connect branch
-  Int_t *fIndexRecTracks;         //! index of particle label in the TreeT_TPC
+  AliTPCtrack *fTPCTrack;         //!< pointer to TPC track to connect branch
+  Int_t *fIndexRecTracks;         //!< index of particle label in the TreeT_TPC
 
-  Int_t fRowsWithDigitsInn;       //! number of rows with digits in the inner sectors
-  Int_t fRowsWithDigits;          //! number of rows with digits in the outer sectors
-  Int_t fRowsTrackLength;         //! last - first row with digit
-  Int_t fDigitsInSeed;            //! digits in the default seed rows
-  TParticle *fParticle;           //! generated particle 
-  Double_t fVDist[4];             //! distance of the particle vertex from primary vertex
+  Int_t fRowsWithDigitsInn;       //!< number of rows with digits in the inner sectors
+  Int_t fRowsWithDigits;          //!< number of rows with digits in the outer sectors
+  Int_t fRowsTrackLength;         //!< last - first row with digit
+  Int_t fDigitsInSeed;            //!< digits in the default seed rows
+  TParticle *fParticle;           //!< generated particle
+  Double_t fVDist[4];             //!< distance of the particle vertex from primary vertex
                                   // the fVDist[3] contains size of the 3-vector
-  AliTrackReference *fTrackRef;   //! track reference saved in the output tree
-  Int_t   fReconstructed;         //! flag if track was reconstructed
-  AliTPCParam* fParamTPC;         //! AliTPCParam
+  AliTrackReference *fTrackRef;   //!< track reference saved in the output tree
+  Int_t   fReconstructed;         //!< flag if track was reconstructed
+  AliTPCParam* fParamTPC;         //!< AliTPCParam
 
-  Int_t fNParticles;              //! number of particles in the input tree genTracks
-  Int_t fDebug;                   //! debug flag  
+  Int_t fNParticles;              //!< number of particles in the input tree genTracks
+  Int_t fDebug;                   //!< debug flag
 
-  Int_t fNextTreeGenEntryToRead;    //! last entry already read from genTracks tree
-  TPCGenInfo *fGenInfo;           //! container for all the details
+  Int_t fNextTreeGenEntryToRead;    //!< last entry already read from genTracks tree
+  TPCGenInfo *fGenInfo;           //!< container for all the details
 
-  Double_t fRecPhi;         // reconstructed phi angle (0;2*kPI)
-  Double_t fLambda;         // reconstructed 
-  Double_t fRecPt_1;        // reconstructed 
-  Float_t fdEdx;           // reconstructed  dEdx      
+  Double_t fRecPhi;         ///< reconstructed phi angle (0;2*kPI)
+  Double_t fLambda;         ///< reconstructed
+  Double_t fRecPt_1;        ///< reconstructed
+  Float_t fdEdx;           ///< reconstructed  dEdx
 
 
   ClassDef(TPCCmpTr,1)    // class which creates and fills tree with TPCGenTrack objects
@@ -1077,10 +1060,9 @@ Int_t TPCCmpTr::Exec()
 ////////////////////////////////////////////////////////////////////////
 Bool_t TPCCmpTr::ConnectGenTree()
 {
-//
-// connect all branches from the genTracksTree
-// use the same variables as for the new cmp tree, it may work
-//
+/// connect all branches from the genTracksTree
+/// use the same variables as for the new cmp tree, it may work
+
   fFileGenTracks = TFile::Open(fFnGenTracks,"READ");
   if (!fFileGenTracks) {
     cerr<<"Error in ConnectGenTree: cannot open file "<<fFnGenTracks<<endl;
@@ -1168,9 +1150,7 @@ Float_t TPCCmpTr::TR2LocalX(AliTrackReference *trackRef,
 
 Int_t TPCCmpTr::TreeTLoop(Int_t eventNr)
 {
-//
-// loop over all TPC reconstructed tracks and store info in memory
-//
+/// loop over all TPC reconstructed tracks and store info in memory
 
   
   if (!fFileRecTracks) fFileRecTracks = TFile::Open(fFnRecTracks,"read");
@@ -1208,11 +1188,9 @@ Int_t TPCCmpTr::TreeTLoop(Int_t eventNr)
 ////////////////////////////////////////////////////////////////////////
 Int_t TPCCmpTr::TreeGenLoop(Int_t eventNr)
 {
-//
-// loop over all entries for a given event, find corresponding 
-// rec. track and store in the fTreeCmp
-//
-  
+/// loop over all entries for a given event, find corresponding
+/// rec. track and store in the fTreeCmp
+
   fFileGenTracks->cd();
   Int_t entry = fNextTreeGenEntryToRead;
   Double_t nParticlesTR = fTreeGenTracks->GetEntriesFast();
index 822cf38..0832dde 100644 (file)
@@ -5,6 +5,7 @@
 #include "AliTPCclusterMI.h"
 #endif
 
+/// \file AliTPCCompareTracks.C
 
 Int_t AliTPCCompareTracks(Int_t eventn, Bool_t all = kFALSE) {
    cerr<<"Comparing tracks...\n";
index e14f7ca..808179c 100644 (file)
@@ -1,13 +1,11 @@
-/****************************************************************************
- *           Very important, delicate and rather obscure macro.             *
- *                                                                          *
- *               Creates list of "trackable" tracks,                        *
- *             calculates efficiency, resolutions etc.                      *
- *     There is a possibility to run this macro over several events.         *
- *                                                                          *
- *           Origin: I.Belikov, CERN, Jouri.Belikov@cern.ch                 *
- * with several nice improvements by: M.Ivanov, GSI, m.ivanov@gsi.de        *
- ****************************************************************************/
+/// \file AliTPCComparison.C
+/// \brief Very important, delicate and rather obscure macro
+///
+/// Creates list of "trackable" tracks, calculates efficiency, resolutions etc.
+///
+/// There is a possibility to run this macro over several events.
+///
+/// \author I.Belikov, CERN, Jouri.Belikov@cern.ch, M.Ivanov, GSI, m.ivanov@gsi.de
 
 #if !defined(__CINT__) || defined(__MAKECINT__)
   #include <TMath.h>
@@ -158,7 +156,8 @@ Int_t AliTPCComparison
    event->ReadFromTree(esdTree);
 
 
-   //******* Loop over events *********
+  // ******* Loop over events *********
+
    Int_t e=0;
    while (esdTree->GetEvent(e)) {
       cout<<endl<<endl<<"********* Processing event number: "<<e<<"*******\n";
index 0ca8285..a3572b4 100644 (file)
@@ -1,13 +1,12 @@
-/****************************************************************************
- *           Very important, delicate and rather obscure macro.             *
- *                                                                          *
- *               Creates list of "trackable" tracks,                        *
- *             sorts tracks for matching with the ITS,                      *
- *             calculates efficiency, resolutions etc.                      *
- *                                                                          *
- *           Origin: I.Belikov, CERN, Jouri.Belikov@cern.ch                 *
- * with several nice improvements by: M.Ivanov, GSI, m.ivanov@gsi.de        *
- ****************************************************************************/
+/// \file AliTPCComparison.C
+/// \brief Very important, delicate and rather obscure macro
+///
+/// Creates list of "trackable" tracks, sorts tracks for matching with the ITS,
+/// calculates efficiency, resolutions etc.
+///
+/// There is a possibility to run this macro over several events.
+///
+/// \author I.Belikov, CERN, Jouri.Belikov@cern.ch, M.Ivanov, GSI, m.ivanov@gsi.de
 
 #if !defined(__CINT__) || defined(__MAKECINT__)
 #include<fstream.h>
@@ -55,7 +54,9 @@ Int_t AliTPCComparison2(Int_t firstev=0, Int_t eventn=1) {
   /***********************************************************************/
 
   TFile *inkin = TFile::Open("rfio:galice.root");
-  //  if(gAlice)delete gAlice;   COMMENTED BECAUSE OF A BUG (IN COMPILED MODE)
+/// \file AliTPCComparison2.C
+///  if(gAlice)delete gAlice;   COMMENTED BECAUSE OF A BUG (IN COMPILED MODE)
+
   gAlice = (AliRun*)inkin->Get("gAlice");
   cout<<"AliRun object found on file "<<gAlice<<endl;
   AliKalmanTrack::SetFieldMap(gAlice->Field());
index 0b2ed79..fc8aa65 100644 (file)
@@ -1,7 +1,10 @@
+/// \file AliTPCCreatePRF.C
+/// create prf
+/// with given parameters
+
 void AliTPCCreatePRF()
 { 
-  //create prf
-  //with given parameters
+
   TFile *f=TFile::Open("AliTPCprf2d.root","recreate");
   AliTPCPRF2D prf;
   prf.SetPad(0.4,0.75);
index bcf0335..3346bca 100644 (file)
@@ -1,7 +1,10 @@
+/// \file AliTPCCreatePRFGEM.C
+/// create prf
+/// with given parameters
+
 void AliTPCCreatePRFGEM()
 { 
-  //create prf
-  //with given parameters
+
   TFile *f=TFile::Open("AliTPCprf2dGEM.root","recreate");
   AliTPCPRF2D prf;
   prf.SetPad(0.4,0.75);
index e0c9aff..e958461 100644 (file)
@@ -9,8 +9,9 @@
 
 
 void AliTPCDDL(Int_t eventNumber=0, Int_t eth=0){
-  //eth is a threshold.
-  //Digits stored into a file have an amplitude value greater than "eth"
+/// \file AliTPCDDL.C
+/// eth is a threshold.
+/// Digits stored into a file have an amplitude value greater than "eth"
 
   const char * inFile_new = "galice.root";
   AliRunLoader *rl = AliRunLoader::Open(inFile_new,"Event","read");
index b5794d8..cf2df0b 100644 (file)
@@ -4,6 +4,7 @@
 #include "AliTPCCompression.h"
 #endif
 
+/// \file AliTPCDDLRawData.C
 
 void AliTPCDDLRawData(Int_t eventNumber=0, Int_t LDCsNumber=12){
   AliTPCDDLRawData *util=new AliTPCDDLRawData();
@@ -14,9 +15,9 @@ void AliTPCDDLRawData(Int_t eventNumber=0, Int_t LDCsNumber=12){
   util->SetVerbose(1);
   u->SetVerbose(1);  
   
-  //The Altro File "AltroFormatDDL.dat" is built from "AliTPCDDL.dat"
-  //util->RawDataAltro();
-  
+  // The Altro File "AltroFormatDDL.dat" is built from "AliTPCDDL.dat"
+  // util->RawDataAltro();
+
   /*
   //The file "AltroFormatDDL.dat" is converted in a txt file "AltroFormatDDL.txt"
   //that is used for debugging
index 2938ba0..a9124f2 100644 (file)
@@ -1,6 +1,5 @@
-/****************************************************************************
- *           Origin: I.Belikov, CERN, Jouri.Belikov@cern.ch                 *
- ****************************************************************************/
+/// \file AliTPCDisplayDigits.C
+/// \author I.Belikov, CERN, Jouri.Belikov@cern.ch
 
 #ifndef __CINT__
 #include <Riostream.h>
old mode 100755 (executable)
new mode 100644 (file)
index e276710..2de42a1 100644 (file)
@@ -1,6 +1,7 @@
-////////////////////////////////////////////////
-// Dubna, 22 Jan 2003                         //
-////////////////////////////////////////////////
+/// \file AliTPCSavePID.C
+/// 
+/// \author Dubna, 22 Jan 2003
+
 Int_t AliTPCSavePID(Int_t emax=3) {
 ///////////////////////////////////////
 #include<fstream.h>
index 3c2cd44..f15722c 100644 (file)
@@ -1,7 +1,8 @@
-///////////////////////////////////////////////////////////
-// Test macro for AliTPCtracksPid.root file            //
-// JINR Dubna Aug 2002                                   //
-///////////////////////////////////////////////////////////
+/// \file AliTPCScanPID.C
+/// \brief Test macro for AliTPCtracksPid.root file
+///
+/// \author JINR Dubna Aug 2002
+
 void
 AliTPCScanPID(Int_t evNumber2=3) {
   //................. Prepare histogramms ................
index 9dbdb66..1a26192 100644 (file)
@@ -8,41 +8,39 @@
 
 #endif
 
-// Marian Ivanov
-// test of the tpc merging using AliRunDigitizer and 
-// TPC  Hits2Digits, Hits2SDigits and SDigits2Digits macros
-
-// preparation  
-// 0. make 2 directorys - ev1 and ev2
-
-// 1.make hits, digits,sdigits and sdigits-digits in both directories 
-//  1.a  galice -b -q grun.C and produce hits
-//  1.b. cp galice.root galice.root.hits
-//  1.c  run AliTPCHits2Digits.C
-//  1.d  cp galice.root galice.root.digits
-//  1.e  copy back cp galice.root.hits galice.root
-//  1.f  run AliTPCSDigits2Digits.C
-//  1.g  cp galice.root  galice.root.sdigits
-//  1.h  run AliTPCSDigits2Digit.C 
-//  1.i  cp galice.root galice.root.dig2
-
-// 2. cp ev1/galice.root/galice.root.sdigit galice.root
-// 3. load this macro and run testmerge()
-
-// 4. run test function bellow to compare merged digits with original one
-// 5. to be  noticed output ftom testx() function - should be bigger than
-//    noise because in proces of digitisation we use different seed
-//    of random numbers for diffusion and gas gain
-//    -anyway in place where we have the signal should occur the signal in both casses
-//    - only the amplitude should be different - by factor of sqrt
-
+/// \file AliTPCTestMerge.C
+///
+/// test of the tpc merging using AliRunDigitizer and
+/// TPC  Hits2Digits, Hits2SDigits and SDigits2Digits macros
+/// preparation
+/// 0. make 2 directorys - ev1 and ev2
+/// 1.make hits, digits,sdigits and sdigits-digits in both directories
+///  1.a  galice -b -q grun.C and produce hits
+///  1.b. cp galice.root galice.root.hits
+///  1.c  run AliTPCHits2Digits.C
+///  1.d  cp galice.root galice.root.digits
+///  1.e  copy back cp galice.root.hits galice.root
+///  1.f  run AliTPCSDigits2Digits.C
+///  1.g  cp galice.root  galice.root.sdigits
+///  1.h  run AliTPCSDigits2Digit.C
+///  1.i  cp galice.root galice.root.dig2
+/// 2. cp ev1/galice.root/galice.root.sdigit galice.root
+/// 3. load this macro and run testmerge()
+/// 4. run test function bellow to compare merged digits with original one
+/// 5. to be  noticed output ftom testx() function - should be bigger than
+///    noise because in proces of digitisation we use different seed
+///    of random numbers for diffusion and gas gain
+///    -anyway in place where we have the signal should occur the signal in both casses
+///    - only the amplitude should be different - by factor of sqrt
+///
+/// \author Marian Ivanov
       
 void testmerge()
 {
-  // merge two example events
-  //
-  //it merge two events -one from current directory -second from directory ev2
-  
+  /// merge two example events
+  /// 
+  /// it merge two events -one from current directory -second from directory ev2
+
   if(gAlice) delete gAlice;
   AliRunDigitizer * manager = new AliRunDigitizer(2,1);
   manager->SetTreeDTPCBaseName("TreeD_75x40_100x60_150x60_");
@@ -62,9 +60,10 @@ void testmerge()
 
 void drawmerged(Int_t sec, Int_t row, Int_t x1=-1, Int_t x2=-1, Int_t y1=-1, Int_t y2=-1)
 {
-  //if you think that there is memory leak -
-  //you are tru but othervise graphic doesn't work
-  // sec=0; row =0;
+  /// if you think that there is memory leak -
+  /// you are tru but othervise graphic doesn't work
+  /// sec=0; row =0;
+
   TFile * f = new TFile("galice.root");
   TFile * f1= new TFile("ev1/galice.root.digits");
   TFile * f2= new TFile("ev2/galice.root.digits");
@@ -140,8 +139,9 @@ void drawd(TFile * f, Int_t amp1, Int_t amp2)
 }
 
 void test1(){
-  //test of the merged digits
-  //compare merged digits with standard digits
+  /// test of the merged digits
+  /// compare merged digits with standard digits
+
   TFile f("galice.root");
   TFile f1("ev1/galice.root.digits");
   TFile f2("ev2/galice.root.digits");
@@ -180,8 +180,8 @@ void test1(){
 }
 
 void test5(){
-  //
-  //compare merged digits with digits obtained hits2sdig->sdigtodig
+  /// compare merged digits with digits obtained hits2sdig->sdigtodig
+
   TFile f("galice.root");
   TFile f1("ev1/galice.root.dig2");
   TFile f2("ev2/galice.root.dig2");
@@ -225,7 +225,8 @@ void test5(){
 }
 
 void test3(){
-  //test of the merged digits
+  /// test of the merged digits
+
   TFile f("galice.root");
   TFile f1("ev1/galice.root.sdigits");
   TFile f2("ev2/galice.root.sdigits");
@@ -270,8 +271,9 @@ void test3(){
 
 
 void TestSDigitsDig2(){
-  //test of the digits produced by the Hits2Digits 
-  //and Hits2SDigits - SDigits2Digits chain
+  /// test of the digits produced by the Hits2Digits
+  /// and Hits2SDigits - SDigits2Digits chain
+
   TFile f1("galice.root.digits");
   TFile f2("galice.root.dig2");
   //
@@ -323,8 +325,9 @@ void TestSDigitsDig2(){
 }
 
 void TestSDigitsDig1(){
-  //test of the digits produced by the Hits2Digits 
-  //and Hits2SDigits - SDigits2Digits chain
+  /// test of the digits produced by the Hits2Digits
+  /// and Hits2SDigits - SDigits2Digits chain
+
   TFile f1("galice.root.digits");
   TFile f2("galice.root.dig2");
   //
@@ -370,7 +373,8 @@ void TestSDigitsDig1(){
 
 
 void test4(){
-  //TPC internal test
+  /// TPC internal test
+
   TFile f1("galice.root.sdigits");
   TFile f2("galice.root.digits");
   TTree * tree1 = (TTree*)f1.Get("TreeS_75x40_100x60_150x60_0");
index 597cb47..4af245c 100644 (file)
@@ -1,7 +1,7 @@
-//
-// Process ESD tracks  - 
-// Extract TPC tracks  - write them to tree
-//
+/// \file AnalyzeESDtracks.C
+/// 
+/// \brief Process ESD tracks - extract TPC tracks - write them to tree
+
 /*
   .L AnalyzeESDtracks.C+
   .L AliGenInfo.C+
index 9f9cc0d..6cdceb9 100644 (file)
@@ -1,7 +1,12 @@
+/// \file ClassTree.C
+/// \brief Macro generated from canvas: ClassTree
+///
+/// \author ROOT version 2.21/07
+/// \date Tue Jun 1 17:01:38 1999
+
 void ClassTree()
 {
-//=========Macro generated from canvas: ClassTree/
-//=========  (Tue Jun  1 17:01:38 1999) by ROOT version 2.21/07
+
    TCanvas *ClassTree = new TCanvas("ClassTree", "",186,135,594,449);
    ClassTree->SetHighLightColor(2);
    ClassTree->Range(0,5,20,20);
index dda1da4..405d7f6 100644 (file)
@@ -1,8 +1,13 @@
-// One can use the configuration macro in compiled mode by
-// root [0] gSystem->Load("libgeant321");
-// root [0] gSystem->SetIncludePath("-I$ROOTSYS/include -I$ALICE_ROOT/include\
-//                   -I$ALICE_ROOT -I$ALICE/geant3/TGeant3");
-// root [0] .x grun.C(1,"ConfigKr.C++")
+/// \file ConfigKr.C
+///
+/// One can use the configuration macro in compiled mode by
+///
+/// ~~~{.c++}
+/// gSystem->Load("libgeant321");
+/// gSystem->SetIncludePath("-I$ROOTSYS/include -I$ALICE_ROOT/include\
+///                   -I$ALICE_ROOT -I$ALICE/geant3/TGeant3");
+/// .x grun.C(1,"ConfigKr.C++")
+/// ~~~
 
 #if !defined(__CINT__) || defined(__MAKECINT__)
 #include <Riostream.h>
index 39336ad..6d5a4ff 100644 (file)
@@ -1,23 +1,19 @@
-
-/****************************************************************************
- *           Origin: A.Matyja amatyja@cern.ch                               *
- ****************************************************************************/
-
-/*
-
-  macro to create array of clusters from TPC digits
-  input files - galice.root 
-                digits.root - file with digits - usualy use link to galice.root
-                           - in splitted mode - neccesary to create link to proper file
-                           
-   output file - TPC.RecPoints.root
-
-
-//  Warning - if cluster file AliTPCclusters.root already exist - macro exit and don't produce anything
-              
-*/
-
+/// \file FindKrClusters.C
+/// \brief Macro to create array of clusters from TPC digits
+///
+/// Input files:
+///
+/// * galice.root 
+/// * digits.root: file with digits - usualy use link to galice.root
+///   in splitted mode - neccesary to create link to proper file
+///
+/// Output file:
+///
+/// * TPC.RecPoints.root
+///
+/// Warning - if cluster file AliTPCclusters.root already exist - macro exit and don't produce anything
+///
+/// \author A.Matyja amatyja@cern.ch
 
 #ifndef __CINT__
 #include <iostream.h>
index e9479d4..2942111 100644 (file)
@@ -1,4 +1,4 @@
-//
+/// \file FindKrClustersRaw.C
 
 Int_t FindKrClusterCheck(const char *fileName="data.root");
 
index 4b9c638..9da6f4f 100644 (file)
@@ -12,8 +12,9 @@ class TLandauMean: public TObject {
 public:
   void Init(Int_t n, Float_t mean, Float_t sigma);  // initial parameters
   void Gener();          // gener sample 
-  //  void Anal();
-  //
+
+  // void Anal();
+
   Int_t fNSample;      // number of samples
   Float_t fLMean;        // landau mean
   Float_t fLSigma;       // landau sigma
@@ -38,8 +39,8 @@ ClassImp(TLandauMean)
 
 void TLandauMean::Init(Int_t n, Float_t mean, Float_t sigma)
 {
-  //
-  //init parameters
+  /// init parameters
+
   fNSample = n;
   fLMean   = mean;
   fLSigma  = sigma;
@@ -69,8 +70,8 @@ Float_t TLandauMean::Moment3(Float_t sumi1, Float_t sumi2, Float_t sumi3, Int_t
 
 void TLandauMean::Gener()
 {
-  // 
-  // generate sample
+  /// generate sample
+
   Float_t * buffer = new Float_t[fNSample];
   
   for (Int_t i=0;i<fNSample;i++) {
index 464acc8..7dc3521 100644 (file)
@@ -1,7 +1,9 @@
-void MakeTPCAltroMapping(){
-  // Create TObjArray of TPC altro mapping objects and
-  // store it in the CDB
-  //
+/// \file MakeTPCAltroMapping.C
+///
+/// \brief Create TObjArray of TPC altro mapping objects and store it in the CDB
+
+void MakeTPCAltroMapping() {
+
   const char* macroname = "MakeTPCAltroMapping.C";
 
   TObjArray mappingsArray(6);
index 6d01a79..353a6e2 100644 (file)
@@ -1,6 +1,8 @@
+/// \file MakeTPCFullMisAlignment.C
+/// \brief Create TClonesArray of full misalignment objects for TPC
+
 void MakeTPCFullMisAlignment(){
-  // Create TClonesArray of full misalignment objects for TPC
-  //
+
   const char* macroname = "MakeTPCFullMisAlignment.C";
   // Activate CDB storage and load geometry from CDB
   AliCDBManager* cdb = AliCDBManager::Instance();
index 2462b0d..b622894 100644 (file)
@@ -1,6 +1,8 @@
-void MakeTPCResMisAlignment(){
-  // Create TClonesArray of residual misalignment objects for TPC
-  //
+/// \file MakeTPCResMisAlignment.C
+/// \brief Create TClonesArray of residual misalignment objects for TPC
+
+void MakeTPCResMisAlignment() {
+
   const char* macroname = "MakeTPCResMisAlignment.C";
 
   // Activate CDB storage and load geometry from CDB
index 9661b4c..2ab6978 100644 (file)
@@ -1,6 +1,8 @@
+/// \file MakeTPCZeroMisAlignment.C
+/// \brief Create TClonesArray of zero misalignment objects for TPC
+
 void MakeTPCZeroMisAlignment(){
-  // Create TClonesArray of zero misalignment objects for TPC
-  //
+
   const char* macroname = "MakeTPCZeroMisAlignment.C";
 
   TClonesArray *array = new TClonesArray("AliAlignObjParams",100);
index baca15e..57b4f00 100644 (file)
@@ -1,6 +1,7 @@
-AliTPCParam *SetTPCParamOptional(){
+/// \file SetTPCParamOptional.C
+/// \brief Optional set of parameters
 
-  // optional set of parameters
+AliTPCParam *SetTPCParamOptional(){
 
   AliTPCParam *par=new AliTPCParamSR;
   par->SetTitle("optional"); //This is a dummy code ! Just to change something
index dab0215..513786a 100644 (file)
@@ -1,10 +1,12 @@
-/*
- .L AliGenInfo.C+
- .L TestAnalisys.C+
- AddChains(868);    // AddChains(runNumber);
-  Select();          // make default selection of data
-  MakePictures("pic868");
-*/
+/// \file TestAnalisys.C
+///
+/// ~~~{.cxx}
+/// .L AliGenInfo.C+
+/// .L TestAnalisys.C+
+/// AddChains(868);    // AddChains(runNumber);
+///  Select();          // make default selection of data
+///  MakePictures("pic868");
+/// ~~~
 
 #include "TFile.h"
 #include "TTree.h"
@@ -49,7 +51,7 @@ void P3Z(TCut cut0, TCut cut1,  char * description);
 void ResYZ(TCut cut0, TCut cut1,  char * description);
 void SysYX(TCut cut0,  char * description);
 void SysZX(TCut cut0,  char * description);
-//
+
 TProfile * ProfileMaxRow(TCut cut0, char *name, Int_t max);
 TProfile * ProfileMaxPhi(TCut cut0, char *name, Int_t max);
 TProfile * ProfileMaxZ(TCut cut0, char *name, Int_t max);
index de41186..188e8ab 100644 (file)
@@ -1,10 +1,8 @@
-//
-// example macro for reconstruction of the TPC raw data
-//
-// The path to the Calibration parameters is for the moment hard-wired in the code
-// Taken from /afs/
-//
-//
+/// \file recTPC.C
+/// \brief Example macro for reconstruction of the TPC raw data
+/// 
+/// The path to the Calibration parameters is for the moment hard-wired in the code
+/// Taken from /afs
 
 void recTPC(Int_t type, const char *filename="data.root")
 {