Coding conventions (C.Oppedisano)

diff --git a/ZDC/AliGenZDC.cxx b/ZDC/AliGenZDC.cxx
index 9c09e047373fb943a5ea649a04b9ab331adf1d8f..7fb86efbb4009d24883ac9b03add1b30160f5e60 100644 (file)
--- a/ZDC/AliGenZDC.cxx
+++ b/ZDC/AliGenZDC.cxx
@@ -15,6 +15,13 @@
 
 /* $Id$ */
 
+//////////////////////////////////////////////////////////////////////
+//                                                                  //         //
+//      Generator of spectator nucleons (either protons or neutrons)//
+//        computes beam crossing and divergence and Fermi momentum  //
+//                                                                  //
+/////////////////////////////////////////////////////////////////////
+
 #include <assert.h>
 
 #include <TDatabasePDG.h>
@@ -74,6 +81,8 @@ AliGenZDC::AliGenZDC(Int_t npart)
 //_____________________________________________________________________________
 void AliGenZDC::Init()
 {
+  //Initialize Fermi momentum distributions for Pb-Pb
+  //
   printf("\n\n         AliGenZDC initialization:\n");
   printf("   Particle: %d, Track cosines: x = %f, y = %f, z = %f \n", 
         fIpart,fCosx,fCosy,fCosz);
@@ -81,7 +90,6 @@ void AliGenZDC::Init()
          "= %f, Crossing plane = %d\n\n", fFermiflag, fBeamDiv, fBeamCrossAngle,
         fBeamCrossPlane);
 
-  //Initialize Fermi momentum distributions for Pb-Pb
   FermiTwoGaussian(207.,fPp,fProbintp,fProbintn);
 }  
   
@@ -93,7 +101,7 @@ void AliGenZDC::Generate()
   //
   Int_t i;
 
-  Double_t Mass, pLab[3], fP0, fP[3], fBoostP[3], ddp[3], dddp0, dddp[3]; 
+  Double_t mass, pLab[3], fP0, fP[3], fBoostP[3], ddp[3], dddp0, dddp[3]; 
   Float_t  fPTrack[3], ptot = fPMin;
   Int_t nt;
   
@@ -128,10 +136,10 @@ void AliGenZDC::Generate()
   if(fFermiflag==1){
     if((fIpart==kProton) || (fIpart==kNeutron))
       ExtractFermi(fIpart,fPp,fProbintp,fProbintn,ddp);
-    Mass=gAlice->PDGDB()->GetParticle(fIpart)->Mass();
-    fP0 = TMath::Sqrt(fP[0]*fP[0]+fP[1]*fP[1]+fP[2]*fP[2]+Mass*Mass);
+    mass=gAlice->PDGDB()->GetParticle(fIpart)->Mass();
+    fP0 = TMath::Sqrt(fP[0]*fP[0]+fP[1]*fP[1]+fP[2]*fP[2]+mass*mass);
     for(i=0; i<=2; i++) dddp[i] = ddp[i];
-    dddp0 = TMath::Sqrt(dddp[0]*dddp[0]+dddp[1]*dddp[1]+dddp[2]*dddp[2]+Mass*Mass);
+    dddp0 = TMath::Sqrt(dddp[0]*dddp[0]+dddp[1]*dddp[1]+dddp[2]*dddp[2]+mass*mass);
     
     TVector3 b(fP[0]/fP0, fP[1]/fP0, fP[2]/fP0);
     TLorentzVector pFermi(dddp[0], dddp[1], dddp[2], dddp0);
@@ -239,6 +247,8 @@ void AliGenZDC::ExtractFermi(Int_t id, Double_t *fPp, Double_t *fProbintp,
 void AliGenZDC::BeamDivCross(Int_t icross, Float_t fBeamDiv, Float_t fBeamCrossAngle, 
                 Int_t fBeamCrossPlane, Double_t *pLab)
 {
+  // Applying beam divergence and crossing angle
+  //
   Double_t tetpart, fipart, tetdiv=0, fidiv=0, angleSum[2], tetsum, fisum;
   Double_t rvec;
 
@@ -293,7 +303,8 @@ void AliGenZDC::BeamDivCross(Int_t icross, Float_t fBeamDiv, Float_t fBeamCrossA
 //_____________________________________________________________________________
 void  AliGenZDC::AddAngle(Double_t theta1, Double_t phi1, Double_t theta2,
               Double_t phi2, Double_t *angleSum)
-{
+{ 
+  // Calculating the sum of 2 angles
   Double_t temp, conv, cx, cy, cz, ct1, st1, ct2, st2, cp1, sp1, cp2, sp2;
   Double_t rtetsum, tetsum, fisum;
   

diff --git a/ZDC/AliGenZDC.h b/ZDC/AliGenZDC.h
index 83ca30d23d66687d9ed6cc951e01053805e7aec3..c5cb311507ab11ee32085f665ad9ffa077bf47a0 100644 (file)
--- a/ZDC/AliGenZDC.h
+++ b/ZDC/AliGenZDC.h
@@ -49,8 +49,8 @@ public:
   void SetDebug(Int_t idebu) {fDebugOpt = idebu;};
   
   // Getters 
-  Double_t GetFermi2p(Int_t key) {return fProbintp[key];}
-  Double_t GetFermi2n(Int_t key) {return fProbintn[key];}
+  const Double_t GetFermi2p(Int_t key) {return fProbintp[key];}
+  const Double_t GetFermi2n(Int_t key) {return fProbintn[key];}
 
 protected:
   Int_t    fIpart;              // Particle to be generated
@@ -66,7 +66,7 @@ protected:
                                 // (=1 -> horizontal, =2 -> vertical plane)
   Double_t fProbintp[201];      // Protons momentum distribution due to Fermi 
   Double_t fProbintn[201];      // Neutrons momentum distribution due to Fermi 
-  Double_t fPp[201];            // 
+  Double_t fPp[201];            // Spectator momenta
   Int_t    fDebugOpt;          // Option for debugging [0->No debug, 1->Screen
                                //  prints, 2->ASCII data file]
   

diff --git a/ZDC/AliZDC.cxx b/ZDC/AliZDC.cxx
index b864f77f6864b6d04b0e385c9c7921f53ab65309..5947f2c7f204c33c2954348fc3199cfb8fb10e75 100644 (file)
--- a/ZDC/AliZDC.cxx
+++ b/ZDC/AliZDC.cxx
@@ -51,7 +51,7 @@
  
 ClassImp(AliZDC)
 
-AliZDC *gZDC;
+AliZDC *gAliZDC;
  
 //_____________________________________________________________________________
 AliZDC::AliZDC()
@@ -98,7 +98,7 @@ AliZDC::AliZDC(const char *name, const char *title)
   
   fCalibData  = 0;
 
-  gZDC=this;
+  gAliZDC=this;
 
 }
 //____________________________________________________________________________ 
@@ -109,7 +109,7 @@ AliZDC::~AliZDC()
   //
 
   fIshunt   = 0;
-  gZDC=0;
+  gAliZDC=0;
 
   delete fCalibData;
 
@@ -340,12 +340,12 @@ void AliZDC::Digits2Raw()
 
   // preliminary format: 12 interger values (ZNC, ZNQ1-4, ZPC, ZPQ1-4, ZEM1,2)
   // For the CAEN module V965 we have an header, the Data Words and an End Of Block
-  const int NADCData1=24, NADCData2=20;
+  const int knADCData1=24, knADCData2=20;
   UInt_t lADCHeader1; 
-  UInt_t lADCData1[NADCData1];
+  UInt_t lADCData1[knADCData1];
   //
   UInt_t lADCHeader2; 
-  UInt_t lADCData2[NADCData2];
+  UInt_t lADCData2[knADCData2];
   //
   UInt_t lADCEndBlock;
 
@@ -361,8 +361,8 @@ void AliZDC::Digits2Raw()
   // ADC header
   UInt_t lADCHeaderGEO = 0;
   UInt_t lADCHeaderCRATE = 0;
-  UInt_t lADCHeaderCNT1 = NADCData1;
-  UInt_t lADCHeaderCNT2 = NADCData2;
+  UInt_t lADCHeaderCNT1 = knADCData1;
+  UInt_t lADCHeaderCNT2 = knADCData2;
     
   lADCHeader1 = lADCHeaderGEO << 27 | 0x1 << 25 | lADCHeaderCRATE << 16 |
                lADCHeaderCNT1 << 8 ;
@@ -374,15 +374,15 @@ void AliZDC::Digits2Raw()
       
   // ADC data word
   UInt_t lADCDataGEO = lADCHeaderGEO;
-  UInt_t lADCDataValue1[NADCData1];
-  UInt_t lADCDataValue2[NADCData2];
-  UInt_t lADCDataOvFlw1[NADCData1];
-  UInt_t lADCDataOvFlw2[NADCData2];
-  for(Int_t i = 0; i<NADCData1 ; i++){
+  UInt_t lADCDataValue1[knADCData1];
+  UInt_t lADCDataValue2[knADCData2];
+  UInt_t lADCDataOvFlw1[knADCData1];
+  UInt_t lADCDataOvFlw2[knADCData2];
+  for(Int_t i = 0; i<knADCData1 ; i++){
     lADCDataValue1[i] = 0;
     lADCDataOvFlw1[i] = 0;
   }
-  for(Int_t i = 0; i<NADCData2 ; i++){
+  for(Int_t i = 0; i<knADCData2 ; i++){
     lADCDataValue2[i] = 0;
     lADCDataOvFlw2[i] = 0;
   }

diff --git a/ZDC/AliZDC.h b/ZDC/AliZDC.h
index ceb0829cae9cf970f6ed4661ee210cc3e8174972..8e0b2a269842eb742f5f06e58699edca65f6a14c 100644 (file)
--- a/ZDC/AliZDC.h
+++ b/ZDC/AliZDC.h
@@ -57,7 +57,7 @@ public:
 
 protected:
 
-  Int_t        fNoShower;      // Flag to switch off the shower        
+  Int_t        fNoShower;              // Flag to switch off the shower        
 
   //Calibration data member 
   AliZDCCalibData* fCalibData;         // Calibration data for ZDC

diff --git a/ZDC/AliZDCCalibData.cxx b/ZDC/AliZDCCalibData.cxx
index 0640ea66801c78c43018b23cef4ee7c23acb3d46..0af2b02b0115636211b9899664649994f1ff41f7 100644 (file)
--- a/ZDC/AliZDCCalibData.cxx
+++ b/ZDC/AliZDCCalibData.cxx
@@ -35,6 +35,7 @@ AliZDCCalibData::AliZDCCalibData()
 //________________________________________________________________
 AliZDCCalibData::AliZDCCalibData(const char* name)
 {
+  // Constructor
   TString namst = "Calib_";
   namst += name;
   SetName(namst.Data());
@@ -96,6 +97,7 @@ AliZDCCalibData::~AliZDCCalibData()
 //________________________________________________________________
 void AliZDCCalibData::Reset()
 {
+  // Reset
   memset(fMeanPedestal,0,47*sizeof(Float_t));
   memset(fMeanPedWidth,0,47*sizeof(Float_t));
   memset(fOOTPedestal,0,44*sizeof(Float_t));
@@ -125,6 +127,7 @@ void AliZDCCalibData::PrepHistos()
 //________________________________________________________________
 void  AliZDCCalibData::Print(Option_t *) const
 {
+   // Printing of calibration object
    printf("\n  ####### Mean pedestal values    ####### \n");
    for(int t=0; t<47; t++){
      if(t==0 || t==24) printf("\n\t -------- ZN HighRes -------- \n");
@@ -191,6 +194,7 @@ void AliZDCCalibData::SetOOTPedWidth(Float_t* OOTPedWidth)
 void AliZDCCalibData:: SetPedCorrCoeff(Float_t* PedCorrCoeff0, 
        Float_t* PedCorrCoeff1)
 {
+  // Set coefficients for pedestal correlations
   if(PedCorrCoeff0 && PedCorrCoeff1) for(int t=0; t<44; t++){
     fPedCorrCoeff[0][t] = PedCorrCoeff0[t];
     fPedCorrCoeff[1][t] = PedCorrCoeff1[t];

diff --git a/ZDC/AliZDCCalibData.h b/ZDC/AliZDCCalibData.h
index 117a557b0f9fd7d7ded4da94ed8eb47d341f5816..e95d6e09a2b62583b947b3bdcb5f0a97a7f87b2f 100644 (file)
--- a/ZDC/AliZDCCalibData.h
+++ b/ZDC/AliZDCCalibData.h
@@ -10,9 +10,10 @@
 
 #include "TNamed.h"
 #include "TH1.h"
-#include "AliZDC.h"
 #include "AliCDBEntry.h"
 
+class AliZDC;
+
 class AliZDCCalibData: public TNamed {
 
  public:

diff --git a/ZDC/AliZDCDigit.cxx b/ZDC/AliZDCDigit.cxx
index d765d0ada1f1722ce37a937ff8e5c9d47d353d1e..fa500347d38d5fe633a6a6c6e52adaca20dc86c0 100644 (file)
--- a/ZDC/AliZDCDigit.cxx
+++ b/ZDC/AliZDCDigit.cxx
@@ -13,12 +13,13 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-//_________________________________________________________________________
+//**********************************************************************
 //
+//             Class for ZDC digit 
+//           ADC Channels for each PM 
+//        5 for hadronic ZDCs 1 for EM ZDCs
 //
-//   ZDC digit = ADC Channels for each PM 
-//
-//_________________________________________________________________________
+//**********************************************************************
 
 #include "AliZDCDigit.h"
 
@@ -61,3 +62,4 @@ AliZDCDigit::AliZDCDigit(const AliZDCDigit & digit):TObject(digit)
   fADCValue[1] = digit.fADCValue[1];             
 
 }
+

diff --git a/ZDC/AliZDCDigit.h b/ZDC/AliZDCDigit.h
index 0d80a5508c222bf890d1744b07f3866047c4bc51..c8e78910425840c4a9ab84c7e01dc6150c8fbde6 100644 (file)
--- a/ZDC/AliZDCDigit.h
+++ b/ZDC/AliZDCDigit.h
@@ -3,12 +3,13 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-//_________________________________________________________________________
+//**********************************************************************
 //
+//             Class for ZDC digit 
+//           ADC Channels for each PM 
+//        5 for hadronic ZDCs 1 for EM ZDCs
 //
-//   ZDC digit = ADC Channels for each PM 
-//
-//_________________________________________________________________________
+//**********************************************************************
 
 #include<TObject.h>
 
@@ -22,22 +23,20 @@ class AliZDCDigit : public TObject {
   virtual ~AliZDCDigit() {}
 
   // Getters 
-  virtual Int_t   GetSector(Int_t i)        {return fSector[i];}
-  virtual Int_t   GetADCValue(Int_t i)      {return fADCValue[i];}
+  const Int_t   GetSector(Int_t i)       {return fSector[i];}
+  const Int_t   GetADCValue(Int_t i)      {return fADCValue[i];}
 
   // Operators
-  Int_t operator == (AliZDCDigit &digit) {
-    // Two digits are equal if they refers to the detector
-    // in the same sub-volume (same procedure as for hits)
+  // Two digits are equal if they refers to the detector
+  // in the same sub-volume (same procedure as for hits)
+  const Int_t operator == (AliZDCDigit &digit) {
     Int_t i;
     for(i=0; i<2; i++) if(fSector[i]!=digit.GetSector(i)) return 0;
     return 1;
   }
+  // Adds the amplitude of digits 
   virtual AliZDCDigit& operator + (AliZDCDigit &digit) {
-    // Adds the amplitude of digits 
-    for(Int_t i = 0; i < 2; i++){
-      fADCValue[i] += digit.fADCValue[i] ;
-    } 
+    for(Int_t i = 0; i < 2; i++) fADCValue[i] += digit.fADCValue[i];
     return *this ;
   }
   

diff --git a/ZDC/AliZDCDigitizer.cxx b/ZDC/AliZDCDigitizer.cxx
index 39bd6551091f29973521b1552e77b13176abcfea..ac5054cc702ccbc7bd6c50ba5e32fe9337d00266 100644 (file)
--- a/ZDC/AliZDCDigitizer.cxx
+++ b/ZDC/AliZDCDigitizer.cxx
@@ -37,13 +37,14 @@
 #include "AliRunDigitizer.h"
 #include "AliRunLoader.h"
 #include "AliCDBManager.h"
-#include "AliCDBStorage.h"
 #include "AliCDBEntry.h"
 #include "AliZDCSDigit.h"
 #include "AliZDCDigit.h"
 #include "AliZDCFragment.h"
 #include "AliZDCDigitizer.h"
-#include "AliZDCCalibData.h"
+
+class AliCDBStorage;
+class AliZDCCalibData;
 
 ClassImp(AliZDCDigitizer)
 
@@ -183,6 +184,7 @@ void AliZDCDigitizer::Exec(Option_t* /*option*/)
     SpectatorSignal(2, freeSpecP, pm);
   }
 
+
   // get the output run loader and loader
   AliRunLoader* runLoader = 
     AliRunLoader::GetRunLoader(fManager->GetOutputFolderName());
@@ -346,16 +348,17 @@ Int_t AliZDCDigitizer::Phe2ADCch(Int_t Det, Int_t Quad, Float_t Light,
                                  Int_t Res) const
 {
   // Evaluation of the ADC channel corresponding to the light yield Light
-  Int_t ADCch = (Int_t) (Light * fPMGain[Det-1][Quad] * fADCRes[Res]);
+  Int_t vADCch = (Int_t) (Light * fPMGain[Det-1][Quad] * fADCRes[Res]);
   //printf("\t Phe2ADCch -> det %d quad %d - phe %.0f  ADC %d\n", Det,Quad,Light,ADCch);
 
-  return ADCch;
+  return vADCch;
 }
 
 //_____________________________________________________________________________
 Int_t AliZDCDigitizer::Pedestal(Int_t Det, Int_t Quad, Int_t Res) const
 {
-  
+  // Returns a pedestal for detector det, PM quad, channel with res.
+  //
   Float_t meanPed;
   if(Det != 3) meanPed = fCalibData->GetMeanPed(10*(Det-1)+Quad+5*Res);
   else         meanPed = fCalibData->GetMeanPed(10*(Det-1)+Quad+1*Res);
@@ -399,7 +402,8 @@ AliCDBStorage* AliZDCDigitizer::SetStorage(const char *uri)
 //_____________________________________________________________________________
 AliZDCCalibData* AliZDCDigitizer::GetCalibData() const
 {
-
+  // returns pointer to AliZDCCalibData object
+  //
   AliCDBEntry  *entry = fStorage->Get("ZDC/Calib/Data",0);  
   AliZDCCalibData *calibdata = (AliZDCCalibData*) entry->GetObject();
     

diff --git a/ZDC/AliZDCFragment.cxx b/ZDC/AliZDCFragment.cxx
index df1f7b4b21b0bc95c2b87e5054c19e8605b3ec0a..7b1d67a43aa745773dd5e30da2786ef1f1d339b7 100644 (file)
--- a/ZDC/AliZDCFragment.cxx
+++ b/ZDC/AliZDCFragment.cxx
@@ -13,6 +13,13 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
+
+// ******************************************************************
+//
+//     Class for nuclear fragments formation
+//
+// ******************************************************************
+
 // --- Standard libraries
 #include <stdlib.h>
 
@@ -349,10 +356,12 @@ void AliZDCFragment::AttachNeutrons(Int_t *fZZ, Int_t *fNN, Int_t &fZtot,Int_t &
 }
 
 //_____________________________________________________________________________
-Float_t AliZDCFragment::DeuteronFraction()
+const Float_t AliZDCFragment::DeuteronFraction()
 {
-    Float_t DeuteronProdPar[2] = {1.068,0.0385};
-    Float_t DeutFrac = DeuteronProdPar[0]-DeuteronProdPar[1]*fB;
-    if(DeutFrac>1.) DeutFrac=1.;
-    return DeutFrac;
+    // Calculates the fraction of deuterum nucleus produced
+    //
+    Float_t deuteronProdPar[2] = {1.068,0.0385};
+    Float_t deutFrac = deuteronProdPar[0]-deuteronProdPar[1]*fB;
+    if(deutFrac>1.) deutFrac=1.;
+    return deutFrac;
 }

diff --git a/ZDC/AliZDCFragment.h b/ZDC/AliZDCFragment.h
index 79eafd056faa63640b18ab8becaf380420fea04d..b63d1c7f33b34cb400fd833f6414ca2555d63f03 100644 (file)
--- a/ZDC/AliZDCFragment.h
+++ b/ZDC/AliZDCFragment.h
@@ -24,13 +24,13 @@ public:
   virtual      ~AliZDCFragment() {}
   void GenerateIMF(Int_t* fZZ, Int_t &fNalpha);
   void AttachNeutrons(Int_t* fZZ, Int_t* fNN, Int_t &Ztot, Int_t &Ntot);
-  Float_t DeuteronFraction();
+  const Float_t DeuteronFraction();
   
   // Setting parameters
   virtual void SetImpactParameter(Float_t b) {fB=b;};
   
   // Getting parameters
-  Int_t GetFragmentNum() {return fNimf;};
+  const Int_t GetFragmentNum() {return fNimf;};
   
  
 protected:

diff --git a/ZDC/AliZDCHit.cxx b/ZDC/AliZDCHit.cxx
index fc16462be23bb046e480bc60604be9775c47dfb1..009e4ee691d014845b551cc69986b00736fcf749 100644 (file)
--- a/ZDC/AliZDCHit.cxx
+++ b/ZDC/AliZDCHit.cxx
@@ -15,11 +15,11 @@
 
 /* $Id$ */
 
+// **************************************************************
 //
-////////////////////////////////////////////////
-//  Hits classes for set ZDC                  //
-////////////////////////////////////////////////
+//             Hits classes for ZDC                  
 //
+// **************************************************************
 
 #include "AliZDCHit.h"
 
@@ -48,3 +48,14 @@ AliZDCHit::AliZDCHit(Int_t shunt, Int_t track, Int_t *vol, Float_t *hits):
   fEnergy      = hits[9]; 
   
 }
+  
+//_____________________________________________________________________________
+void AliZDCHit::Print(Option_t *) const 
+{
+   // Print method
+   printf(" -> HIT: vol[0] =  %d vol[1] =  %d Track: %d \n" 
+         "  Primary E = %f, Ximpact = %f, Yimpact = %f, SFlag = %f\n"
+          "  PMQLight = %f, PMCLight = %f,  Deposited E = %f\n ", 
+          fVolume[0],fVolume[1],fTrack,fPrimKinEn,fXImpact,fYImpact,
+          fSFlag,fLightPMQ,fLightPMC,fEnergy);
+}

diff --git a/ZDC/AliZDCHit.h b/ZDC/AliZDCHit.h
index e28f222191e24d34c37ff5b61e92a7c29109d83b..92b36d97316570c4aad6dea006dbd7a9d486cddb 100644 (file)
--- a/ZDC/AliZDCHit.h
+++ b/ZDC/AliZDCHit.h
@@ -36,7 +36,7 @@ public:
   virtual void SetYImpact(Float_t value)  {fYImpact=value;}
 
   // Operators
-  Int_t operator == (AliZDCHit &quad) {
+  const Int_t operator == (AliZDCHit &quad) {
      Int_t i;
      if(fTrack!=quad.GetTrack()) return 0;
      for(i=0; i<2; i++) if(fVolume[i]!=quad.GetVolume(i)) return 0;
@@ -51,13 +51,7 @@ public:
   }
 
   // Print method
-  virtual void Print(Option_t *) const {
-     printf(" -> HIT: vol[0] =  %d vol[1] =  %d Track: %d \n" 
-            "  Primary E = %f, Ximpact = %f, Yimpact = %f, SFlag = %f\n"
-           "  PMQLight = %f, PMCLight = %f,  Deposited E = %f\n ", 
-           fVolume[0],fVolume[1],fTrack,fPrimKinEn,fXImpact,fYImpact,
-           fSFlag,fLightPMQ,fLightPMC,fEnergy);
-  }
+  void Print(Option_t *) const;
 
 protected:
   // Data members

diff --git a/ZDC/AliZDCRawStream.cxx b/ZDC/AliZDCRawStream.cxx
index ac12ddf15e796fca393cabec58bb51e81e520c4c..c16d845146be7b115da5c235f952eb09d3b8edfc 100644 (file)
--- a/ZDC/AliZDCRawStream.cxx
+++ b/ZDC/AliZDCRawStream.cxx
@@ -101,16 +101,16 @@ Bool_t AliZDCRawStream::Next()
     fADCValue = (fRawADC & 0xfff);   
     fIsADCDataWord = kTRUE;
 
-    Int_t ADCChannel = (fRawADC & 0x1e0000) >> 17;
-    if (ADCChannel >= 0 && ADCChannel <= 4) { 
+    Int_t vADCChannel = (fRawADC & 0x1e0000) >> 17;
+    if (vADCChannel >= 0 && vADCChannel <= 4) { 
       fSector[0] = 1;
-      fSector[1] = ADCChannel;
-    } else if (ADCChannel >= 8 && ADCChannel <= 12) {
+      fSector[1] = vADCChannel;
+    } else if (vADCChannel >= 8 && vADCChannel <= 12) {
       fSector[0] = 2;
-      fSector[1] = ADCChannel-8;
-    } else if (ADCChannel == 5 || ADCChannel == 13){
+      fSector[1] = vADCChannel-8;
+    } else if (vADCChannel == 5 || vADCChannel == 13){
       fSector[0] = 3;
-      fSector[1] = (ADCChannel-5)/8;
+      fSector[1] = (vADCChannel-5)/8;
     }
   }
   return kTRUE;

diff --git a/ZDC/AliZDCTrigger.cxx b/ZDC/AliZDCTrigger.cxx
index 48c0340b6bdfd90988413ba5945679059dcea779..6fb4f0f5b48c39fd0cb7b756100d8f5c262d2b91 100644 (file)
--- a/ZDC/AliZDCTrigger.cxx
+++ b/ZDC/AliZDCTrigger.cxx
@@ -13,6 +13,12 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
+// ****************************************************************
+//
+//     Trigger class for ZDC
+//
+// ****************************************************************
+
 #include "AliLog.h"
 #include "AliRun.h"
 #include "AliLoader.h"
@@ -28,11 +34,11 @@ ClassImp(AliZDCTrigger)
 
 //________________________________________________________________
 AliZDCTrigger::AliZDCTrigger() : AliTriggerDetector() 
-{
+{  
+   // Constructor
    SetName("ZDC");
    CreateInputs();
    //
-   SetZNMinCut(0);
    SetZDCLeftMinCut(0);
    SetZDCRightMinCut(0);
    SetZEMMinCut(0);
@@ -51,7 +57,7 @@ AliZDCTrigger::AliZDCTrigger() : AliTriggerDetector()
 //________________________________________________________________
 void AliZDCTrigger::CreateInputs()
 {
-   // inputs 
+   // Trigger inputs
    
    // Do not create inputs again!!
    if( fInputs.GetEntriesFast() > 0 ) return;
@@ -66,89 +72,87 @@ void AliZDCTrigger::CreateInputs()
 void AliZDCTrigger::Trigger()
 {
 
-
+   // Trigger selection
+   //
    AliRunLoader *runLoader = gAlice->GetRunLoader();
 
-   AliLoader *ZDCLoader = runLoader->GetLoader("ZDCLoader");
-   ZDCLoader->LoadDigits("READ");
+   AliLoader *aZDCLoader = runLoader->GetLoader("ZDCLoader");
+   aZDCLoader->LoadDigits("READ");
    AliZDCDigit digit;
    AliZDCDigit* pdigit = &digit;
-   TTree* TD = ZDCLoader->TreeD();
-   if (!TD) cerr<<"AliZDCTrigger: digits tree not found\n";
-   TD->SetBranchAddress("ZDC", &pdigit);
+   TTree* tD = aZDCLoader->TreeD();
+   if (!tD) cerr<<"AliZDCTrigger: digits tree not found\n";
+   tD->SetBranchAddress("ZDC", &pdigit);
    //
-   Float_t ZNLeftSignal[2], ZPLeftSignal[2], ZDCLeftSumSignal[2];
-   Float_t ZNRightSignal[2], ZPRightSignal[2], ZDCRightSumSignal[2];
-   Float_t ZEMSumSignal[2];
-   for(Int_t iDigit=0; iDigit<TD->GetEntries(); iDigit++){
-      TD->GetEntry(iDigit);
+   Float_t signalZNLeft[2], signalZPLeft[2], signalZDCLeftSum[2];
+   Float_t signalZNRight[2], signalZPRight[2], signalZDCRightSum[2];
+   Float_t signalZEMSum[2];
+   for(Int_t iDigit=0; iDigit<tD->GetEntries(); iDigit++){
+      tD->GetEntry(iDigit);
       //
       // *** ZDC LEFT
       if(digit.GetSector(0)==1)
          for(Int_t i=0; i<2; i++){ //0=high range; 1=low range
-           ZNLeftSignal[i] += digit.GetADCValue(i);
-           ZDCLeftSumSignal[i] += digit.GetADCValue(i);
+           signalZNLeft[i] += digit.GetADCValue(i);
+           signalZDCLeftSum[i] += digit.GetADCValue(i);
          }
       else if(digit.GetSector(0)==2)
          for(Int_t i=0; i<2; i++){
-           ZPLeftSignal[i] += digit.GetADCValue(i);
-           ZDCLeftSumSignal[i] += digit.GetADCValue(i);
+           signalZPLeft[i] += digit.GetADCValue(i);
+           signalZDCLeftSum[i] += digit.GetADCValue(i);
          }
       else if(digit.GetSector(0)==3)
-         for(Int_t i=0; i<2; i++) ZEMSumSignal[i] += digit.GetADCValue(i);
+         for(Int_t i=0; i<2; i++) signalZEMSum[i] += digit.GetADCValue(i);
       // *** ZDC RIGHT
       else if(digit.GetSector(0)==4)
          for(Int_t i=0; i<2; i++){ //0=high range; 1=low range
-           ZNRightSignal[i] += digit.GetADCValue(i);
-           ZDCRightSumSignal[i] += digit.GetADCValue(i);
+           signalZNRight[i] += digit.GetADCValue(i);
+           signalZDCRightSum[i] += digit.GetADCValue(i);
          }
       else if(digit.GetSector(0)==5)
          for(Int_t i=0; i<2; i++){
-           ZPRightSignal[i] += digit.GetADCValue(i);
-           ZDCRightSumSignal[i] += digit.GetADCValue(i);
+           signalZPRight[i] += digit.GetADCValue(i);
+           signalZDCRightSum[i] += digit.GetADCValue(i);
          }
    }
    // *******************************************************************
-   if(ZNLeftSignal[0]>fZDCLeftEMDCuts[0] && ZNLeftSignal[0]<fZDCLeftEMDCuts[1] && 
-      ZNRightSignal[0]>fZDCRightEMDCuts[0] && ZNRightSignal[0]<fZDCRightEMDCuts[1] &&
-      ZEMSumSignal[1]<fZEMMinCut){ // *** 1n EMD trigger
+   if(signalZNLeft[0]>fZDCLeftEMDCuts[0] && signalZNLeft[0]<fZDCLeftEMDCuts[1] && 
+      signalZNRight[0]>fZDCRightEMDCuts[0] && signalZNRight[0]<fZDCRightEMDCuts[1] &&
+      signalZEMSum[1]<fZEMMinCut){ // *** 1n EMD trigger
         SetInput("ZDC_EMD_L1");
    }
    // *******************************************************************
-   if(ZDCLeftSumSignal[1]>fZDCLeftMBCut && ZDCRightSumSignal[1]>fZDCRightMBCut) 
+   if(signalZDCLeftSum[1]>fZDCLeftMBCut && signalZDCRightSum[1]>fZDCRightMBCut) 
        // *** ZDC minimum bias trigger
        SetInput("ZDC_1_L1");
    // *******************************************************************
-   if(ZDCLeftSumSignal[1]>fZDCLeftMinCut && ZDCLeftSumSignal[1]<fZDCLeftCentrCut &&
-      ZDCRightSumSignal[1]>fZDCRightMinCut && ZDCRightSumSignal[1]<fZDCRightCentrCut &&
-      ZEMSumSignal[1]>fZEMCentrCut) 
+   if(signalZDCLeftSum[1]>fZDCLeftMinCut && signalZDCLeftSum[1]<fZDCLeftCentrCut &&
+      signalZDCRightSum[1]>fZDCRightMinCut && signalZDCRightSum[1]<fZDCRightCentrCut &&
+      signalZEMSum[1]>fZEMCentrCut) 
        // *** ZDC central (0-10%)
        SetInput("ZDC_2_L1");
    // *******************************************************************
-   if(ZDCLeftSumSignal[1]>fZDCLeftCentrCut && ZDCLeftSumSignal[1]<fZDCLeftSemiCentrCut &&
-      ZDCRightSumSignal[1]>fZDCRightCentrCut && ZDCRightSumSignal[1]<fZDCRightSemiCentrCut
-      && ZEMSumSignal[1]>fZEMCentrCut) 
+   if(signalZDCLeftSum[1]>fZDCLeftCentrCut && signalZDCLeftSum[1]<fZDCLeftSemiCentrCut &&
+      signalZDCRightSum[1]>fZDCRightCentrCut && signalZDCRightSum[1]<fZDCRightSemiCentrCut
+      && signalZEMSum[1]>fZEMCentrCut) 
        // *** ZDC semi-central (10-40%)
        SetInput("ZDC_3_L1");
    
 }
 
-//________________________________________________________________
-void AliZDCTrigger::SetZNMinCut(Float_t ZNMinCut) 
-{
-  if(ZNMinCut)  fZNMinCut = ZNMinCut;
-  else  fZNMinCut = 400.;
-}
-
 //________________________________________________________________
 void AliZDCTrigger::SetZDCLeftMinCut(Float_t ZDCLeftMinCut) 
 {
+  // Set default cut values for ZDC trigger
+  //
   if(ZDCLeftMinCut)  fZDCLeftMinCut = ZDCLeftMinCut;
   else  fZDCLeftMinCut = 800.;
 }
 //________________________________________________________________
 void AliZDCTrigger::SetZDCRightMinCut(Float_t ZDCRightMinCut) 
 {
+  // Set default cut values for ZDC trigger
+  //
   if(ZDCRightMinCut)  fZDCRightMinCut = ZDCRightMinCut;
   else  fZDCRightMinCut = 800.;
 }
@@ -156,12 +160,16 @@ void AliZDCTrigger::SetZDCRightMinCut(Float_t ZDCRightMinCut)
 //________________________________________________________________
 void AliZDCTrigger::SetZEMMinCut(Float_t ZEMMinCut) 
 {
+  // Set default cut values for ZDC trigger
+  //
   if(ZEMMinCut)  fZEMMinCut = ZEMMinCut;
   else  fZEMMinCut = 80.;
 }
 //________________________________________________________________
 void AliZDCTrigger::SetZDCLeftEMDCuts(Float_t* ZDCLeftEMDCuts) 
 {
+  // Set default cut values for ZDC trigger
+  //
   if(ZDCLeftEMDCuts) for(int j=0; j<2; j++) fZDCLeftEMDCuts[j] = ZDCLeftEMDCuts[j];
   else{
     fZDCLeftEMDCuts[0] = 600.;
@@ -172,6 +180,8 @@ void AliZDCTrigger::SetZDCLeftEMDCuts(Float_t* ZDCLeftEMDCuts)
 void AliZDCTrigger::SetZDCLeftEMDCuts(Float_t ZDCLeftEMDCutInf, 
        Float_t ZDCLeftEMDCutSup) 
 {
+  // Set default cut values for ZDC trigger
+  //
   if(ZDCLeftEMDCutInf && ZDCLeftEMDCutSup){
     fZDCLeftEMDCuts[0]=ZDCLeftEMDCutInf; 
     fZDCLeftEMDCuts[1]=ZDCLeftEMDCutSup;
@@ -184,6 +194,8 @@ void AliZDCTrigger::SetZDCLeftEMDCuts(Float_t ZDCLeftEMDCutInf,
 //________________________________________________________________
 void AliZDCTrigger::SetZDCRightEMDCuts(Float_t* ZDCRightEMDCuts) 
 {
+  // Set default cut values for ZDC trigger
+  //
   if(ZDCRightEMDCuts) for(int j=0; j<2; j++) fZDCRightEMDCuts[j] = ZDCRightEMDCuts[j];
   else{
     fZDCRightEMDCuts[0] = 600.;
@@ -194,6 +206,8 @@ void AliZDCTrigger::SetZDCRightEMDCuts(Float_t* ZDCRightEMDCuts)
 void AliZDCTrigger::SetZDCRightEMDCuts(Float_t ZDCRightEMDCutInf, 
        Float_t ZDCRightEMDCutSup) 
 {
+  // Set default cut values for ZDC trigger
+  //
   if(ZDCRightEMDCutInf && ZDCRightEMDCutSup){
     fZDCRightEMDCuts[0]=ZDCRightEMDCutInf; 
     fZDCRightEMDCuts[1]=ZDCRightEMDCutSup;
@@ -206,42 +220,56 @@ void AliZDCTrigger::SetZDCRightEMDCuts(Float_t ZDCRightEMDCutInf,
 //________________________________________________________________
 void AliZDCTrigger::SetZDCLeftMBCut(Float_t ZDCLeftMBCut) 
 {
+  // Set default cut values for ZDC trigger
+  //
   if(ZDCLeftMBCut) fZDCLeftMBCut = ZDCLeftMBCut;
   else fZDCLeftMBCut = 800.;
 }
 //________________________________________________________________
 void AliZDCTrigger::SetZDCRightMBCut(Float_t ZDCRightMBCut) 
 {
+  // Set default cut values for ZDC trigger
+  //
   if(ZDCRightMBCut) fZDCRightMBCut = ZDCRightMBCut;
   else fZDCRightMBCut = 800.;
 }
 //________________________________________________________________
 void AliZDCTrigger::SetZDCLeftCentrCut(Float_t ZDCLeftCentrCut) 
 {
+  // Set default cut values for ZDC trigger
+  //
   if(ZDCLeftCentrCut) fZDCLeftCentrCut = ZDCLeftCentrCut;
   else fZDCLeftCentrCut = 10000.;
 }
 //________________________________________________________________
 void AliZDCTrigger::SetZDCRightCentrCut(Float_t ZDCRightCentrCut) 
 {
+  // Set default cut values for ZDC trigger
+  //
   if(ZDCRightCentrCut) fZDCRightCentrCut = ZDCRightCentrCut;
   else fZDCRightCentrCut = 10000.;
 }
 //________________________________________________________________
 void AliZDCTrigger::SetZDCLeftSemiCentrCut(Float_t ZDCLeftSemiCentrCut) 
 {
+  // Set default cut values for ZDC trigger
+  //
   if(ZDCLeftSemiCentrCut) fZDCLeftSemiCentrCut = ZDCLeftSemiCentrCut;
   else fZDCLeftSemiCentrCut = 18500.;
 }
 //________________________________________________________________
 void AliZDCTrigger::SetZDCRightSemiCentrCut(Float_t ZDCRightSemiCentrCut) 
 {
+  // Set default cut values for ZDC trigger
+  //
   if(ZDCRightSemiCentrCut) fZDCRightSemiCentrCut = ZDCRightSemiCentrCut;
   else fZDCRightSemiCentrCut = 18500.;
 }
 //________________________________________________________________
 void AliZDCTrigger::SetZEMCentrCut(Float_t ZEMCentrCut) 
 {
+  // Set default cut values for ZDC trigger
+  //
   if(ZEMCentrCut) fZEMCentrCut = ZEMCentrCut;
   else fZEMCentrCut = 210.;
 }

diff --git a/ZDC/AliZDCTrigger.h b/ZDC/AliZDCTrigger.h
index 88d035dc98659b127abc805aa439fe67d1768080..aec0737b8c792236d34baa3776429fed5dd2e10f 100644 (file)
--- a/ZDC/AliZDCTrigger.h
+++ b/ZDC/AliZDCTrigger.h
@@ -36,7 +36,6 @@ class AliZDCTrigger : public AliTriggerDetector
  protected:
    
    // Setters   
-   void SetZNMinCut(Float_t ZNMinCut);
    void SetZDCLeftMinCut(Float_t ZDCLeftMinCut);
    void SetZDCRightMinCut(Float_t ZDCRightMinCut);
    void SetZEMMinCut(Float_t ZEMMinCut);
@@ -53,19 +52,18 @@ class AliZDCTrigger : public AliTriggerDetector
    void SetZEMCentrCut(Float_t ZEMCentrCut);
 
    // Data member
-   Float_t fZNMinCut;   
-   Float_t fZDCLeftMinCut;   
-   Float_t fZDCRightMinCut;   
-   Float_t fZEMMinCut;   
-   Float_t fZDCLeftEMDCuts[2];
-   Float_t fZDCRightEMDCuts[2];
-   Float_t fZDCLeftMBCut;
-   Float_t fZDCRightMBCut;
-   Float_t fZDCLeftCentrCut;
-   Float_t fZDCRightCentrCut;
-   Float_t fZDCLeftSemiCentrCut;
-   Float_t fZDCRightSemiCentrCut;
-   Float_t fZEMCentrCut;   
+   Float_t fZDCLeftMinCut;     // ZDC left minimum bias   
+   Float_t fZDCRightMinCut;    // ZDC right minimum bias
+   Float_t fZEMMinCut;         // ZEM minimum bias
+   Float_t fZDCLeftEMDCuts[2]; // ZDC left windows for EMD signal
+   Float_t fZDCRightEMDCuts[2]; // ZDC right windows for EMD signal
+   Float_t fZDCLeftMBCut;      // ZDC left minimum bias trigger
+   Float_t fZDCRightMBCut;     // ZDC right minimum bias trigger
+   Float_t fZDCLeftCentrCut;   // ZDC left central trigger
+   Float_t fZDCRightCentrCut;  // ZDC right  central trigger
+   Float_t fZDCLeftSemiCentrCut;//  ZDC left semi-central trigger
+   Float_t fZDCRightSemiCentrCut;// ZDC right semi- central trigger
+   Float_t fZEMCentrCut;       // ZEM cut values
     
   ClassDef(AliZDCTrigger,1)  // ZDC Trigger Detector class
 };

diff --git a/ZDC/AliZDCv2.cxx b/ZDC/AliZDCv2.cxx
index af8f1182838caf1059e011517cda5291685a19de..cb2edbb549c61016d1ceeca0eef91da6feada8e4 100644 (file)
--- a/ZDC/AliZDCv2.cxx
+++ b/ZDC/AliZDCv2.cxx
@@ -39,14 +39,14 @@
 
 // --- AliRoot classes
 #include "AliConst.h"
-#include "AliDetector.h"
 #include "AliMagF.h"
-#include "AliPDG.h"
 #include "AliRun.h"
-#include "AliZDCHit.h"
 #include "AliZDCv2.h"
 #include "AliMC.h"
  
+class  AliZDCHit;
+class  AliPDG;
+class  AliDetector;
  
 ClassImp(AliZDCv2)