Corrections to obey the coding conventions
authorhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 4 Mar 2003 08:27:17 +0000 (08:27 +0000)
committerhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 4 Mar 2003 08:27:17 +0000 (08:27 +0000)
34 files changed:
STEER/AliConfig.cxx
STEER/AliDebugVolume.cxx
STEER/AliDigit.cxx
STEER/AliDigit.h
STEER/AliDigitNew.cxx
STEER/AliDigitizer.cxx
STEER/AliDigitizer.h
STEER/AliESD.h
STEER/AliFieldMap.cxx
STEER/AliFieldMap.h
STEER/AliGausCorr.cxx
STEER/AliGenEventHeader.cxx
STEER/AliGenerator.cxx
STEER/AliHeader.cxx
STEER/AliHeader.h
STEER/AliHit.cxx
STEER/AliKalmanTrack.cxx
STEER/AliKalmanTrack.h
STEER/AliLegoGenerator.cxx
STEER/AliLegoGeneratorEta.cxx
STEER/AliLegoGeneratorPhiZ.cxx
STEER/AliLegoGeneratorXYZ.cxx
STEER/AliMCQA.h
STEER/AliMagF.cxx
STEER/AliMagFC.cxx
STEER/AliMagFCM.cxx
STEER/AliMagFCM.h
STEER/AliMagFDM.cxx
STEER/AliMagFMaps.cxx
STEER/AliMergeCombi.cxx
STEER/AliPoints.cxx
STEER/AliPoints.h
STEER/AliStack.cxx
STEER/AliStack.h

index 798826a..933c934 100644 (file)
 
 /* $Id$ */
 
+// Class for configuration of TFolder and TTasks
+// in AliRoot. Used by AliRun, AliGenerator, 
+// AliModule and AliDetector classes
+// as well as by the PHOS and EMCAL Getters
+// Author: Originally developed by the PHOS group
+
 #include <Riostream.h>
 #include <TDatabasePDG.h>
 #include <TFolder.h>
@@ -217,6 +223,7 @@ AliConfig::AliConfig(const char *name, const char *title):
 //____________________________________________________________________________
 AliConfig::~AliConfig()
 { 
+  // destructor
   delete [] fDetectorFolder ;  
   delete fDetectorTask ;  
   delete fTopFolder ; 
@@ -225,6 +232,7 @@ AliConfig::~AliConfig()
 //____________________________________________________________________________
 void AliConfig::AddInFolder (const char *dir, TObject *obj)
 {
+  // Adds an object "obj" to a folder named "dir"
   TFolder *folder =
     dynamic_cast<TFolder *>(fTopFolder->FindObject(dir));
   if (folder)
@@ -234,6 +242,8 @@ void AliConfig::AddInFolder (const char *dir, TObject *obj)
 //____________________________________________________________________________
 void    AliConfig::AddSubFolder(const char * dir[], TObject *obj)
 {
+  // Adds a subfolder taken from "obj" to all the folders from dir,
+  // which are found in the top folder
   int iDir = 0;
   
   while (dir[iDir]) 
@@ -250,6 +260,8 @@ void    AliConfig::AddSubFolder(const char * dir[], TObject *obj)
 //____________________________________________________________________________
 void    AliConfig::AddSubTask(const char * dir[], TObject *obj)
 {
+  // Adds a subtask taken from "obj" to all the folders from dir,
+  // which are found in the top folder
   int iDir = 0;
   
   while (dir[iDir]) 
@@ -268,6 +280,8 @@ void    AliConfig::AddSubTask(const char * dir[], TObject *obj)
 //____________________________________________________________________________
 TObject* AliConfig::FindInFolder (const char *dir, const char *name)
 {
+  // Searches for object with "name" in the top directory and in
+  // the directory "dir"
   if(!name) return(fTopFolder->FindObject(name));
   TFolder * folder = dynamic_cast<TFolder *>(fTopFolder->FindObject(dir));
   if (!folder) return (NULL);
@@ -277,30 +291,36 @@ TObject* AliConfig::FindInFolder (const char *dir, const char *name)
 //____________________________________________________________________________
 void    AliConfig::Add (AliGenerator * obj)
 {
+  // Adds new AliGenerator to the generator's folder
   AddInFolder(fGeneratorFolder, obj);
 }
 
 //____________________________________________________________________________
 void    AliConfig::Add (TVirtualMC * obj)
 {
+  // Adds new object of type TVirtualMC to the MC folder
   AddInFolder(fMCFolder, obj);
 }
 
 //____________________________________________________________________________
 void    AliConfig::Add (TDatabasePDG * obj)
 {
+  // Adds new TDatabasePDG to the PDG folder
   AddInFolder(fPDGFolder, obj);
 }
 
 //____________________________________________________________________________
 void    AliConfig::Add (AliModule* obj)
 {
+  // Adds new module to the folder of modules 
   AddInFolder(fModuleFolder, obj);
 }
 
 //____________________________________________________________________________
 void    AliConfig::Add (AliDetector * obj)
 {
+  // Adds new detector to the detctor's folder as well as to
+  // the detector's task
   AddSubFolder(fDetectorFolder, obj); 
   AddSubTask(fDetectorTask, obj);
 }
@@ -309,6 +329,8 @@ void    AliConfig::Add (AliDetector * obj)
 //____________________________________________________________________________
 void    AliConfig::Add (char *list)
 {
+  // Finds in the list of directories all macros named Configure.C 
+  // and Default.C and uses them to configure the setup
   char *path;
   
   const char   *confPath = gSystem->Getenv ("ALICE_CONFIG_PATH");
index 15ee87b..0ead08c 100644 (file)
@@ -16,9 +16,9 @@
 /* $Id$ */
 
 //-----------------------------------------------------------------------
-//
 //    Class to debug entry and exit from a volume
-//
+//    Used by AliLego class
+//    Author: A.Morsch
 //-----------------------------------------------------------------------
 
 
@@ -67,6 +67,8 @@ Bool_t  AliDebugVolume::IsVEqual(const char* name, const Int_t copy) const
 //_______________________________________________________________________
 char*   AliDebugVolume::Status() const
 {
+  // Returns the status of the particle with respect to 
+  // the current volume (Undefined, Entering, Exiting) 
   char* tmp;
   tmp = "Undefined";
   if (fStatus == 1) tmp = "Entering";
index e6d20b3..ac53558 100644 (file)
@@ -16,9 +16,9 @@
 /* $Id$ */
 
 //------------------------------------------------------------------------
-//
 //             Main digit class
-//
+//  Base class for Alice digits
+//  Author:
 //------------------------------------------------------------------------
 
 #include "AliDigit.h"
index d32afa8..9c33568 100644 (file)
@@ -13,9 +13,6 @@
 #include "TObject.h"
 
 class AliDigit : public TObject {
-protected:
-  Int_t     fTracks[3];   //tracks number making this digit (up to 3)
-
 public:
   AliDigit();
   AliDigit(Int_t *track);
@@ -24,6 +21,9 @@ public:
   virtual Int_t GetTrack(Int_t i) const 
   {assert(0<=i&&i<=2); return fTracks[i];}
   
+protected:
+  Int_t     fTracks[3];   //tracks number making this digit (up to 3)
+
   ClassDef(AliDigit,1)  //Base class for all Alice digits
 };
 #endif
index d48fadb..91b3a0c 100644 (file)
@@ -16,9 +16,9 @@
 /* $Id$ */
 
 //-----------------------------------------------------------------------
-//
 //    Proposal for a new digitisation abstract class
-//
+//    Used by EMCAL, PHOS, PMD, TOF digitizers and/or rec. points
+//    Author:
 //-----------------------------------------------------------------------
 
 #include "AliDigitNew.h"
index 07e88f9..6b14fa4 100644 (file)
 
 /* $Id$ */
 
-////////////////////////////////////////////////////////////////////////
-//
+//----------------------------------------------------------------------
 //  Base Class for Detector specific Merging/Digitization   
-//                  
+//  Collaborates with AliRunDigitizer class                
 //  Author: Jiri Chudoba (CERN)
-//
-////////////////////////////////////////////////////////////////////////
+//----------------------------------------------------------------------
 
 
 // system includes
index ae4da8c..05a1a24 100644 (file)
@@ -29,7 +29,7 @@ class AliDigitizer: public TTask {
                 const Text_t* title="AliDigitizer");
 // Copy ctor needed because there is a pointer
     AliDigitizer(const AliDigitizer &dig);
-    AliDigitizer& operator=(AliDigitizer &dig)
+    AliDigitizer& operator=(const AliDigitizer &dig)
       {dig.Copy(*this);return *this;}
       
     virtual ~AliDigitizer();
index 7b5777b..0498a26 100644 (file)
@@ -137,7 +137,7 @@ protected:
   TObjArray    fPMDCluster;             // List of PMD clusters
 
 private:
-  AliESD(const AliESD &);
+  AliESD(const AliESD &esd);
   AliESD & operator=(const AliESD &) {return (*this);}
   
   ClassDef(AliESD,1)  //ESD 
index c2ae56d..1461569 100644 (file)
 /* $Id$ */
 
 //-----------------------------------------------------------------------
-//
+// Class to read the magnetic field map and to calculate
+// the magnetic field in a given point. For the moment uses a simple
+// linear interpolation between the nodes of a rectangular grid
 // Author: Andreas Morsch <andreas.morsch@cern.ch>
-//
 //-----------------------------------------------------------------------
 
 #include <TSystem.h>
@@ -205,61 +206,131 @@ void AliFieldMap::ReadField()
 }
 
 //_______________________________________________________________________
-void AliFieldMap::Field(Float_t *x, Float_t *b)
-{
-  //
-  // Use simple interpolation to obtain field at point x
-  //
-    Double_t ratx, raty, ratz, hix, hiy, hiz, ratx1, raty1, ratz1, 
-       bhyhz, bhylz, blyhz, blylz, bhz, blz, xl[3];
-    const Double_t kone=1;
-    Int_t ix, iy, iz;
-    b[0]=b[1]=b[2]=0;
-    //
+// void AliFieldMap::Field(Float_t *x, Float_t *b)
+// {
+//   //
+//   // Use simple interpolation to obtain field at point x
+//   //
+//     Double_t ratx, raty, ratz, hix, hiy, hiz, ratx1, raty1, ratz1, 
+//     bhyhz, bhylz, blyhz, blylz, bhz, blz, xl[3];
+//     const Double_t kone=1;
+//     Int_t ix, iy, iz;
+//     b[0]=b[1]=b[2]=0;
+//     //
     
-    xl[0]=TMath::Abs(x[0])-fXbeg;
-    xl[1]=TMath::Abs(x[1])-fYbeg;
-    xl[2]=x[2]-fZbeg;
+//     xl[0]=TMath::Abs(x[0])-fXbeg;
+//     xl[1]=TMath::Abs(x[1])-fYbeg;
+//     xl[2]=x[2]-fZbeg;
     
-    hix=xl[0]*fXdeli;
-    ratx=hix-int(hix);
-    ix=int(hix);
+//     hix=xl[0]*fXdeli;
+//     ratx=hix-int(hix);
+//     ix=int(hix);
     
-    hiy=xl[1]*fYdeli;
-    raty=hiy-int(hiy);
-    iy=int(hiy);
+//     hiy=xl[1]*fYdeli;
+//     raty=hiy-int(hiy);
+//     iy=int(hiy);
     
-    hiz=xl[2]*fZdeli;
-    ratz=hiz-int(hiz);
-    iz=int(hiz);
-
-    ratx1=kone-ratx;
-    raty1=kone-raty;
-    ratz1=kone-ratz;
-
-    bhyhz = Bx(ix  ,iy+1,iz+1)*ratx1+Bx(ix+1,iy+1,iz+1)*ratx;
-    bhylz = Bx(ix  ,iy+1,iz  )*ratx1+Bx(ix+1,iy+1,iz  )*ratx;
-    blyhz = Bx(ix  ,iy  ,iz+1)*ratx1+Bx(ix+1,iy  ,iz+1)*ratx;
-    blylz = Bx(ix  ,iy  ,iz  )*ratx1+Bx(ix+1,iy  ,iz  )*ratx;
-    bhz   = blyhz             *raty1+bhyhz             *raty;
-    blz   = blylz             *raty1+bhylz             *raty;
-    b[0]  = blz               *ratz1+bhz               *ratz;
-    //
-    bhyhz = By(ix  ,iy+1,iz+1)*ratx1+By(ix+1,iy+1,iz+1)*ratx;
-    bhylz = By(ix  ,iy+1,iz  )*ratx1+By(ix+1,iy+1,iz  )*ratx;
-    blyhz = By(ix  ,iy  ,iz+1)*ratx1+By(ix+1,iy  ,iz+1)*ratx;
-    blylz = By(ix  ,iy  ,iz  )*ratx1+By(ix+1,iy  ,iz  )*ratx;
-    bhz   = blyhz             *raty1+bhyhz             *raty;
-    blz   = blylz             *raty1+bhylz             *raty;
-    b[1]  = blz               *ratz1+bhz               *ratz;
-    //
-    bhyhz = Bz(ix  ,iy+1,iz+1)*ratx1+Bz(ix+1,iy+1,iz+1)*ratx;
-    bhylz = Bz(ix  ,iy+1,iz  )*ratx1+Bz(ix+1,iy+1,iz  )*ratx;
-    blyhz = Bz(ix  ,iy  ,iz+1)*ratx1+Bz(ix+1,iy  ,iz+1)*ratx;
-    blylz = Bz(ix  ,iy  ,iz  )*ratx1+Bz(ix+1,iy  ,iz  )*ratx;
-    bhz   = blyhz             *raty1+bhyhz             *raty;
-    blz   = blylz             *raty1+bhylz             *raty;
-    b[2]  = blz               *ratz1+bhz               *ratz;
+//     hiz=xl[2]*fZdeli;
+//     ratz=hiz-int(hiz);
+//     iz=int(hiz);
+
+//     ratx1=kone-ratx;
+//     raty1=kone-raty;
+//     ratz1=kone-ratz;
+
+//     bhyhz = Bx(ix  ,iy+1,iz+1)*ratx1+Bx(ix+1,iy+1,iz+1)*ratx;
+//     bhylz = Bx(ix  ,iy+1,iz  )*ratx1+Bx(ix+1,iy+1,iz  )*ratx;
+//     blyhz = Bx(ix  ,iy  ,iz+1)*ratx1+Bx(ix+1,iy  ,iz+1)*ratx;
+//     blylz = Bx(ix  ,iy  ,iz  )*ratx1+Bx(ix+1,iy  ,iz  )*ratx;
+//     bhz   = blyhz             *raty1+bhyhz             *raty;
+//     blz   = blylz             *raty1+bhylz             *raty;
+//     b[0]  = blz               *ratz1+bhz               *ratz;
+//     //
+//     bhyhz = By(ix  ,iy+1,iz+1)*ratx1+By(ix+1,iy+1,iz+1)*ratx;
+//     bhylz = By(ix  ,iy+1,iz  )*ratx1+By(ix+1,iy+1,iz  )*ratx;
+//     blyhz = By(ix  ,iy  ,iz+1)*ratx1+By(ix+1,iy  ,iz+1)*ratx;
+//     blylz = By(ix  ,iy  ,iz  )*ratx1+By(ix+1,iy  ,iz  )*ratx;
+//     bhz   = blyhz             *raty1+bhyhz             *raty;
+//     blz   = blylz             *raty1+bhylz             *raty;
+//     b[1]  = blz               *ratz1+bhz               *ratz;
+//     //
+//     bhyhz = Bz(ix  ,iy+1,iz+1)*ratx1+Bz(ix+1,iy+1,iz+1)*ratx;
+//     bhylz = Bz(ix  ,iy+1,iz  )*ratx1+Bz(ix+1,iy+1,iz  )*ratx;
+//     blyhz = Bz(ix  ,iy  ,iz+1)*ratx1+Bz(ix+1,iy  ,iz+1)*ratx;
+//     blylz = Bz(ix  ,iy  ,iz  )*ratx1+Bz(ix+1,iy  ,iz  )*ratx;
+//     bhz   = blyhz             *raty1+bhyhz             *raty;
+//     blz   = blylz             *raty1+bhylz             *raty;
+//     b[2]  = blz               *ratz1+bhz               *ratz;
+// }
+//_______________________________________________________________________
+void AliFieldMap::Field(Float_t *x, Float_t *b)
+{
+  //
+  // Use simple interpolation to obtain field at point x
+  // Faster version which uses direct access to the TVector
+  // instead of Bx(...), By(...), Bz(...) interfaces.
+  // The interpolation is done first in Z (4 points),
+  // then in Y (2 points), and finally in X direction (one point).
+
+    Double_t h=(x[2]-fZbeg)*fZdeli;
+    Int_t i=int(h); // ix
+    register Int_t index=i;
+    Double_t ratz=h-i;
+    Double_t ratz1=1-ratz;
+
+    h=(TMath::Abs(x[1])-fYbeg)*fYdeli;
+    i=int(h);       // iy
+    index+=(i*fZn);
+    Double_t raty=h-i;
+    Double_t raty1=1-raty;
+
+    h=(TMath::Abs(x[0])-fXbeg)*fXdeli;
+    i=int(h);       // iz
+    index+=(i*fZn*fYn);
+    index*=3; //index now points to the beginning of the field data (ix,iy,iz)
+    Double_t ratx=h-i;
+    Double_t ratx1=1-ratx;
+
+    // The way we retrive data from fB should be optimized 
+    // with respect to the CPU cache
+
+    Float_t bx00=(*fB)[index++]*ratz1;
+    Float_t by00=(*fB)[index++]*ratz1;
+    Float_t bz00=(*fB)[index++]*ratz1;
+    bx00+=(*fB)[index++]*ratz;
+    by00+=(*fB)[index++]*ratz;
+    bz00+=(*fB)[index]*ratz;
+
+    index+=(3*fZn-5);
+
+    Float_t bx01=(*fB)[index++]*ratz1;
+    Float_t by01=(*fB)[index++]*ratz1;
+    Float_t bz01=(*fB)[index++]*ratz1;
+    bx01+=(*fB)[index++]*ratz;
+    by01+=(*fB)[index++]*ratz;
+    bz01+=(*fB)[index]*ratz;
+
+    index+=(3*fYn*fZn-5);
+
+    Float_t bx11=(*fB)[index++]*ratz1;
+    Float_t by11=(*fB)[index++]*ratz1;
+    Float_t bz11=(*fB)[index++]*ratz1;
+    bx11+=(*fB)[index++]*ratz;
+    by11+=(*fB)[index++]*ratz;
+    bz11+=(*fB)[index]*ratz;
+
+    index-=(3*fZn+5);
+
+    Float_t bx10=(*fB)[index++]*ratz1;
+    Float_t by10=(*fB)[index++]*ratz1;
+    Float_t bz10=(*fB)[index++]*ratz1;
+    bx10+=(*fB)[index++]*ratz;
+    by10+=(*fB)[index++]*ratz;
+    bz10+=(*fB)[index]*ratz;
+
+    b[0]= (bx00*raty1+bx01*raty)*ratx1 +(bx10*raty1+bx11*raty)*ratx;
+    b[1]= (by00*raty1+by01*raty)*ratx1 +(by10*raty1+by11*raty)*ratx;
+    b[2]= (bz00*raty1+bz01*raty)*ratx1 +(bz10*raty1+bz11*raty)*ratx;
 }
 
 //_______________________________________________________________________
index 24adf72..832a4ec 100644 (file)
@@ -24,14 +24,14 @@ public:
     virtual AliFieldMap & operator=(const AliFieldMap &map);
 
     virtual void Field(Float_t *x, Float_t *b);
-    Float_t Bx(const Int_t ix, const Int_t iy, const Int_t iz) {
-       return (*fB)(3*(ix*(fZn*fYn)+iy*fZn+iz));
+    Float_t Bx(const Int_t ix, const Int_t iy, const Int_t iz) const{
+       return (*fB)(3*((ix*fYn+iy)*fZn+iz));
     }
-    Float_t By(const Int_t ix, const Int_t iy, const Int_t iz) {
-       return (*fB)(3*(ix*(fZn*fYn)+iy*fZn+iz)+1);
+    Float_t By(const Int_t ix, const Int_t iy, const Int_t iz) const{
+       return (*fB)(3*((ix*fYn+iy)*fZn+iz)+1);
     }
-    Float_t Bz(const Int_t ix, const Int_t iy, const Int_t iz) {
-       return (*fB)(3*(ix*(fZn*fYn)+iy*fZn+iz)+2);
+    Float_t Bz(const Int_t ix, const Int_t iy, const Int_t iz) const{
+       return (*fB)(3*((ix*fYn+iy)*fZn+iz)+2);
     }
 
     Bool_t Inside(Float_t x, Float_t y, Float_t z) const
index a269644..f1813de 100644 (file)
@@ -133,6 +133,7 @@ void AliGausCorr::PrintCv() const
 //_______________________________________________________________________
 AliGausCorr & AliGausCorr::operator=(const AliGausCorr & tgcorr)
 {
+  // Assignment operator
   if(&tgcorr != this && tgcorr.fSize!=fSize){
     if(fCv)delete fCv;
     fSize = tgcorr.fSize;
index eae176e..16a7eca 100644 (file)
 
 /* $Id$ */
 
+//---------------------------------------------------------------------
 // Event header base class for generator. 
 // Stores as a minimum the date, run number, event number,
 // number of particles produced  
 // and the impact parameter.
-// 
 // Author: andreas.morsch@cern.ch
+//---------------------------------------------------------------------
 
 #include "AliGenEventHeader.h"
 ClassImp(AliGenEventHeader)
index 1c17326..2ef0d76 100644 (file)
 
 /* $Id$ */
 
-///////////////////////////////////////////////////////////////////
-//                                                               //
-//    Generate the final state of the interaction as the input   //
-//    to the MonteCarlo                                          //
-//
+//-----------------------------------------------------------------
+//    Generate the final state of the interaction as the input
+//    to the MonteCarlo
+//    Author: A.Morsch
+//-----------------------------------------------------------------
 //Begin_Html
 /*
 <img src="picts/AliGeneratorClass.gif">
index 9ebf8ed..a78907c 100644 (file)
 /* $Id$ */
 
 //-----------------------------------------------------------------------
-//
 //     Simulation event header class
-//
+//     Collaborates with AliRun, AliStack, and AliGenReaderTreeK classes
+//     Many other classes depend on it
+//     Author:
 //-----------------------------------------------------------------------
 
 #include <stdio.h>
index d5edccd..62d1a47 100644 (file)
@@ -48,7 +48,7 @@ public:
 
   virtual void Print(const char *opt=0) const;
 
-  AliHeader& operator=(AliHeader& head) 
+  AliHeader& operator=(const AliHeader& head) 
     {head.Copy(*this); return *this;}
   
 protected:
index 60cc4ef..9517767 100644 (file)
 /* $Id$ */
 
 //-----------------------------------------------------------------------
-//
 //    Base Hit class for all detectors
-//
+//    Contains the coordinates of the hit (single energy deposition)
+//    and the number of correspondent track
+//    Author:
 //-----------------------------------------------------------------------
 
 #include "TParticle.h"
index 6c983b5..5b1a85f 100644 (file)
@@ -81,7 +81,7 @@ void AliKalmanTrack::StartTimeIntegral()
   //  Warning("StartTimeIntegral", "Reseting Recorded Time.");
 
   fStartTimeIntegral = kTRUE;
-  for(Int_t i=0; i<fTypes; i++) fIntegratedTime[i] = 0;  
+  for(Int_t i=0; i<fgkTypes; i++) fIntegratedTime[i] = 0;  
   fIntegratedLength = 0;
 }
 //_______________________________________________________________________
@@ -107,13 +107,13 @@ void AliKalmanTrack:: AddTimeStep(Double_t length)
   // S.Radomski@gsi.de
   // 
   
-  static const Double_t cc = 2.99792458e-2;
+  static const Double_t kcc = 2.99792458e-2;
 
   if (!fStartTimeIntegral) return;
   
   fIntegratedLength += length;
 
-  static Int_t pdgCode[fTypes]  = {kElectron, kMuonMinus, kPiPlus, kKPlus, kProton};
+  static Int_t pdgCode[fgkTypes]  = {kElectron, kMuonMinus, kPiPlus, kKPlus, kProton};
   TDatabasePDG *db = TDatabasePDG::Instance();
 
   Double_t xr, param[5];
@@ -127,11 +127,11 @@ void AliKalmanTrack:: AddTimeStep(Double_t length)
 
   if (length > 100) return;
 
-  for (Int_t i=0; i<fTypes; i++) {
+  for (Int_t i=0; i<fgkTypes; i++) {
     
     Double_t mass = db->GetParticle(pdgCode[i])->Mass();
     Double_t correction = TMath::Sqrt( pt*pt * (1 + tgl*tgl) + mass * mass ) / p;
-    Double_t time = length * correction / cc;
+    Double_t time = length * correction / kcc;
 
     //cout << mass << "\t" << pt << "\t" << p << "\t" 
     //     << correction << endl;
@@ -158,9 +158,9 @@ Double_t AliKalmanTrack::GetIntegratedTime(Int_t pdg) const
     return 0.;
   }
 
-  static Int_t pdgCode[fTypes] = {kElectron, kMuonMinus, kPiPlus, kKPlus, kProton};
+  static Int_t pdgCode[fgkTypes] = {kElectron, kMuonMinus, kPiPlus, kKPlus, kProton};
 
-  for (Int_t i=0; i<fTypes; i++)
+  for (Int_t i=0; i<fgkTypes; i++)
     if (pdgCode[i] == TMath::Abs(pdg)) return fIntegratedTime[i];
 
   Warning(":GetIntegratedTime","Particle type [%d] not found", pdg);
@@ -174,9 +174,9 @@ void AliKalmanTrack::PrintTime() const
   // Prints time for all hypothesis
   //
 
-  static Int_t pdgCode[fTypes] = {kElectron, kMuonMinus, kPiPlus, kKPlus, kProton};
+  static Int_t pdgCode[fgkTypes] = {kElectron, kMuonMinus, kPiPlus, kKPlus, kProton};
 
-  for (Int_t i=0; i<fTypes; i++)
+  for (Int_t i=0; i<fgkTypes; i++)
     printf("%d: %.2f  ", pdgCode[i], fIntegratedTime[i]);
   printf("\n");  
 }
index e4f8a4e..875d496 100644 (file)
@@ -75,10 +75,10 @@ private:
   static Double_t fgConvConst; //conversion constant cm -> GeV/c
 
   // variables for time integration
-  static const Int_t fTypes = 5; 
+  static const Int_t fgkTypes = 5;  // Number of track types (e,mu,pi,k,p)
   Bool_t  fStartTimeIntegral;       // indicator wether integrate time
   Float_t fIntegratedTime[5];       // intgrated time
-  Float_t fIntegratedLength;
+  Float_t fIntegratedLength;        // integrated length
   
   ClassDef(AliKalmanTrack,2)    // Reconstructed track
 };
index 3f0bf4c..e8f3fbe 100644 (file)
 /* $Id$ */
 
 //------------------------------------------------------------------------
-//
 //        Generic Lego generator code
-//
+//    Uses geantino rays to check the material distributions and detector's
+//    geometry
+//    Author: A.Morsch
 //------------------------------------------------------------------------
 
 #include "AliLegoGenerator.h"
index 3de42d5..680c8a1 100644 (file)
 /* $Id$ */
 
 //------------------------------------------------------------------------
-//
 //    Lego generator in Eta bins
-//
+//    Uses geantino rays to check the material distributions and detector's
+//    geometry
+//    Author: A.Morsch 
 //------------------------------------------------------------------------
 
 #include "AliLegoGeneratorEta.h"
index 360aa05..2c2089e 100644 (file)
 /* $Id$ */
 
 //-------------------------------------------------------------------------
-//
 //    Lego generator in Phi - Z bins
-//
+//    Uses geantino rays to check the material distributions and detector's
+//    geometry
+//    Author: A.Morsch 
 //-------------------------------------------------------------------------
 
 #include "AliLegoGeneratorPhiZ.h"
index 773f0b1..1ad9748 100644 (file)
 /* $Id$ */
 
 //-------------------------------------------------------------------------
-//
 //      Lego generator in x - y - z bins
-//
+//    Uses geantino rays to check the material distributions and detector's
+//    geometry
+//    Author: A.Morsch 
 //-------------------------------------------------------------------------
 
 #include "AliLegoGeneratorXYZ.h"
index 8612681..b57d309 100644 (file)
@@ -21,7 +21,7 @@ class AliMCQA : public TObject
 public:
   AliMCQA();
   AliMCQA(Int_t ndets);
-  AliMCQA(const AliMCQA &);
+  AliMCQA(const AliMCQA &qa);
   virtual ~AliMCQA();
   Bool_t  IsFolder() const {return kTRUE;}
   virtual  void  Browse(TBrowser *b);
index 5ff82e6..ed35cdb 100644 (file)
 
 /* $Id$ */
 
-//
+//----------------------------------------------------------------------
 // Basic magnetic field class
-//
+// Used in all the detectors, and also in the traking classes
+// Author:
+//----------------------------------------------------------------------
 
 #include "AliMagF.h"
 
index fa2ebb9..83f3ba4 100644 (file)
@@ -16,9 +16,9 @@
 /* $Id$ */
 
 //-------------------------------------------------------------------------
-//
 //     Constant magnetic field class
-//
+//     Used by AliRun class
+//     Author:
 //-------------------------------------------------------------------------
 
 #include <stdlib.h>
index bd9f22a..56609ff 100644 (file)
 
 /* $Id$ */
 
+//-----------------------------------------------------------------------
+//  Class for Alice magnetic field with constant mesh
+//  Used in the configuration macros (macros/Config.C, etc.)
+//  Author:
+//-----------------------------------------------------------------------
 #include "TSystem.h"
 #include "TVector.h"
 
index 4683d01..5d0b0e7 100644 (file)
@@ -10,7 +10,7 @@ class TVector;
 
 class AliMagFCM : public AliMagF
 {
-  //Alice Magnetic Field with constan mesh
+  //Alice Magnetic Field with constant mesh
 
 public:
   AliMagFCM();
index 88067e5..ecee137 100644 (file)
@@ -16,9 +16,9 @@
 /* $Id$ */
 
 //-------------------------------------------------------------------------
-//
 //   Field with Magnetic Field map
-//
+//   Used by AliRun class
+//   Author:
 //-------------------------------------------------------------------------
 
 #include <stdlib.h>
index bf25be9..e0ec5ca 100644 (file)
 
 /* $Id$ */
 
-//
+//------------------------------------------------------------------------
+// Magnetic field composed by 3 maps: the L3 magnet, extended region, and
+// dipole magnet
+// Used in the configuration macros (macros/Config.C, etc.)
 // Author: Andreas Morsch <andreas.morsch@cern.ch>
-//
+//------------------------------------------------------------------------
 
 #include <TFile.h>
 #include <TSystem.h>
index 16f5dbd..a678798 100644 (file)
 
 /* $Id$ */
 
-////////////////////////////////////////////////////////////////////////
-//
+//----------------------------------------------------------------------
 // AliMergeCombi.cxx
 // class to
 // return combinations of input event numbers
-//
-////////////////////////////////////////////////////////////////////////
+//----------------------------------------------------------------------
 
 #include "AliMergeCombi.h"
 
index 16afce3..4212493 100644 (file)
@@ -179,7 +179,7 @@ TParticle *AliPoints::GetParticle() const
 }
 
 //_______________________________________________________________________
-void AliPoints::InspectParticle()
+void AliPoints::InspectParticle() const
 {
   //
   //   Inspect particle corresponding to this point
index 74e883f..5b1dc4d 100644 (file)
@@ -21,7 +21,7 @@ public:
   Int_t                 GetIndex() const {return fIndex;}
   TParticle            *GetParticle() const;
   virtual const Text_t *GetName() const;
-  virtual void          InspectParticle(); // *MENU*
+  virtual void          InspectParticle() const; // *MENU*
   virtual void          DumpParticle() const; // *MENU*
   virtual Text_t       *GetObjectInfo(Int_t px, Int_t py) const;
   AliPoints &           operator=(const AliPoints &pts)
index ddf2a04..529ccc3 100644 (file)
@@ -446,6 +446,7 @@ void AliStack::PurifyKine()
    //   delete [] map;
 }
 
+//_____________________________________________________________________________
 Bool_t AliStack::KeepPhysics(TParticle* part)
 {
     //
@@ -663,6 +664,23 @@ Int_t AliStack::TreeKEntry(Int_t id) const
 }
 
 //_____________________________________________________________________________
+Int_t AliStack::CurrentTrackParent() const
+{
+  //
+  // Return number of the parent of the current track
+  //
+  
+  TParticle* current = (TParticle*)fParticleMap->At(fCurrent);
+
+  if (current) 
+    return current->GetFirstMother();
+  else {
+    Warning("CurrentTrackParent", "Current track not found in the stack");
+    return -1;
+  }  
+}
+//_____________________________________________________________________________
 Int_t AliStack::GetPrimary(Int_t id)
 {
   //
@@ -856,6 +874,7 @@ void AliStack::FinishRun()
     }
 }
 
+//_____________________________________________________________________________
 Bool_t AliStack::GetEvent(Int_t event)
 {
 //
index fc2f419..c9bc535 100644 (file)
@@ -61,6 +61,7 @@ class AliStack : public TVirtualMCStack
     virtual Int_t GetNtrack() const;
     Int_t       GetNprimary() const;
     virtual Int_t CurrentTrack() const;
+    virtual Int_t CurrentTrackParent() const;
     TObjArray*  Particles() const;
     TParticle*  Particle(Int_t id);
     Int_t       GetPrimary(Int_t id);