Coding conventions.
authorloizides <loizides@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sat, 26 Jun 2004 11:39:40 +0000 (11:39 +0000)
committerloizides <loizides@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sat, 26 Jun 2004 11:39:40 +0000 (11:39 +0000)
HLT/src/AliL3Benchmark.cxx
HLT/src/AliL3Benchmark.h
HLT/src/AliL3Fitter.cxx
HLT/src/AliL3Fitter.h
HLT/src/AliL3MemHandler.cxx
HLT/src/AliL3MemHandler.h

index 90612e0ebc24a3dcdb6a5a204341f1ddad70b311..0e52975368f4b97ca648028dd59458382b6deabe 100644 (file)
@@ -3,19 +3,6 @@
 // Author: Uli Frankenfeld <mailto:franken@fi.uib.no>
 //*-- Copyright &copy ALICE HLT Group
 
-#include "AliL3StandardIncludes.h"
-
-#ifndef no_root
-#include <TFile.h>
-#include <TGraphAsymmErrors.h>
-#include <TString.h>
-#include <TStopwatch.h>
-#include <TMath.h>
-#endif
-
-#include "AliL3Logging.h"
-#include "AliL3Benchmark.h"
-
 /** \class AliL3Benchmark
 </pre>
 //_____________________________________________________________
 </pre>
 */
 
+#ifndef no_root
+#include <TFile.h>
+#include <TGraphAsymmErrors.h>
+#include <TString.h>
+#include <TStopwatch.h>
+#include <TMath.h>
+#endif
+#include "AliL3StandardIncludes.h"
+#include "AliL3RootTypes.h"
+#include "AliL3Logging.h"
+#include "AliL3Benchmark.h"
+
 ClassImp(AliL3Benchmark)
+
 AliL3Benchmark::AliL3Benchmark()
 {
   //Constructor
-
   fNbench = 0;
   fNmax   = 20;
   fNames  = 0;
@@ -41,11 +40,11 @@ AliL3Benchmark::AliL3Benchmark()
   fMin    = 0;
   fMax    = 0;
   fCount  = 0;
-  //fStopwatch = 0;
 }
 
 AliL3Benchmark::~AliL3Benchmark()
 {
+  //deconstructor
    fNbench   = 0;
    if (fNames)  {delete [] fNames; fNames  = 0;}
    if (fTimer)  {delete [] fTimer; fTimer  = 0;}
@@ -53,20 +52,21 @@ AliL3Benchmark::~AliL3Benchmark()
    if (fMin)    {delete [] fMin;   fMin   = 0;}
    if (fMax)    {delete [] fMax;   fMax   = 0;}
    if (fCount)  {delete [] fCount; fCount =0;}
-   //if(fStopwatch) {delete fStopwatch; fStopwatch =0;}
 }
 
-Int_t AliL3Benchmark::GetBench(const char *name)
+Int_t AliL3Benchmark::GetBench(const Char_t *name)
 {
+  //get bench with name
    for (Int_t i=0;i<fNbench;i++) {
-      if (!strcmp(name,(const char*)fNames[i])) return i;
+      if (!strcmp(name,(const Char_t*)fNames[i])) return i;
    }
    return -1;
 }
 
 
-void AliL3Benchmark::Start(const char *name)
+void AliL3Benchmark::Start(const Char_t *name)
 {
+  //start the benchmark with name
    if (!fNbench) {
 #ifdef no_root
      fNames=new Char_t*[fNmax];
@@ -100,18 +100,10 @@ void AliL3Benchmark::Start(const char *name)
       fNbench++;
       fTimer[bench].Reset();
       fTimer[bench].Start();
-      //if(fStopwatch) {delete fStopwatch; fStopwatch =0;}
-      //fStopwatch = new TStopwatch();
-      //fStopwatch->Reset();
-      //fStopwatch->Start();
    } else if (bench >=0) {
    // Resume the existent benchmark
       fTimer[bench].Reset();
       fTimer[bench].Start();
-      //if(fStopwatch) {delete fStopwatch; fStopwatch =0;}
-      //fStopwatch = new TStopwatch();
-      //fStopwatch->Reset();
-      //fStopwatch->Start();
    }
    else
      LOG(AliL3Log::kWarning,"AliL3Benchmark::Start","Start")
@@ -120,13 +112,12 @@ void AliL3Benchmark::Start(const char *name)
 
 void AliL3Benchmark::Stop(const char *name)
 {
+  //stop the benchmark with name
    Int_t bench = GetBench(name);
    if (bench < 0) return;
 
    fTimer[bench].Stop();
    Float_t val = fTimer[bench].CpuTime();
-   //fStopwatch->Stop();
-   //Float_t val = fStopwatch->CpuTime();
    
    fSum[bench] += val; 
    fCount[bench]++;
@@ -140,12 +131,14 @@ void AliL3Benchmark::Stop(const char *name)
    }
 }
 
-void AliL3Benchmark::Analyze(const Char_t* name){
+void AliL3Benchmark::Analyze(const Char_t* name)
+{
+  //get results of benchmark
   Float_t *x = new Float_t[fNbench]; 
   Float_t *y = new Float_t[fNbench];
   Float_t *eyl = new Float_t[fNbench]; 
   Float_t *eyh = new Float_t[fNbench];
-  char filename[256];
+  Char_t filename[256];
   sprintf(filename,"%s.dat",name);
   FILE *f= fopen(filename,"w");
   for (Int_t i=0;i<fNbench;i++) {
@@ -193,5 +186,6 @@ void AliL3Benchmark::Analyze(const Char_t* name){
 
 Double_t AliL3Benchmark::GetCpuTime()
 {
+  //get cpu time
   {return (Double_t)(clock()) / CLOCKS_PER_SEC;}
 }
index 10328b78b50437370cfcb4d1b16af1e8696ef171..43a380ded3430bdbfa10be7ec0eb6b4a33d098c9 100644 (file)
@@ -1,19 +1,35 @@
 // @(#) $Id$
 
-#ifndef AliL3_Benchmark
-#define AliL3_Benchmark
+#ifndef AliL3BenchmarkH
+#define AliL3BenchmarkH
+
+//_____________________________________________________________
+//
+// AliL3Benchmark
+//
+//   Benchmark class for level3 code
+//  
+//
 
 #ifndef no_root
-#include <Rtypes.h>
 class TStopwatch;
 class TString;
 #else
-#include "AliL3RootTypes.h"
-#include "AliL3Stopwatch.h"
+class  AliL3Stopwatch;
 #endif
 
 class AliL3Benchmark {
 
+public:
+   AliL3Benchmark();
+   virtual ~AliL3Benchmark();
+   Int_t      GetBench(const char *name);
+   void       Start(const char *name);
+   void       Stop(const char *name);
+   void       Analyze(const char* name);
+   
+   static Double_t GetCpuTime();
+
 private:
 
    Int_t      fNbench;          //Number of active benchmarks
@@ -22,25 +38,14 @@ private:
    TString    *fNames;          //Names of benchmarks
    TStopwatch *fTimer;          //Timers
 #else
-   Char_t **fNames;
-   AliL3Stopwatch *fTimer;
+   Char_t **fNames;             //Names of benchmarks
+   AliL3Stopwatch *fTimer;      //Timers
 #endif
-   Float_t    *fSum;
-   Float_t    *fMin;
-   Float_t    *fMax;
-   Int_t      *fCount;
-   //TStopwatch *fStopwatch;    //Stopwatch
+   Float_t    *fSum;  //sum of time
+   Float_t    *fMin;  //min of time
+   Float_t    *fMax;  //max of time
+   Int_t      *fCount;// counter
 
-public:
-   AliL3Benchmark();
-   virtual ~AliL3Benchmark();
-   Int_t      GetBench(const char *name);
-   void       Start(const char *name);
-   void       Stop(const char *name);
-   void       Analyze(const char* name);
-   
-   static Double_t GetCpuTime();
-   
    ClassDef(AliL3Benchmark,0)  //L3 benchmark
 };
 
index 27566bc32079a9261fd2961c4cb2810e51615228..7326bf796396f8d49843ab6e6be132f72e546a10 100644 (file)
@@ -3,6 +3,15 @@
 // Author: Anders Vestbo <mailto:vestbo@fi.uib.no>
 //*-- Copyright &copy ALICE HLT Group 
 
+/** \class AliL3Fitter
+<pre>
+//_____________________________________________________________
+// AliL3Fitter
+//
+// Fit class HLT for helix
+</pre>
+*/
+
 #include "AliL3StandardIncludes.h"
 #include <math.h>
 
 #include "AliL3Transform.h"
 #include "AliLevel3.h"
 
-/** \class AliL3Fitter
-<pre>
-//_____________________________________________________________
-// AliL3Fitter
-//
-// Fit class HLT
-</pre>
-*/
 
 ClassImp(AliL3Fitter)
 
 
 AliL3Fitter::AliL3Fitter()
 {
+  //constructor
   fTrack=0;
   fVertex=0;
   memset(fClusters,0,36*6*sizeof(AliL3SpacePointData*));
@@ -45,6 +47,7 @@ AliL3Fitter::AliL3Fitter(AliL3Vertex *vertex,Bool_t vertexconstraint)
 
 AliL3Fitter::~AliL3Fitter()
 {
+  //destructor
   for(Int_t i=0; i<36; i++)
     {
       for(Int_t j=0; j<6; j++)
@@ -57,6 +60,7 @@ AliL3Fitter::~AliL3Fitter()
 
 void AliL3Fitter::LoadClusters(Char_t *path,Int_t event,Bool_t sp)
 {
+  //load clusters
   Char_t fname[256];
   AliL3MemHandler *clusterfile[36][6];
   for(Int_t s=0; s<=35; s++)
@@ -88,7 +92,7 @@ void AliL3Fitter::LoadClusters(Char_t *path,Int_t event,Bool_t sp)
     }
 }
 
-void AliL3Fitter::SortTrackClusters(AliL3Track *track)
+void AliL3Fitter::SortTrackClusters(AliL3Track *track) const
 {
   //Sort the internal cluster list in each track with respect to row numbering.
   //This may be necessary when no conventional track follower has been
@@ -136,6 +140,7 @@ void AliL3Fitter::SortTrackClusters(AliL3Track *track)
 
 Int_t AliL3Fitter::FitHelix(AliL3Track *track)
 {
+  //fit helix parameters
   fTrack = track;
   if(FitCircle())
     {
@@ -356,7 +361,7 @@ Int_t AliL3Fitter::FitCircle()
   rrrrav  = rrrrav / wsum ;
   xyav    = xyav   / wsum ;
 
-  Int_t const ntry = 5 ;
+  Int_t const kntry = 5 ;
 //
 //-->  USE THESE TO GET THE COEFFICIENTS OF THE 4-TH ORDER POLYNIMIAL
 //-->  DON'T PANIC - THE THIRD ORDER TERM IS ZERO !
@@ -386,7 +391,7 @@ Int_t AliL3Fitter::FitCircle()
   Double_t dlamax = 0.001 / chiscl ;   
    
   Double_t p, pd ;
-  for ( int itry = 1 ; itry <= ntry ; itry++ ) {
+  for ( int itry = 1 ; itry <= kntry ; itry++ ) {
      p      = c0 + lamda * (c1 + lamda * (c2 + lamda * lamda * c4 )) ;
      pd     = (c1 + lamda * (c2d + lamda * lamda * c4d)) ;
      dlamda = -p / pd ;
@@ -540,15 +545,15 @@ Int_t AliL3Fitter::FitLine ( )
     }
 
   Double_t localPsi = 0.5F * sqrt ( dx*dx + dy*dy ) / radius ;
-  Double_t total_s ;
+  Double_t totals ;
   
   if ( fabs(localPsi) < 1. ) 
     {
-      total_s = 2.0 * radius * asin ( localPsi ) ;
+      totals = 2.0 * radius * asin ( localPsi ) ;
     } 
   else 
     { 
-      total_s = 2.0 * radius * AliL3Transform::Pi() ;
+      totals = 2.0 * radius * AliL3Transform::Pi() ;
     } 
   
   Double_t dpsi,s;
@@ -579,7 +584,7 @@ Int_t AliL3Fitter::FitLine ( )
          fS[i]=s;
        }
       else
-       fS[i]=total_s;
+       fS[i]=totals;
       
       sum += fZWeight[i];
       ss  += fZWeight[i] * fS[i];
index 6bd2566022c4db6b89d26e173b85177ef6d8c69d..61d78457b25b838356381d696ea407f122dc8947 100644 (file)
@@ -1,9 +1,14 @@
 // @(#) $Id$
 
-#ifndef ALIL3_Fitter
-#define ALIL3_Fitter
+#ifndef ALIL3FitterH
+#define ALIL3FitterH
 
-#include "AliL3RootTypes.h"
+//_____________________________________________________________
+// AliL3Fitter
+//
+// Fit class HLT
+//
+// Author: Anders Vestbo <mailto:vestbo@fi.uib.no>
 
 class AliL3Track;
 class AliL3Vertex;
@@ -11,25 +16,25 @@ class AliL3SpacePointData;
 
 class AliL3Fitter {
 
- private:
-  AliL3Track *fTrack; //!
-  AliL3Vertex *fVertex; //!
-  Bool_t fVertexConstraint;
-  AliL3SpacePointData *fClusters[36][6]; //!
-  UInt_t fNcl[36][6];
-  
- public:
+  public:
   AliL3Fitter();
   AliL3Fitter(AliL3Vertex *vertex,Bool_t vertexconstraint=kTRUE);
   virtual ~AliL3Fitter();
   
   void LoadClusters(Char_t *path,Int_t event=0,Bool_t sp=kFALSE);
-  void SortTrackClusters(AliL3Track *track);
+  void SortTrackClusters(AliL3Track *track) const;
   Int_t FitHelix(AliL3Track *track);
   Int_t FitCircle();
   Int_t FitLine();
   void NoVertex() {fVertexConstraint=kFALSE;}
-  
+ private:
+  AliL3Track *fTrack; //!                    actual track
+  AliL3Vertex *fVertex; //!                  vertex info
+  Bool_t fVertexConstraint; //               include vertex constraint
+  AliL3SpacePointData *fClusters[36][6]; //! clusters
+  UInt_t fNcl[36][6]; //                     cluster numbers
   ClassDef(AliL3Fitter,1) //HLT fit class
 };
 
index 1f9c387ec4e4ac46df6ed794a9e18514ce81fa2b..e4d36045c1db545b5e859c91e5acaa3b6d902272 100644 (file)
@@ -3,20 +3,6 @@
 // Author: Uli Frankenfeld <mailto:franken@fi.uib.no>, Anders Vestbo <mailto:vestbo$fi.uib.no>, Constantin Loizides <mailto:loizides@ikf.uni-frankfurt.de>
 //*-- Copyright &copy ALICE HLT Group 
 
-#include "AliL3RootTypes.h"
-#include "AliL3StandardIncludes.h"
-#include "AliL3DigitData.h"
-#include "AliL3Logging.h"
-#include "AliL3Transform.h"
-#include "AliL3TrackSegmentData.h"
-#include "AliL3SpacePointData.h"
-#include "AliL3TrackArray.h"
-#include "AliL3MemHandler.h"
-
-#if __GNUC__ == 3
-using namespace std;
-#endif
-
 /** \class AliL3MemHandler 
 <pre>
 //_____________________________________________________________
@@ -75,6 +61,20 @@ using namespace std;
 // The data is RLE encoded and currently using _10_ bit range for the ADC-values.
 </pre>
 */  
+
+#include "AliL3RootTypes.h"
+#include "AliL3StandardIncludes.h"
+#include "AliL3DigitData.h"
+#include "AliL3Logging.h"
+#include "AliL3Transform.h"
+#include "AliL3TrackSegmentData.h"
+#include "AliL3SpacePointData.h"
+#include "AliL3TrackArray.h"
+#include "AliL3MemHandler.h"
+
+#if __GNUC__ == 3
+using namespace std;
+#endif
   
 ClassImp(AliL3MemHandler)
   
@@ -1220,6 +1220,7 @@ void AliL3MemHandler::UpdateRowPointer(AliL3DigitRowData *&tempPt)
 
 Int_t  AliL3MemHandler::ComparePoints(UInt_t /*row*/,UShort_t pad,UShort_t time) const
 {
+  //compare two points
   if(fNUsed>=fNDigits) return -2;
 
   if(pad==fDPt[fNUsed]->fPad&&time==fDPt[fNUsed]->fTime) return 0;
@@ -1232,6 +1233,7 @@ Int_t  AliL3MemHandler::ComparePoints(UInt_t /*row*/,UShort_t pad,UShort_t time)
 
 Int_t AliL3MemHandler::CompareDigits(AliL3RandomDigitData *a,AliL3RandomDigitData *b) const
 {
+  //compare two digits
   if(a->fPad==b->fPad && a->fTime == b->fTime) return 0;
 
   if(a->fPad<b->fPad) return -1;
index b01fc11c40e1909515323379be980083b5273f92..8b7d249fe1bc6b0f078d9a8a6cf2a483d30fdfa5 100644 (file)
@@ -3,8 +3,17 @@
 #ifndef ALIL3_MEMHANDLER_H
 #define ALIL3_MEMHANDLER_H
 
-//#include "AliL3RootTypes.h"
-//#include "AliL3DigitData.h"
+//_____________________________________________________________
+// AliL3MemHandler
+//
+// The HLT Binary File handler 
+//
+//  This class does all the memory I/O handling of HLT binary files.
+//  
+// Author: Uli Frankenfeld <mailto:franken@fi.uib.no>, 
+//         Anders Vestbo <mailto:vestbo$fi.uib.no>, 
+//         Constantin Loizides <mailto:loizides@ikf.uni-frankfurt.de>
+//*-- Copyright &copy ALICE HLT Group 
 
 class AliL3DigitData;
 class AliL3SpacePointData;
@@ -19,47 +28,7 @@ class AliRunLoader;
 #endif
 
 class AliL3MemHandler { 
- private:
-  
-  Byte_t *fPt;//!
-  UInt_t fSize; //size of allocated data structure
 
-  AliL3RandomDigitData **fDPt;//!
-  AliL3RandomDigitData *fRandomDigits;//!
-  Bool_t fIsRandom; //random data generated
-  Int_t fNRandom;   //count random digits 
-  Int_t fNGenerate; //count generated digits
-  Int_t fNUsed;     //count used digits
-  Int_t fNDigits;   //count digits from digitstree
-
-  void Write(UInt_t *comp, UInt_t & index, UInt_t & subindex, UShort_t value) const;
-  UShort_t Read(UInt_t *comp, UInt_t & index, UInt_t & subindex) const;
-  UShort_t Test(UInt_t *comp, UInt_t index, UInt_t subindex) const; 
-  
-  void DigitizePoint(Int_t row,Int_t pad, Int_t time,Int_t charge);
-  void QSort(AliL3RandomDigitData **a, Int_t first, Int_t last);
-  Int_t ComparePoints(UInt_t row,UShort_t pad,UShort_t time) const ;
-  Int_t CompareDigits(AliL3RandomDigitData *a,AliL3RandomDigitData *b) const;
-  void AddData(AliL3DigitData *data,UInt_t & ndata,
-                      UInt_t row,UShort_t pad,UShort_t time,UShort_t charge) const;
-  void AddRandom(AliL3DigitData *data,UInt_t & ndata);
-  void MergeDataRandom(AliL3DigitData *data,UInt_t & ndata,
-                      UInt_t row,UShort_t pad,UShort_t time,UShort_t charge);
-  void AddDataRandom(AliL3DigitData *data,UInt_t & ndata,
-                      UInt_t row,UShort_t pad,UShort_t time,UShort_t charge);
-
- protected:
-  Int_t fRowMin; //min row
-  Int_t fRowMax; //max row
-  Int_t fSlice;  //slice
-  Int_t fPatch;  //patch
-
-  Int_t fEtaMinTimeBin[159]; //for ROI in eta only
-  Int_t fEtaMaxTimeBin[159]; //for ROI in eta only
-  
-  FILE *fInBinary;//!
-  FILE *fOutBinary;//!
-  
  public:
   AliL3MemHandler();
   virtual ~AliL3MemHandler();
@@ -191,6 +160,48 @@ class AliL3MemHandler {
   virtual AliL3DigitRowData* DDLData2Memory(UInt_t &/*nrow*/,Int_t /*event*/=-1){return 0;}
   virtual Bool_t DDLData2CompBinary(Int_t /*event*/=-1){return 0;}
 
+ protected:
+  Int_t fRowMin; //min row
+  Int_t fRowMax; //max row
+  Int_t fSlice;  //slice
+  Int_t fPatch;  //patch
+
+  Int_t fEtaMinTimeBin[159]; //for ROI in eta only
+  Int_t fEtaMaxTimeBin[159]; //for ROI in eta only
+  
+  FILE *fInBinary;//!
+  FILE *fOutBinary;//!
+
+ private:
+  
+  Byte_t *fPt;//!
+  UInt_t fSize; //size of allocated data structure
+
+  AliL3RandomDigitData **fDPt;//!
+  AliL3RandomDigitData *fRandomDigits;//!
+  Bool_t fIsRandom; //random data generated
+  Int_t fNRandom;   //count random digits 
+  Int_t fNGenerate; //count generated digits
+  Int_t fNUsed;     //count used digits
+  Int_t fNDigits;   //count digits from digitstree
+
+  void Write(UInt_t *comp, UInt_t & index, UInt_t & subindex, UShort_t value) const;
+  UShort_t Read(UInt_t *comp, UInt_t & index, UInt_t & subindex) const;
+  UShort_t Test(UInt_t *comp, UInt_t index, UInt_t subindex) const; 
+  
+  void DigitizePoint(Int_t row,Int_t pad, Int_t time,Int_t charge);
+  void QSort(AliL3RandomDigitData **a, Int_t first, Int_t last);
+  Int_t ComparePoints(UInt_t row,UShort_t pad,UShort_t time) const ;
+  Int_t CompareDigits(AliL3RandomDigitData *a,AliL3RandomDigitData *b) const;
+  void AddData(AliL3DigitData *data,UInt_t & ndata,
+                      UInt_t row,UShort_t pad,UShort_t time,UShort_t charge) const;
+  void AddRandom(AliL3DigitData *data,UInt_t & ndata);
+  void MergeDataRandom(AliL3DigitData *data,UInt_t & ndata,
+                      UInt_t row,UShort_t pad,UShort_t time,UShort_t charge);
+  void AddDataRandom(AliL3DigitData *data,UInt_t & ndata,
+                      UInt_t row,UShort_t pad,UShort_t time,UShort_t charge);
+
+
   ClassDef(AliL3MemHandler,1) // Memory handler class
 };
 #endif