Coding conventions (J.Klay)
authorhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sat, 22 Apr 2006 08:27:04 +0000 (08:27 +0000)
committerhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sat, 22 Apr 2006 08:27:04 +0000 (08:27 +0000)
25 files changed:
EMCAL/AliEMCAL.cxx
EMCAL/AliEMCAL.h
EMCAL/AliEMCALAlignData.cxx
EMCAL/AliEMCALAlignData.h
EMCAL/AliEMCALClusterizerv1.cxx
EMCAL/AliEMCALClusterizerv1.h
EMCAL/AliEMCALDigit.cxx
EMCAL/AliEMCALDigit.h
EMCAL/AliEMCALDigitizer.cxx
EMCAL/AliEMCALDigitizer.h
EMCAL/AliEMCALGeometryOfflineTrd1.cxx
EMCAL/AliEMCALGeometryOfflineTrd1.h
EMCAL/AliEMCALHistoUtilities.cxx
EMCAL/AliEMCALHistoUtilities.h
EMCAL/AliEMCALHit.h
EMCAL/AliEMCALLoader.cxx
EMCAL/AliEMCALLoader.h
EMCAL/AliEMCALRawStream.h
EMCAL/AliEMCALRecPoint.cxx
EMCAL/AliEMCALRecPoint.h
EMCAL/AliEMCALSDigitizer.cxx
EMCAL/AliEMCALTick.cxx
EMCAL/AliEMCALTick.h
EMCAL/AliEMCALTrigger.h
EMCAL/jetfinder/AliEMCALJetMicroDst.cxx

index 41f5c7d..99f26c7 100644 (file)
@@ -83,12 +83,14 @@ AliEMCAL::AliEMCAL(const char* name, const char* title): AliDetector(name,title)
 //____________________________________________________________________________
 AliEMCAL::~AliEMCAL()
 {
-
+  //dtor
 }
 
 //____________________________________________________________________________
 void AliEMCAL::Copy(AliEMCAL & emcal) const
 {
+  //copy
+
   TObject::Copy(emcal) ; 
   emcal.fHighCharge        = fHighCharge ;
   emcal.fHighGain          = fHighGain ; 
@@ -99,6 +101,7 @@ void AliEMCAL::Copy(AliEMCAL & emcal) const
 //____________________________________________________________________________
 AliDigitizer* AliEMCAL::CreateDigitizer(AliRunDigitizer* manager) const
 {
+  //create and return the digitizer
   return new AliEMCALDigitizer(manager);
 }
 
@@ -254,8 +257,8 @@ void AliEMCAL::Digits2Raw()
 
   AliAltroBuffer* buffer = NULL;
   Int_t prevDDL = -1;
-  Int_t adcValuesLow[fkTimeBins];
-  Int_t adcValuesHigh[fkTimeBins];
+  Int_t adcValuesLow[fgkTimeBins];
+  Int_t adcValuesHigh[fgkTimeBins];
   
   // loop over digits (assume ordered digits)
   for (Int_t iDigit = 0; iDigit < digits->GetEntries(); iDigit++) {
@@ -532,6 +535,7 @@ Double_t AliEMCAL::RawResponseFunction(Double_t *x, Double_t *par)
 //__________________________________________________________________
 Double_t AliEMCAL::RawResponseFunctionMax(Double_t charge, Double_t gain) 
 {
+  //compute the maximum of the raw response function and return
   return ( charge * TMath::Power(fgOrder, fgOrder) * TMath::Power(gain, fgOrder) 
      / ( fgCapa * TMath::Exp(fgOrder) ) );  
 
index eafdd6f..cd7309b 100644 (file)
@@ -7,6 +7,8 @@
 
 //_________________________________________________________________________
 //  Base Class for EMCAL     
+//  holds all geant information of
+//  materials, etc.
 //                  
 //*-- Author: Yves Schutz (SUBATECH)
 
@@ -69,7 +71,7 @@ class AliEMCAL : public AliDetector {
   Double_t GetRawFormatLowGain() const { return ( fHighGain / fHighLowGainFactor ) ; }  
   Int_t GetRawFormatLowGainOffset() const { return fLowGainOffset ; }  
   Int_t GetRawFormatOrder() const { return fgOrder ; }   
-  Int_t GetRawFormatTimeBins() const { return fkTimeBins ; }    
+  Int_t GetRawFormatTimeBins() const { return fgkTimeBins ; }    
   Double_t GetRawFormatTimeMax() const { return fgTimeMax ; }   
   Double_t GetRawFormatTimePeak() const { return fgTimePeak ; }    
   Double_t GetRawFormatTimeTrigger() const { return fgTimeTrigger ; }
@@ -99,13 +101,13 @@ protected:
   Double_t fHighLowGainFactor ;         // high to low gain factor for the raw RO signal
   Int_t    fLowGainOffset ;             // to separate high from low gain in the DDL
   static Int_t fgOrder ;                // order of the gamma function for the RO signal
-  static const Int_t fkTimeBins = 256 ; // number of sampling bins of the raw RO signal  
+  static const Int_t fgkTimeBins = 256 ; // number of sampling bins of the raw RO signal  
   static Double_t fgTimeMax ;           // maximum sampled time of the raw RO signal                             
   static Double_t fgTimePeak ;          // peaking time of the raw RO signal                                    
   static Double_t fgTimeTrigger ;       // time of the trigger for the RO signal 
-  static Int_t fgDDLOffset;
-  static Int_t fgThreshold;
-  static Int_t fgChannelsPerDDL;
+  static Int_t fgDDLOffset;             // DDL offset
+  static Int_t fgThreshold;             // threshold
+  static Int_t fgChannelsPerDDL;        // number of channels per DDL
 
   ClassDef(AliEMCAL,9) // Electromagnetic calorimeter (base class)
     
index f559da5..5304635 100644 (file)
 
 ////////////////////////////////////////////////
 //  class for EMCAL alignment parameters       //
+//  
+//  A. Pavlinov
+//
+//  JLK (21-Apr-2006): this should go away sometime
+//  soon and EMCAL should use
+//  official ALICE alignment classes
+//
 ////////////////////////////////////////////////
 
 #include "AliEMCALAlignData.h"
index 7f97ffa..6f761c8 100644 (file)
@@ -44,7 +44,7 @@ class AliEMCALAlignData: public TNamed {
 
  protected:
   Int_t   fNSuperModules;                    // number of EMCAL supermodules (max=12)
-  AliAlignObjMatrix *fSuperModuleMatrix[12]; 
+  AliAlignObjMatrix *fSuperModuleMatrix[12]; //matrix info for supermodules
 
   ClassDef(AliEMCALAlignData,1)    // EMCAL Alignment data
 };
index 1a44750..d83179a 100644 (file)
@@ -820,6 +820,8 @@ void AliEMCALClusterizerv1::PrintRecPoints(Option_t * option)
 }
 TList* AliEMCALClusterizerv1::BookHists()
 {
+  //set up histograms for monitoring clusterizer performance
+
   gROOT->cd();
 
        fPointE = new TH1F("pointE","point energy", 2000, 0.0, 150.);
index 6ffc69c..59b0ca1 100644 (file)
@@ -36,6 +36,9 @@ class AliEMCALClusterizerv1 : public AliEMCALClusterizer {
 public:
   
   AliEMCALClusterizerv1() ;         
+  //cpy ctor required by coding convention
+  AliEMCALClusterizerv1(const AliEMCALClusterizerv1& clus):AliEMCALClusterizer(clus){};
+
   AliEMCALClusterizerv1(const TString alirunFileNameFile, const TString eventFolderName = AliConfig::GetDefaultEventFolderName());
   virtual ~AliEMCALClusterizerv1()  ;
   virtual void Browse(TBrowser* b);
@@ -85,16 +88,16 @@ protected:
             
 ///////////////////// 
    TList  *fHists;   //!
-   TH1F* fPointE;
-   TH1F* fPointL1;
-   TH1F* fPointL2;
-   TH1F* fPointDis;
-   TH1F* fPointMult;
-   TH1F* fDigitAmp;
-   TH1F* fMaxE;
-   TH1F* fMaxL1;
-   TH1F* fMaxL2;
-   TH1F* fMaxDis;
+   TH1F* fPointE;    //histogram of point energy
+   TH1F* fPointL1;   //histogram of point L1
+   TH1F* fPointL2;   //histogram of point L2
+   TH1F* fPointDis;  //histogram of point dispersion
+   TH1F* fPointMult; //histogram of point multiplicity
+   TH1F* fDigitAmp;  //histogram of digit ADC Amplitude
+   TH1F* fMaxE;      //histogram of maximum point energy
+   TH1F* fMaxL1;     //histogram of maximum point L1
+   TH1F* fMaxL2;     //histogram of maximum point L2
+   TH1F* fMaxDis;    //histogram of maximum point dispersion
 ///////////////////////
 
 
index cf3cf80..96f1153 100644 (file)
@@ -151,7 +151,9 @@ Int_t AliEMCALDigit::Compare(const TObject * obj) const
 
 //____________________________________________________________________________
 Float_t AliEMCALDigit::GetEta() const
-{ // should be change in EMCALGeometry - 19-nov-04
+{ 
+  //return pseudorapidity for this digit
+  // should be change in EMCALGeometry - 19-nov-04
   Float_t eta=-10., phi=-10.;
   Int_t id = GetId();
   const AliEMCALGeometry *g = AliEMCALGeometry::GetInstance();
@@ -161,7 +163,9 @@ Float_t AliEMCALDigit::GetEta() const
 
 //____________________________________________________________________________
 Float_t AliEMCALDigit::GetPhi() const
-{ // should be change in EMCALGeometry - 19-nov-04
+{ 
+  //return phi coordinate of digit
+  // should be change in EMCALGeometry - 19-nov-04
   Float_t eta=-10., phi=-10.;
   Int_t id = GetId();
   const AliEMCALGeometry *g = AliEMCALGeometry::GetInstance();
index bc13430..4801b31 100644 (file)
@@ -38,7 +38,8 @@ class AliEMCALDigit : public AliDigitNew {
   Bool_t operator==(const AliEMCALDigit &rValue) const;
   AliEMCALDigit& operator+(AliEMCALDigit const &rValue) ;
   AliEMCALDigit& operator*(Float_t factor) ; 
+  const AliEMCALDigit& operator = (const AliEMCALDigit &) {return *this;}
+
   Int_t   Compare(const TObject * obj) const ;  
   Float_t GetEta() const ; 
   Int_t   GetNprimary() const { return fNprimary ; }
index 126aa98..17e1c66 100644 (file)
@@ -147,6 +147,7 @@ AliEMCALDigitizer::AliEMCALDigitizer(AliRunDigitizer * rd):
 //____________________________________________________________________________ 
   AliEMCALDigitizer::~AliEMCALDigitizer()
 {
+  //dtor
   if (AliRunLoader::GetRunLoader()) {
     AliLoader *emcalLoader=0;
     if ((emcalLoader = AliRunLoader::GetRunLoader()->GetDetectorLoader("EMCAL")))
@@ -175,13 +176,13 @@ void AliEMCALDigitizer::Digitize(Int_t event)
 
   AliRunLoader *rl = AliRunLoader::GetRunLoader();
   AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(rl->GetDetectorLoader("EMCAL"));
-  Int_t ReadEvent = event ; 
+  Int_t readEvent = event ; 
   // fManager is data member from AliDigitizer
   if (fManager) 
-    ReadEvent = dynamic_cast<AliStream*>(fManager->GetInputStream(0))->GetCurrentEventNumber() ; 
+    readEvent = dynamic_cast<AliStream*>(fManager->GetInputStream(0))->GetCurrentEventNumber() ; 
   AliDebug(1,Form("Adding event %d from input stream 0 %s %s", 
-                 ReadEvent, GetTitle(), fEventFolderName.Data())) ; 
-  rl->GetEvent(ReadEvent);
+                 readEvent, GetTitle(), fEventFolderName.Data())) ; 
+  rl->GetEvent(readEvent);
 
   TClonesArray * digits = emcalLoader->Digits() ; 
   digits->Clear() ;
@@ -229,10 +230,10 @@ void AliEMCALDigitizer::Digitize(Int_t event)
       rl2 = AliRunLoader::Open(fInputFileNames[i], tempo) ; 
 
     if (fManager) 
-      ReadEvent = dynamic_cast<AliStream*>(fManager->GetInputStream(i))->GetCurrentEventNumber() ; 
-    Info("Digitize", "Adding event %d from input stream %d %s %s", ReadEvent, i, fInputFileNames[i].Data(), tempo.Data()) ; 
+      readEvent = dynamic_cast<AliStream*>(fManager->GetInputStream(i))->GetCurrentEventNumber() ; 
+    Info("Digitize", "Adding event %d from input stream %d %s %s", readEvent, i, fInputFileNames[i].Data(), tempo.Data()) ; 
     rl2->LoadSDigits();
-    rl2->GetEvent(ReadEvent);
+    rl2->GetEvent(readEvent);
     AliEMCALLoader *emcalLoader2 = dynamic_cast<AliEMCALLoader*>(rl2->GetDetectorLoader("EMCAL"));
     sdigArray->AddAt(emcalLoader2->SDigits(), i) ;
   }
@@ -542,7 +543,9 @@ Bool_t AliEMCALDigitizer::Init()
 
 //____________________________________________________________________________ 
 void AliEMCALDigitizer::InitParameters()
-{ // Tune parameters - 24-nov-04
+{ 
+  //parameter initialization for digitizer
+  // Tune parameters - 24-nov-04
 
   fMeanPhotonElectron = 3300 ; // electrons per GeV 
   fPinNoise           = 0.004; 
@@ -665,7 +668,10 @@ void AliEMCALDigitizer::Print(Option_t*)const
 }
 
 //__________________________________________________________________
-void AliEMCALDigitizer::PrintDigits(Option_t * option){
+void AliEMCALDigitizer::PrintDigits(Option_t * option)
+{
+  //utility method for printing digit information
+
   AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(AliRunLoader::GetRunLoader()->GetDetectorLoader("EMCAL"));
   TClonesArray * digits  = emcalLoader->Digits() ;
   TClonesArray * sdigits = emcalLoader->SDigits() ;
@@ -762,7 +768,10 @@ void AliEMCALDigitizer::Browse(TBrowser* b)
 }
 
 TList *AliEMCALDigitizer::BookControlHists(int var)
-{ // 22-nov-04
+{ 
+  // 22-nov-04
+  // histograms for monitoring digitizer performance
+
   Info("BookControlHists"," started ");
   gROOT->cd();
   const AliEMCALGeometry *geom = AliEMCALGeometry::GetInstance();
index 4043138..eccb711 100644 (file)
@@ -107,7 +107,7 @@ private:
   Float_t fTimeThreshold ;        // Threshold to start timing for given crystall
   Float_t fTimeSignalLength ;     // Length of the timing signal 
   Float_t fADCchannelEC ;         // width of one ADC channel in EC section (GeV)
-  Float_t fADCpedestalEC ;        //
+  Float_t fADCpedestalEC ;        // pedestal for one ADC channel
   Int_t   fNADCEC ;               // number of channels in EC section ADC
 
   TString fEventFolderName;         // skowron: name of EFN to read data from in stand alone mode
index 45988d9..804d6b5 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 // GeometryOfflineTrd1 class  for EMCAL : singleton
+//  implementation of 
+//  specific geometry
+//  for trd 1
+//
 //*-- Author: Aleksei Pavlinov (WSU)
 
 /* $Id$*/
@@ -33,6 +37,7 @@ AliEMCALGeometryOfflineTrd1* AliEMCALGeometryOfflineTrd1::fgGeomOfflineTrd1=0;
 
 AliEMCALGeometryOfflineTrd1* AliEMCALGeometryOfflineTrd1::GetInstance()
 {
+  //retrurn instance of the geometry
   if(fgGeomOfflineTrd1==0) {
     fgGeomOfflineTrd1 = new AliEMCALGeometryOfflineTrd1();
   }
@@ -40,7 +45,8 @@ AliEMCALGeometryOfflineTrd1* AliEMCALGeometryOfflineTrd1::GetInstance()
 }
 
 AliEMCALGeometryOfflineTrd1::AliEMCALGeometryOfflineTrd1() : TNamed("geomTRD1","")
-{ // this private constarctor
+{ 
+  // this private constarctor
   fGeometry = AliEMCALGeometry::GetInstance("SHISH_62_TRD1");
   Init();
 }
@@ -104,7 +110,9 @@ void AliEMCALGeometryOfflineTrd1::Init()
 }
 
 TVector3& AliEMCALGeometryOfflineTrd1::PosInSuperModule(int nSupMod, Int_t nTower, Int_t nIphi, Int_t nIeta)
-{ // 10-nov-04
+{ 
+  //return location of position within supermodule
+  // 10-nov-04
   static Int_t iphi, ieta;
   static TVector3 v;
   fGeometry->GetCellPhiEtaIndexInSModule(nSupMod, nTower,nIphi,nIeta, iphi,ieta);
@@ -117,6 +125,8 @@ TVector3& AliEMCALGeometryOfflineTrd1::PosInSuperModule(int nSupMod, Int_t nTowe
 void AliEMCALGeometryOfflineTrd1::PositionInSuperModule(Int_t iphi, Int_t ieta, 
 double &lphi, double &leta)
 { 
+  //return location of position within supermodule
+
   static Int_t ie=0;
   lphi = fSMPositionPhi[iphi-1];
   ie = ieta - 1;
@@ -128,26 +138,34 @@ double &lphi, double &leta)
 void AliEMCALGeometryOfflineTrd1::PositionInSuperModule(int nSupMod, Int_t nTower, Int_t nIphi, Int_t nIeta,
 double &lphi, double &leta)
 {
+  //return location of position within supermodule
+
   static Int_t iphi,ieta;
   fGeometry->GetCellPhiEtaIndexInSModule(nSupMod, nTower,nIphi,nIeta,iphi,ieta);
   PositionInSuperModule(iphi,ieta, lphi,leta);
 }
 
 TRotation* AliEMCALGeometryOfflineTrd1::Rotation(Int_t module)
-{ // module chabge from 1 to 12
+{ 
+  //return rotation matrix for module
+  // module chabge from 1 to 12
   if(module<1)  module=1;
   if(module>12) module=12;
   return &fSuperModuleRotation[module];
 }
 
 TVector3* AliEMCALGeometryOfflineTrd1::CellPosition(int absId)
-{ // 15-nov-04
+{ 
+  //return cell position given absoluted cell id
+  // 15-nov-04
   if(absId<1 || absId>fXYZofCells->GetSize()) return 0;
   return (TVector3*)fXYZofCells->At(absId-1);
 }
 
 void AliEMCALGeometryOfflineTrd1::PrintSuperModule()
-{ // 12-nov-04
+{
+  //utility method for printing supermodule info
+  // 12-nov-04
   printf(" ** Super module ** fSMMaxEta %i fSMMaxPHI %i\n ETA     eta(Z)          (X)\n",
   fSMMaxEta,fSMPositionPhi.GetSize());
   for(Int_t i=0; i<fSMMaxEta; i++) {
@@ -161,6 +179,7 @@ void AliEMCALGeometryOfflineTrd1::PrintSuperModule()
 
 void AliEMCALGeometryOfflineTrd1::PrintCell(Int_t absId)
 {
+  //utility method for printing cell info
   Int_t nSupMod, nTower, nIphi, nIeta, iphi, ieta;
   if(fGeometry->GetCellIndex(absId, nSupMod,nTower,nIphi,nIeta)){
      fGeometry->GetCellPhiEtaIndexInSModule(nSupMod,nTower,nIphi,nIeta, iphi,ieta);
@@ -174,6 +193,7 @@ void AliEMCALGeometryOfflineTrd1::PrintCell(Int_t absId)
 
 void AliEMCALGeometryOfflineTrd1::Browse(TBrowser* b)
 {
+  //Browse the geometry
   if(fGeometry) b->Add(fGeometry);
 
   for(Int_t i=0; i<fMaxInEta; i++)  if(fTrd1Modules[i]>0) b->Add(fTrd1Modules[i]);
@@ -193,5 +213,6 @@ void AliEMCALGeometryOfflineTrd1::Browse(TBrowser* b)
 
 Bool_t AliEMCALGeometryOfflineTrd1::IsFolder() const
 {
+  //folder check
   return kTRUE;
 }
index f6df999..038cf79 100644 (file)
@@ -30,11 +30,29 @@ class AliEMCALGeometryOfflineTrd1 : public TNamed {
     Fatal("Cpy ctor", "Not implemented");
   }
 
+  //assignment operator for coding convention
+  const AliEMCALGeometryOfflineTrd1 & operator = (const AliEMCALGeometryOfflineTrd1 &) {return *this;}
+
   virtual ~AliEMCALGeometryOfflineTrd1() { /* nothing */ };
   static   AliEMCALGeometryOfflineTrd1* GetInstance();
   // positon in SuperModule
   TVector3&  PosInSuperModule(int nSupMod, int nTower, int nIphi, int nIeta); 
 
+ public:
+  // One Super Module
+  void PositionInSuperModule(int iphi, int ieta, double &lphi, double &leta);
+  void PositionInSuperModule(int nSupMod, int nTower, int nIphi, int nIeta, double &lphi, double &leta);
+  // Position towers(cells)
+  TVector3* CellPosition(int absId); // from 0 to fGeometry->GetNCells()
+  // Global System
+  TRotation* Rotation(Int_t module); // module change from 1 to 12;
+
+  // service methods
+  void    PrintSuperModule();       // *MENU*
+  void    PrintCell(Int_t absId=1); // *MENU*
+  virtual void Browse(TBrowser* b);
+  virtual Bool_t  IsFolder() const;
+
  private:
   AliEMCALGeometryOfflineTrd1();
   void Init();
@@ -57,20 +75,6 @@ class AliEMCALGeometryOfflineTrd1 : public TNamed {
   TRotation fSuperModuleRotation[12];                    //! 
   // position of cells in global coordinate system
   TObjArray *fXYZofCells;                                //! 
- public:
-  // One Super Module
-  void PositionInSuperModule(int iphi, int ieta, double &lphi, double &leta);
-  void PositionInSuperModule(int nSupMod, int nTower, int nIphi, int nIeta, double &lphi, double &leta);
-  // Position towers(cells)
-  TVector3* CellPosition(int absId); // from 0 to fGeometry->GetNCells()
-  // Global System
-  TRotation* Rotation(Int_t module); // module change from 1 to 12;
-
-  // service methods
-  void    PrintSuperModule();       // *MENU*
-  void    PrintCell(Int_t absId=1); // *MENU*
-  virtual void Browse(TBrowser* b);
-  virtual Bool_t  IsFolder() const;
 
   ClassDef(AliEMCALGeometryOfflineTrd1, 0) // EMCAL geometry for offline 
 };
index 9a28a30..ee078d0 100644 (file)
@@ -15,6 +15,9 @@
 
 /*
 $Log$
+Revision 1.3  2006/03/29 18:15:06  pavlinov
+Alignmnet staff and some clean up
+
 Revision 1.2  2006/03/01 23:36:50  jklay
 suppress compiler warnings by correcting some hidden virtual methods
 
@@ -24,7 +27,10 @@ add histogram utilities class, correct package definitions
 */
 
 //_________________________________________________________________________
-// This is just set of static methods for common using
+// This is a set of histogram
+// utilities for the EMCAL
+// to make some common
+// functions easier
 //
 //*-- Authors: J.L. Klay (LLNL) & Aleksei Pavlinov (WSU) 
 
@@ -70,6 +76,7 @@ TList* AliEMCALHistoUtilities::MoveHistsToList(const char* name, Bool_t putToBro
 
 void AliEMCALHistoUtilities::FillH1(TList *l, Int_t ind, Double_t x, Double_t w)
 {
+  //fill 1d histogram
   static TH1* hid=0;
   if(l == 0) return;
   if(ind < l->GetSize()){
@@ -80,6 +87,7 @@ void AliEMCALHistoUtilities::FillH1(TList *l, Int_t ind, Double_t x, Double_t w)
 
 void AliEMCALHistoUtilities::FillH2(TList *l, Int_t ind, Double_t x, Double_t y, Double_t w)
 {
+  //fill 2d histogram
   static TH2* hid=0;
   if(l == 0) return;
   if(ind < l->GetSize()){
@@ -90,6 +98,7 @@ void AliEMCALHistoUtilities::FillH2(TList *l, Int_t ind, Double_t x, Double_t y,
 
 int AliEMCALHistoUtilities::SaveListOfHists(TList *mylist,const char* name,Bool_t kSingleKey,const char* opt)
 {
+  //write histograms to file
   printf(" Name of out file |%s|\n", name); 
   int save = 0;
   if(mylist && mylist->GetSize() && strlen(name)){
@@ -124,9 +133,10 @@ int AliEMCALHistoUtilities::SaveListOfHists(TList *mylist,const char* name,Bool_
   return save;
 }
 
-// Moved from AliEMCALGeometry
 int AliEMCALHistoUtilities::ParseString(const TString &topt, TObjArray &Opt)
-{ // Feb 06, 2006
+{ 
+  // Moved from AliEMCALGeometry
+  // Feb 06, 2006
   Ssiz_t begin, index, end, end2;
   begin = index = end = end2 = 0;
   TRegexp separator("[^ ;,\\t\\s/]+");
index baa528b..13c4c0e 100644 (file)
@@ -6,7 +6,10 @@
 /* $Id$ */
 
 //_________________________________________________________________________
-// This is just set of static methods for common using
+// This is a set of histogram
+// utilities for the EMCAL
+// to make some common
+// functions easier
 //                  
 //*-- Authors: J.L. Klay (LLNL) & Aleksei Pavlinov (WSU)
 
index 3c7d8e1..75ac43b 100644 (file)
@@ -44,7 +44,7 @@ public:
   Float_t GetPz(void) const{return fPz;}
   Float_t GetPe(void) const{return fPe;}
 
-  void   SetIparent(Int_t i_parent) {fIparent=i_parent;}
+  void   SetIparent(Int_t iparent) {fIparent=iparent;}
   void   SetPrimary(Int_t primary)  {fPrimary=primary;}
 
   Bool_t operator == (AliEMCALHit const &rValue) const;
index 3d6f818..78ee0ac 100644 (file)
@@ -39,9 +39,7 @@
 //
 //////////////////////////////////////////////////////////////////////////////
 
-
 // --- ROOT system ---
-
 #include "TTree.h"
 
 // --- Standard library ---
 ClassImp(AliEMCALLoader)
   
 const TString AliEMCALLoader::fgkECARecPointsBranchName("EMCALECARP");//Name for branch with ECA Reconstructed Points
-AliEMCALCalibData* AliEMCALLoader::fCalibData = 0; //calibation data
-AliEMCALAlignData* AliEMCALLoader::fAlignData = 0; //alignment data
+AliEMCALCalibData* AliEMCALLoader::fgCalibData = 0; //calibation data
+AliEMCALAlignData* AliEMCALLoader::fgAlignData = 0; //alignment data
 
 //____________________________________________________________________________ 
 AliEMCALLoader::AliEMCALLoader()
 {
+  //Default constructor for EMCAL Loader Class
+
   fDebug = 0;
   fHits = new TClonesArray("AliEMCALHit");
   fDigits = new TClonesArray("AliEMCALDigit");
@@ -73,6 +73,8 @@ AliEMCALLoader::AliEMCALLoader()
 AliEMCALLoader::AliEMCALLoader(const Char_t *detname,const Char_t *eventfoldername):
   AliLoader(detname,eventfoldername)
 {
+  //Specific constructor for EMCAL Loader class
+
   fDebug=0;
   fHits = new TClonesArray("AliEMCALHit");
   fDigits = new TClonesArray("AliEMCALDigit");
@@ -104,8 +106,8 @@ AliEMCALAlignData* AliEMCALLoader::AlignData()
   // Check if the instance of AliEMCALAlignData exists, and return it
   
   if( !(AliCDBManager::Instance()->IsDefaultStorageSet()) )
-    fAlignData=0x0;
-  return fAlignData;
+    fgAlignData=0x0;
+  return fgAlignData;
 }
 
 //____________________________________________________________________________ 
@@ -114,9 +116,9 @@ AliEMCALCalibData* AliEMCALLoader::CalibData()
   // Check if the instance of AliEMCALCalibData exists, and return it
 
   if( !(AliCDBManager::Instance()->IsDefaultStorageSet()) ) 
-    fCalibData=0x0;
+    fgCalibData=0x0;
   
-  return fCalibData;
+  return fgCalibData;
   
 }
 
@@ -150,7 +152,10 @@ Int_t AliEMCALLoader::CalibrateRaw(Double_t energy, Int_t module,
 }
 
 //____________________________________________________________________________ 
-Int_t AliEMCALLoader::LoadHits(Option_t* opt) {
+Int_t AliEMCALLoader::LoadHits(Option_t* opt) 
+{
+  //Load the hits tree for the
+  //EMCAL
   
   Int_t status = AliLoader::LoadHits(opt);  // First call AliLoader to do all the groundwork
   
@@ -167,8 +172,10 @@ Int_t AliEMCALLoader::LoadHits(Option_t* opt) {
 }
 
 //____________________________________________________________________________ 
-Int_t AliEMCALLoader::LoadSDigits(Option_t* opt) {
-  
+Int_t AliEMCALLoader::LoadSDigits(Option_t* opt) 
+{
+  //Load SDigits from TreeS for EMCAL
+
   Int_t status = AliLoader::LoadSDigits(opt);  // First call AliLoader to do all the groundwork
   
   TTree *treeS = TreeS();
@@ -182,8 +189,10 @@ Int_t AliEMCALLoader::LoadSDigits(Option_t* opt) {
 }
 
 //____________________________________________________________________________ 
-Int_t AliEMCALLoader::LoadDigits(Option_t* opt) {
-  
+Int_t AliEMCALLoader::LoadDigits(Option_t* opt) 
+{
+  //Load Digits from TreeD for EMCAL
+
   Int_t status = AliLoader::LoadDigits(opt);  // First call AliLoader to do all the groundwork
   
   TTree *treeD = TreeD();
@@ -197,7 +206,9 @@ Int_t AliEMCALLoader::LoadDigits(Option_t* opt) {
 }
 
 //____________________________________________________________________________ 
-Int_t AliEMCALLoader::LoadRecPoints(Option_t* opt) {
+Int_t AliEMCALLoader::LoadRecPoints(Option_t* opt) 
+{
+  //Load RecPoints from TreeR for EMCAL
   
   Int_t status = AliLoader::LoadRecPoints(opt);  // First call AliLoader to do all the groundwork
   
@@ -211,8 +222,12 @@ Int_t AliEMCALLoader::LoadRecPoints(Option_t* opt) {
 }
 
 //____________________________________________________________________________ 
-Int_t AliEMCALLoader::GetEvent() {
-  
+Int_t AliEMCALLoader::GetEvent() 
+{
+  //Method to load all of the data
+  //members of the EMCAL for a given
+  //event from the Trees
+
   AliLoader::GetEvent();  // First call AliLoader to do all the groundwork
   
   // Now connect and fill TClonesArray
index 97053fe..1cc6c64 100644 (file)
@@ -109,8 +109,8 @@ class AliEMCALLoader : public AliLoader {
 
   Int_t CalibrateRaw (Double_t energy, Int_t module, Int_t column, Int_t row);//take real calibration coefficients
   
-  void  SetAlignData(AliEMCALAlignData* alignda)  { fAlignData = alignda; } 
-  void  SetCalibData(AliEMCALCalibData* calibda)  { fCalibData = calibda; }
+  void  SetAlignData(AliEMCALAlignData* alignda)  { fgAlignData = alignda; } 
+  void  SetCalibData(AliEMCALCalibData* calibda)  { fgCalibData = calibda; }
   AliEMCALAlignData * AlignData(); // to get the alignment CDB object
   AliEMCALCalibData * CalibData(); // to get the calibration CDB object
 
@@ -128,8 +128,8 @@ private:
   TClonesArray     *fSDigits;      //! TClonesArray of sdigits (for tree reading)
   TObjArray        *fRecPoints;    //! TClonesArray of recpoints (for tree reading)   
   
-  static AliEMCALAlignData * fAlignData;
-  static AliEMCALCalibData * fCalibData;  //  calibration data 
+  static AliEMCALAlignData * fgAlignData;  //  alignment data
+  static AliEMCALCalibData * fgCalibData;  //  calibration data 
 
   ClassDef(AliEMCALLoader,0)  // Algorithm class that provides methods to retrieve objects from a list knowing the index 
    
index 59acff8..ad316c1 100644 (file)
@@ -41,10 +41,10 @@ protected:
 
   virtual void ApplyAltroMapping();
 
-  Int_t            fId;
-  Int_t            fPrevId;
-  Int_t            fModule;
-  Int_t            fPrevModule;
+  Int_t            fId;         //Id of channel
+  Int_t            fPrevId;     //previous id
+  Int_t            fModule;     //module containing channel
+  Int_t            fPrevModule; //previous module
 
   ClassDef(AliEMCALRawStream, 0)   // class for reading EMCAL raw digits
     };
index 686d7f4..e1940d6 100644 (file)
@@ -64,9 +64,9 @@ AliEMCALRecPoint::AliEMCALRecPoint()
   fCoreRadius = 10;        //HG Check this
 
   AliRunLoader *rl = AliRunLoader::GetRunLoader();
-  fGeom = dynamic_cast<AliEMCAL*>(rl->GetAliRun()->GetDetector("EMCAL"))->GetGeometry();
-  //fGeom = AliEMCALGeometry::GetInstance();
-  fGeom->GetTransformationForSM(); // Global <-> Local
+  fGeomPtr = dynamic_cast<AliEMCAL*>(rl->GetAliRun()->GetDetector("EMCAL"))->GetGeometry();
+  //fGeomPtr = AliEMCALGeometry::GetInstance();
+  fGeomPtr->GetTransformationForSM(); // Global <-> Local
 }
 
 //____________________________________________________________________________
@@ -87,10 +87,10 @@ AliEMCALRecPoint::AliEMCALRecPoint(const char * opt) : AliRecPoint(opt)
   fTime = -1. ;
   //fLocPos.SetX(1.e+6)  ;      //Local position should be evaluated
   fCoreRadius = 10;        //HG Check this
-  //fGeom = AliEMCALGeometry::GetInstance();
+  //fGeomPtr = AliEMCALGeometry::GetInstance();
   AliRunLoader *rl = AliRunLoader::GetRunLoader();
-  fGeom = dynamic_cast<AliEMCAL*>(rl->GetAliRun()->GetDetector("EMCAL"))->GetGeometry();
-  fGeom->GetTransformationForSM(); // Global <-> Local
+  fGeomPtr = dynamic_cast<AliEMCAL*>(rl->GetAliRun()->GetDetector("EMCAL"))->GetGeometry();
+  fGeomPtr->GetTransformationForSM(); // Global <-> Local
 }
 //____________________________________________________________________________
 AliEMCALRecPoint::~AliEMCALRecPoint()
@@ -118,7 +118,7 @@ void AliEMCALRecPoint::AddDigit(AliEMCALDigit & digit, Float_t Energy)
     fTimeList =  new Float_t[fMaxDigit]; 
   if(fAbsIdList == 0) {
     fAbsIdList =  new Int_t[fMaxDigit];
-    fSuperModuleNumber = fGeom->GetSuperModuleNumber(digit.GetId());
+    fSuperModuleNumber = fGeomPtr->GetSuperModuleNumber(digit.GetId());
   }
 
   if ( fMulDigit >= fMaxDigit ) { // increase the size of the lists 
@@ -183,11 +183,11 @@ Bool_t AliEMCALRecPoint::AreNeighbours(AliEMCALDigit * digit1, AliEMCALDigit * d
 
   areNeighbours = kFALSE ;
 
-  fGeom->GetCellIndex(digit1->GetId(), nSupMod,nTower,nIphi,nIeta);
-  fGeom->GetCellPhiEtaIndexInSModule(nSupMod,nTower,nIphi,nIeta, relid1[0],relid1[1]);
+  fGeomPtr->GetCellIndex(digit1->GetId(), nSupMod,nTower,nIphi,nIeta);
+  fGeomPtr->GetCellPhiEtaIndexInSModule(nSupMod,nTower,nIphi,nIeta, relid1[0],relid1[1]);
 
-  fGeom->GetCellIndex(digit2->GetId(), nSupMod1,nTower1,nIphi1,nIeta1);
-  fGeom->GetCellPhiEtaIndexInSModule(nSupMod1,nTower1,nIphi1,nIeta1, relid2[0],relid2[1]);
+  fGeomPtr->GetCellIndex(digit2->GetId(), nSupMod1,nTower1,nIphi1,nIeta1);
+  fGeomPtr->GetCellPhiEtaIndexInSModule(nSupMod1,nTower1,nIphi1,nIeta1, relid2[0],relid2[1]);
   
   rowdiff = TMath::Abs( relid1[0] - relid2[0] ) ;  
   coldiff = TMath::Abs( relid1[1] - relid2[1] ) ;  
@@ -375,7 +375,7 @@ void  AliEMCALRecPoint::EvalDispersion(Float_t logWeight, TClonesArray * digits)
   for(iDigit=0; iDigit < fMulDigit; iDigit++) {
     digit = (AliEMCALDigit *) digits->At(fDigitsList[iDigit])  ;
 
-    fGeom->RelPosCellInSModule(digit->GetId(), xyzi[0], xyzi[1], xyzi[2]);
+    fGeomPtr->RelPosCellInSModule(digit->GetId(), xyzi[0], xyzi[1], xyzi[2]);
     w = TMath::Max(0.,logWeight+TMath::Log(fEnergyList[iDigit]/fAmp ) ) ;
 
     if(w>0.0) {
@@ -407,7 +407,7 @@ void AliEMCALRecPoint::EvalLocalPosition(Float_t logWeight, TClonesArray * digit
   for(Int_t iDigit=0; iDigit<fMulDigit; iDigit++) {
     digit = dynamic_cast<AliEMCALDigit *>(digits->At(fDigitsList[iDigit])) ;
 
-    fGeom->RelPosCellInSModule(digit->GetId(), xyzi[0], xyzi[1], xyzi[2]);
+    fGeomPtr->RelPosCellInSModule(digit->GetId(), xyzi[0], xyzi[1], xyzi[2]);
     // printf(" Id %i : Local x,y,z %f %f %f \n", digit->GetId(), xyzi[0], xyzi[1], xyzi[2]);
 
     if(logWeight > 0.0) w = TMath::Max( 0., logWeight + TMath::Log( fEnergyList[iDigit] / fAmp ));
@@ -476,8 +476,8 @@ void AliEMCALRecPoint::EvalCoreEnergy(Float_t logWeight, TClonesArray * digits)
     
     Float_t ieta = 0.0;
     Float_t iphi = 0.0;
-    //fGeom->PosInAlice(digit->GetId(), ieta, iphi);
-    fGeom->EtaPhiFromIndex(digit->GetId(),ieta, iphi) ;
+    //fGeomPtr->PosInAlice(digit->GetId(), ieta, iphi);
+    fGeomPtr->EtaPhiFromIndex(digit->GetId(),ieta, iphi) ;
     iphi = iphi * kDeg2Rad;
   
     Float_t distance = TMath::Sqrt((ieta-fLocPos.X())*(ieta-fLocPos.X())+(iphi-fLocPos.Y())*(iphi-fLocPos.Y())) ;
@@ -501,7 +501,7 @@ void  AliEMCALRecPoint::EvalElipsAxis(Float_t logWeight,TClonesArray * digits)
   const Float_t kDeg2Rad = TMath::DegToRad();
   AliEMCALDigit * digit ;
 
-  TString gn(fGeom->GetName());
+  TString gn(fGeomPtr->GetName());
 
   Int_t iDigit;
   
@@ -514,12 +514,12 @@ void  AliEMCALRecPoint::EvalElipsAxis(Float_t logWeight,TClonesArray * digits)
     // for this geometry does not exist
       int nSupMod=0, nTower=0, nIphi=0, nIeta=0;
       int iphi=0, ieta=0;
-      fGeom->GetCellIndex(digit->GetId(), nSupMod,nTower,nIphi,nIeta);
-      fGeom->GetCellPhiEtaIndexInSModule(nSupMod,nTower,nIphi,nIeta, iphi,ieta);
+      fGeomPtr->GetCellIndex(digit->GetId(), nSupMod,nTower,nIphi,nIeta);
+      fGeomPtr->GetCellPhiEtaIndexInSModule(nSupMod,nTower,nIphi,nIeta, iphi,ieta);
       etai=(Float_t)ieta;
       phii=(Float_t)iphi;
     } else {
-      fGeom->EtaPhiFromIndex(digit->GetId(), etai, phii);
+      fGeomPtr->EtaPhiFromIndex(digit->GetId(), etai, phii);
       phii = phii * kDeg2Rad;
     }
 
@@ -685,7 +685,7 @@ void AliEMCALRecPoint::GetGlobalPosition(TVector3 & gpos) const
   // returns the position of the cluster in the global reference system of ALICE
   // These are now the Cartesian X, Y and Z
   //  cout<<" geom "<<geom<<endl;
-  fGeom->GetGlobal(fLocPos, gpos, fSuperModuleNumber);
+  fGeomPtr->GetGlobal(fLocPos, gpos, fSuperModuleNumber);
 }
 
 //____________________________________________________________________________
index 8318758..8ec9372 100644 (file)
@@ -100,7 +100,7 @@ protected:
          Float_t EtaToTheta(Float_t arg) const;  //Converts Eta (Radians) to Theta(Radians)
 
 private:
-          AliEMCALGeometry* fGeom;  //! Pointer to geometry for utilities
+          AliEMCALGeometry* fGeomPtr;  //! Pointer to geometry for utilities
 
           Int_t   fClusterType;    // type of cluster stored:
                                   // pseudocluster or v1
@@ -115,7 +115,7 @@ private:
           Int_t fMulParent;           // Multiplicity of the parents
           Int_t fMaxParent;           // Maximum number of parents allowed
           Int_t * fParentsList;       // [fMulParent] list of the parents of the digits
-          Int_t   fSuperModuleNumber; //
+          Int_t   fSuperModuleNumber; // number identifying supermodule containing recpoint
 
   ClassDef(AliEMCALRecPoint,7) // RecPoint for EMCAL (Base Class)
  
index 676cd71..1caebbf 100644 (file)
@@ -115,6 +115,7 @@ AliEMCALSDigitizer::AliEMCALSDigitizer(const AliEMCALSDigitizer & sd) : TTask(sd
 
 //____________________________________________________________________________ 
 AliEMCALSDigitizer::~AliEMCALSDigitizer() {
+  //dtor
   AliLoader *emcalLoader=0;
   if ((emcalLoader = AliRunLoader::GetRunLoader()->GetDetectorLoader("EMCAL")))
       emcalLoader->CleanSDigitizer();
@@ -146,6 +147,8 @@ void AliEMCALSDigitizer::Init(){
 //____________________________________________________________________________ 
 void AliEMCALSDigitizer::InitParameters()
 {
+  //initialize parameters for sdigitization
+
   const AliEMCALGeometry * geom = AliEMCALGeometry::GetInstance();
   if (geom->GetSampling() == 0.) {
     Fatal("InitParameters", "Sampling factor not set !") ; 
@@ -404,7 +407,9 @@ void AliEMCALSDigitizer::Browse(TBrowser* b)
 }
 
 TList *AliEMCALSDigitizer::BookControlHists(int var)
-{ // 22-nov-04
+{ 
+  //book histograms for monitoring sdigitization
+  // 22-nov-04
   gROOT->cd();
   const AliEMCALGeometry *geom = AliEMCALGeometry::GetInstance() ;
   if(var>=1){
index 8aa504a..5db9090 100644 (file)
 /* $Id$ */
 
 //_________________________________________________________________________
-// Auxiliary class to help calculate the time of crossing 
-// of the threshold by the front edge of the time signal
+// Auxiliary class to 
+// help calculate the 
+// time of crossing 
+// of the threshold by 
+// the front edge of the 
+// time signal
 //
 //*-- Author :  Dmitri Peressounko (SUBATECH) 
 //////////////////////////////////////////////////////////////////////////////
index f31d361..e873de7 100644 (file)
@@ -7,6 +7,8 @@
 
 //_________________________________________________________________________
 //  Class for EMCAL time digitization
+//  holds info on a single
+//  digit time bucket
 //                  
 //*-- Author: Dmitri Peressounko (SUBATECH)
 
index 3827c72..c1f4846 100644 (file)
@@ -50,6 +50,9 @@ class AliEMCALTrigger : public AliTriggerDetector {
   void            Print(const Option_t * opt ="") const ;  
   virtual void    Trigger();  //Make EMCAL trigger
 
+  //assignment operator for coding convention
+  const AliEMCALTrigger & operator = (const AliEMCALTrigger & ) {return *this;}
+
   //Getters
   Float_t  Get2x2MaxAmplitude()  const {return f2x2MaxAmp ; }
   Float_t  Get4x4MaxAmplitude()  const {return f4x4MaxAmp ; }
index 16dbdc2..4d9b36c 100644 (file)
@@ -812,7 +812,7 @@ int AliEMCALJetMicroDst::SaveListOfHists(TList *list,const char* name,Bool_t kSi
     file.Close();
   } else {
     printf("TAliasPAI::saveListOfHists : N O  S A V I N G \n");
-    if(list==0) printf("List of object 0 : %p \n", list);
+    if(list==0) printf("List of object 0 : %p \n", (void*)list);
     else printf("Size of list %i \n", list->GetSize());
   }
   return save;