coding violations fix (changed naming, added comments, made methods const)
authordsilverm <dsilverm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 28 Oct 2009 16:38:12 +0000 (16:38 +0000)
committerdsilverm <dsilverm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 28 Oct 2009 16:38:12 +0000 (16:38 +0000)
EMCAL/AliCaloCalibPedestal.cxx
EMCAL/AliCaloCalibPedestal.h
EMCAL/AliCaloCalibSignal.cxx
EMCAL/AliCaloCalibSignal.h
EMCAL/AliEMCALCalibAbs.cxx
EMCAL/AliEMCALCalibMapAPD.cxx
EMCAL/AliEMCALCalibMapAPD.h
EMCAL/AliEMCALCalibReference.cxx
EMCAL/AliEMCALCalibTimeDepCorrection.cxx

index 27e2d89..1e2ac9d 100644 (file)
@@ -337,29 +337,29 @@ void AliCaloCalibPedestal::SetParametersFromFile(const char *parameterFile)
                
     while ( ( s.rdstate() & ios::failbit ) == 0 ) {
                        
-      string key_value; 
-      s >> key_value;
+      string keyValue; 
+      s >> keyValue;
       
       // check stream status
       if( s.rdstate() & ios::failbit ) break;
                        
       // skip rest of line if comments found
-      if( key_value.substr( 0, 2 ) == "//" ) break;
+      if( keyValue.substr( 0, 2 ) == "//" ) break;
                        
-      // look for "::" in key_value pair
-      size_t position = key_value.find( delimitor );
+      // look for "::" in keyValue pair
+      size_t position = keyValue.find( delimitor );
       if( position == string::npos ) {
-       printf("wrong format for key::value pair: %s\n", key_value.c_str());
+       printf("wrong format for key::value pair: %s\n", keyValue.c_str());
       }
                                
-      // split key_value pair
-      string key( key_value.substr( 0, position ) );
-      string value( key_value.substr( position+delimitor.size(), 
-                                     key_value.size()-delimitor.size() ) );
+      // split keyValue pair
+      string key( keyValue.substr( 0, position ) );
+      string value( keyValue.substr( position+delimitor.size(), 
+                                     keyValue.size()-delimitor.size() ) );
                        
       // check value does not contain a new delimitor
       if( value.find( delimitor ) != string::npos ) {
-       printf("wrong format for key::value pair: %s\n", key_value.c_str());
+       printf("wrong format for key::value pair: %s\n", keyValue.c_str());
       }
       
       // debug: check key value pair
index c7e8233..67fcb3e 100644 (file)
@@ -51,7 +51,7 @@ class AliCaloCalibPedestal : public TObject {
   Bool_t ProcessEvent(AliCaloRawStreamV3    *in);
   
   // Mapping handling
-  AliCaloAltroMapping **GetAltroMapping() { return fMapping; };
+  AliCaloAltroMapping **GetAltroMapping() const { return fMapping; };
   void  SetAltroMapping(AliCaloAltroMapping **mapp) { fMapping = mapp; };
 
   // Parameter/cut handling
index eef6e0b..906c46a 100644 (file)
@@ -207,7 +207,7 @@ void AliCaloCalibSignal::CreateTrees()
 
 //_____________________________________________________________________
 void AliCaloCalibSignal::ResetInfo()
-{
+{ // reset trees and counters
   Zero(); // set all counters to 0
   DeleteTrees(); // delete previous stuff
   CreateTrees(); // and create some new ones
@@ -233,19 +233,19 @@ void AliCaloCalibSignal::Zero()
 }
 
 //_____________________________________________________________________
-Bool_t AliCaloCalibSignal::CheckFractionAboveAmp(int *AmpVal, 
+Bool_t AliCaloCalibSignal::CheckFractionAboveAmp(const int *iAmpVal, 
                                                 int resultArray[])
-{
+{ // check fraction of towers, per column, that are above amplitude cut
   Bool_t returnCode = false;
     
-  int TowerNum = 0;
+  int iTowerNum = 0;
   double fraction = 0;
   for (int i = 0; i<fModules; i++) {
     for (int j = 0; j<fColumns; j++) {
       int nAbove = 0;
       for (int k = 0; k<fRows; k++) {
-       TowerNum = GetTowerNum(i,j,k);
-       if (AmpVal[TowerNum] > fAmpCut) { 
+       iTowerNum = GetTowerNum(i,j,k);
+       if (iAmpVal[iTowerNum] > fAmpCut) { 
          nAbove++;
        }
       }
@@ -270,7 +270,7 @@ Bool_t AliCaloCalibSignal::CheckFractionAboveAmp(int *AmpVal,
 // Parameter/cut handling
 //_____________________________________________________________________
 void AliCaloCalibSignal::SetParametersFromFile(const char *parameterFile)
-{
+{ // set parameters from file
   static const string delimitor("::");
        
   // open, check input file
@@ -296,29 +296,29 @@ void AliCaloCalibSignal::SetParametersFromFile(const char *parameterFile)
                
     while ( ( s.rdstate() & ios::failbit ) == 0 ) {
                        
-      string key_value; 
-      s >> key_value;
+      string keyValue; 
+      s >> keyValue;
       
       // check stream status
       if( s.rdstate() & ios::failbit ) break;
                        
       // skip rest of line if comments found
-      if( key_value.substr( 0, 2 ) == "//" ) break;
+      if( keyValue.substr( 0, 2 ) == "//" ) break;
                        
-      // look for "::" in key_value pair
-      size_t position = key_value.find( delimitor );
+      // look for "::" in keyValue pair
+      size_t position = keyValue.find( delimitor );
       if( position == string::npos ) {
-       printf("wrong format for key::value pair: %s\n", key_value.c_str());
+       printf("wrong format for key::value pair: %s\n", keyValue.c_str());
       }
                                
-      // split key_value pair
-      string key( key_value.substr( 0, position ) );
-      string value( key_value.substr( position+delimitor.size(), 
-                                     key_value.size()-delimitor.size() ) );
+      // split keyValue pair
+      string key( keyValue.substr( 0, position ) );
+      string value( keyValue.substr( position+delimitor.size(), 
+                                     keyValue.size()-delimitor.size() ) );
                        
       // check value does not contain a new delimitor
       if( value.find( delimitor ) != string::npos ) {
-       printf("wrong format for key::value pair: %s\n", key_value.c_str());
+       printf("wrong format for key::value pair: %s\n", keyValue.c_str());
       }
       
       // debug: check key value pair
@@ -350,7 +350,7 @@ void AliCaloCalibSignal::SetParametersFromFile(const char *parameterFile)
 
 //_____________________________________________________________________
 void AliCaloCalibSignal::WriteParametersToFile(const char *parameterFile)
-{
+{ // write parameters to file
   static const string delimitor("::");
   ofstream out( parameterFile );
   out << "// " << parameterFile << endl;
@@ -445,14 +445,14 @@ Bool_t AliCaloCalibSignal::ProcessEvent(AliCaloRawStreamV3 *in, UInt_t Timestamp
   fNEvents++; // one more event
 
   // use maximum numbers to set array sizes
-  int AmpValHighGain[fgkMaxTowers];
-  int AmpValLowGain[fgkMaxTowers];
-  memset(AmpValHighGain, 0, sizeof(AmpValHighGain));
-  memset(AmpValLowGain, 0, sizeof(AmpValLowGain));
+  int iAmpValHighGain[fgkMaxTowers];
+  int iAmpValLowGain[fgkMaxTowers];
+  memset(iAmpValHighGain, 0, sizeof(iAmpValHighGain));
+  memset(iAmpValLowGain, 0, sizeof(iAmpValLowGain));
 
   // also for LED reference
-  int LEDAmpVal[fgkMaxRefs * 2]; // factor 2 is for the two gain values
-  memset(LEDAmpVal, 0, sizeof(LEDAmpVal));
+  int iLEDAmpVal[fgkMaxRefs * 2]; // factor 2 is for the two gain values
+  memset(iLEDAmpVal, 0, sizeof(iLEDAmpVal));
 
   int sample; // temporary value
   int gain = 0; // high or low gain
@@ -461,8 +461,8 @@ Bool_t AliCaloCalibSignal::ProcessEvent(AliCaloRawStreamV3 *in, UInt_t Timestamp
   int nLowChan = 0; 
   int nHighChan = 0; 
 
-  int TowerNum = 0; // array index for regular towers
-  int RefNum = 0; // array index for LED references
+  int iTowerNum = 0; // array index for regular towers
+  int iRefNum = 0; // array index for LED references
 
   // loop first to get the fraction of channels with amplitudes above cut
 
@@ -510,23 +510,23 @@ Bool_t AliCaloCalibSignal::ProcessEvent(AliCaloRawStreamV3 *in, UInt_t Timestamp
 
       if ( in->IsHighGain() || in->IsLowGain() ) { // regular tower
        // get tower number for AmpVal array
-       TowerNum = GetTowerNum(arrayPos, in->GetColumn(), in->GetRow()); 
+       iTowerNum = GetTowerNum(arrayPos, in->GetColumn(), in->GetRow()); 
 
        if (gain == 0) {
          // fill amplitude into the array         
-         AmpValLowGain[TowerNum] = max - min;
+         iAmpValLowGain[iTowerNum] = max - min;
          nLowChan++;
        } 
        else if (gain==1) {//fill the high gain ones
          // fill amplitude into the array
-         AmpValHighGain[TowerNum] = max - min;
+         iAmpValHighGain[iTowerNum] = max - min;
          nHighChan++;
        }//end if gain
       } // regular tower
       else if ( in->IsLEDMonData() ) { // LED ref.; 
        // strip # is coded is 'column' in the channel maps 
-       RefNum = GetRefNum(arrayPos, in->GetColumn(), gain); 
-       LEDAmpVal[RefNum] = max - min;
+       iRefNum = GetRefNum(arrayPos, in->GetColumn(), gain); 
+       iLEDAmpVal[iRefNum] = max - min;
       } // end of LED ref
 
       } // nsamples>0 check, some data found for this channel; not only trailer/header      
@@ -547,7 +547,7 @@ Bool_t AliCaloCalibSignal::ProcessEvent(AliCaloRawStreamV3 *in, UInt_t Timestamp
   if (fReqFractionAboveAmp) {
     bool ok = false;
     if (nHighChan > 0) { 
-      ok = CheckFractionAboveAmp(AmpValHighGain, checkResultArray); 
+      ok = CheckFractionAboveAmp(iAmpValHighGain, checkResultArray); 
     }
     if (!ok) return false; // skip event
   }
@@ -569,19 +569,19 @@ Bool_t AliCaloCalibSignal::ProcessEvent(AliCaloRawStreamV3 *in, UInt_t Timestamp
       if (checkResultArray[i*fColumns + j] > 0) { // column passed check 
       for(int k=0; k<fRows; k++){
        
-       TowerNum = GetTowerNum(i, j, k); 
+       iTowerNum = GetTowerNum(i, j, k); 
 
-       if(AmpValHighGain[TowerNum]) {
-         fAmp = AmpValHighGain[TowerNum];
+       if(iAmpValHighGain[iTowerNum]) {
+         fAmp = iAmpValHighGain[iTowerNum];
          fChannelNum = GetChannelNum(i,j,k,1);
-         fTreeAmpVsTime->Fill();//fChannelNum,fHour,AmpValHighGain[TowerNum]);
-         fNHighGain[TowerNum]++;
+         fTreeAmpVsTime->Fill();//fChannelNum,fHour,AmpValHighGain[iTowerNum]);
+         fNHighGain[iTowerNum]++;
        }
-       if(AmpValLowGain[TowerNum]) {
-         fAmp = AmpValLowGain[TowerNum];
+       if(iAmpValLowGain[iTowerNum]) {
+         fAmp = iAmpValLowGain[iTowerNum];
          fChannelNum = GetChannelNum(i,j,k,0);
-         fTreeAmpVsTime->Fill();//fChannelNum,fHour,AmpValLowGain[TowerNum]);
-         fNLowGain[TowerNum]++;
+         fTreeAmpVsTime->Fill();//fChannelNum,fHour,AmpValLowGain[iTowerNum]);
+         fNLowGain[iTowerNum]++;
        }
       } // rows
       } // column passed check
@@ -600,8 +600,8 @@ Bool_t AliCaloCalibSignal::ProcessEvent(AliCaloRawStreamV3 *in, UInt_t Timestamp
       if ( (checkResultArray[i*fColumns + iColFirst]>0) || (checkResultArray[i*fColumns + iColFirst + 1]>0) ) { // at least one column in strip passed check 
       for (gain=0; gain<2; gain++) {
        fRefNum = GetRefNum(i, j, gain); 
-       if (LEDAmpVal[fRefNum]) {
-         fAmp = LEDAmpVal[fRefNum];
+       if (iLEDAmpVal[fRefNum]) {
+         fAmp = iLEDAmpVal[fRefNum];
          fTreeLEDAmpVsTime->Fill();//fRefNum,fHour,fAmp);
          fNRef[fRefNum]++;
        }
@@ -670,22 +670,22 @@ Bool_t AliCaloCalibSignal::Analyze()
   memset(profile, 0, sizeof(profile));
 
   char name[200]; // for profile id and title
-  int TowerNum = 0;
+  int iTowerNum = 0;
 
   for (int i = 0; i<fModules; i++) {
     for (int ic=0; ic<fColumns; ic++){
       for (int ir=0; ir<fRows; ir++) {
 
-       TowerNum = GetTowerNum(i, ic, ir);
+       iTowerNum = GetTowerNum(i, ic, ir);
        // high gain
-       if (fNHighGain[TowerNum] > 0) {
+       if (fNHighGain[iTowerNum] > 0) {
          fChannelNum = GetChannelNum(i, ic, ir, 1); 
          sprintf(name, "profileChan%d", fChannelNum);
          profile[fChannelNum] = new TProfile(name, name, numProfBins, timeMin, timeMax, "s");
        }
 
        // same for low gain
-       if (fNLowGain[TowerNum] > 0) {
+       if (fNLowGain[iTowerNum] > 0) {
          fChannelNum = GetChannelNum(i, ic, ir, 0); 
          sprintf(name, "profileChan%d", fChannelNum);
          profile[fChannelNum] = new TProfile(name, name, numProfBins, timeMin, timeMax, "s");
@@ -790,3 +790,24 @@ Bool_t AliCaloCalibSignal::Analyze()
 
   return kTRUE;
 }
+
+//_____________________________________________________________________
+Bool_t AliCaloCalibSignal::DecodeChannelNum(const int chanId, 
+                                           int *imod, int *icol, int *irow, int *igain) const  
+{ // return the module, column, row, and gain for a given channel number
+  *igain = chanId/(fModules*fColumns*fRows);
+  *imod = (chanId/(fColumns*fRows)) % fModules;
+  *icol = (chanId/fRows) % fColumns;
+  *irow = chanId % fRows;
+  return kTRUE;
+} 
+
+//_____________________________________________________________________
+Bool_t AliCaloCalibSignal::DecodeRefNum(const int refId, 
+                                       int *imod, int *istripMod, int *igain) const 
+{ // return the module, stripModule, and gain for a given reference number
+  *igain = refId/(fModules*fLEDRefs);
+  *imod = (refId/(fLEDRefs)) % fModules;
+  *istripMod = refId % fLEDRefs;
+  return kTRUE;
+} 
index c3e2297..f780a23 100644 (file)
@@ -45,10 +45,10 @@ class AliCaloCalibSignal : public TObject {
   // Event processing methods:
   Bool_t ProcessEvent(AliRawReader *rawReader);
   Bool_t ProcessEvent(AliCaloRawStreamV3 *in, UInt_t Timestamp); // added header for time info
-  Bool_t CheckFractionAboveAmp(int *AmpVal, int resultArray[]); // check fraction of signals to check for LED events
+  Bool_t CheckFractionAboveAmp(const int *AmpVal, int resultArray[]); // check fraction of signals to check for LED events
 
   // Mapping handling
-  AliCaloAltroMapping **GetAltroMapping() { return fMapping; };
+  AliCaloAltroMapping **GetAltroMapping() const { return fMapping; };
   void  SetAltroMapping(AliCaloAltroMapping **mapp) { fMapping = mapp; };
 
   // Parameter/cut handling
@@ -72,7 +72,7 @@ class AliCaloCalibSignal : public TObject {
   int GetNLowGain(int towId) const { return fNLowGain[towId];};        //!
 
   // also for LED reference
-  int GetNRef(int imod, int istripMod, int igain) const //!
+  int GetNRef(const int imod, const int istripMod, const int igain) //!
     { int refId = GetRefNum(imod, istripMod, igain); return fNRef[refId];}; //!
   int GetNRef(int refId) const { return fNRef[refId];}; //!
 
@@ -84,27 +84,19 @@ class AliCaloCalibSignal : public TObject {
   int GetRows() const {return fRows;}; //The number of rows per module
   int GetLEDRefs() const {return fLEDRefs;}; //The number of LED references/monitors per module
   int GetModules() const {return fModules;}; //The number of modules
-  int GetTowerNum(int imod, int icol, int irow) const { return (imod*fColumns*fRows + icol*fRows + irow);}; // help index
 
-  int GetChannelNum(int imod, int icol, int irow, int igain) const { return (igain*fModules*fColumns*fRows + imod*fColumns*fRows + icol*fRows + irow);}; // channel number with gain included
+  int GetTowerNum(const int imod, const int icol, const int irow) const { return (imod*fColumns*fRows + icol*fRows + irow);}; // help index
 
-  Bool_t DecodeChannelNum(int chanId, int *imod, int *icol, int *irow, int *igain) const {
-    *igain = chanId/(fModules*fColumns*fRows);
-    *imod = (chanId/(fColumns*fRows)) % fModules;
-    *icol = (chanId/fRows) % fColumns;
-    *irow = chanId % fRows;
-    return kTRUE;
-  }; // return the module, column, row, and gain for a given channel number
+  int GetChannelNum(const int imod, const int icol, const int irow, const int igain) const { return (igain*fModules*fColumns*fRows + imod*fColumns*fRows + icol*fRows + irow);}; // channel number with gain included
+
+  Bool_t DecodeChannelNum(const int chanId, 
+                         int *imod, int *icol, int *irow, int *igain) const; // return the module, column, row, and gain for a given channel number
 
   // LED reference indexing
-  int GetRefNum(int imod, int istripMod, int igain) const { return (igain*fModules*fLEDRefs + imod*fLEDRefs + istripMod);}; // channel number with gain included
-
-  Bool_t DecodeRefNum(int refId, int *imod, int *istripMod, int *igain) const {
-    *igain = refId/(fModules*fLEDRefs);
-    *imod = (refId/(fLEDRefs)) % fModules;
-    *istripMod = refId % fLEDRefs;
-    return kTRUE;
-  }; // return the module, stripModule, and gain for a given reference number
+  int GetRefNum(const int imod, const int istripMod, const int igain) const { return (igain*fModules*fLEDRefs + imod*fLEDRefs + istripMod);}; // channel number with gain included
+
+  Bool_t DecodeRefNum(const int refId, 
+                     int *imod, int *istripMod, int *igain) const; // return the module, stripModule, and gain for a given reference number
 
   // Basic Counters
   int GetNEvents() const {return fNEvents;};
index 889261d..b63b9b4 100644 (file)
@@ -61,11 +61,11 @@ void AliEMCALCalibAbs::ReadTextCalibAbsInfo(Int_t nSM, const TString &txtFileNam
 
   // list of values to be read
   // first: overall values for the whole SuperModule
-  Int_t CalibMethod; 
-  Int_t CalibPass; 
-  Float_t AbsoluteCalib; 
+  Int_t iCalibMethod; 
+  Int_t iCalibPass; 
+  Float_t absoluteCalib; 
   // third: info for each tower
-  Float_t RelativeCalib; // (ADC>GeV relative gain/conversion), value around 1
+  Float_t relativeCalib; // (ADC>GeV relative gain/conversion), value around 1
   // end - all values
 
   Int_t nAPDPerSM = AliEMCALGeoParams::fgkEMCALCols * AliEMCALGeoParams::fgkEMCALRows;
@@ -80,15 +80,15 @@ void AliEMCALCalibAbs::ReadTextCalibAbsInfo(Int_t nSM, const TString &txtFileNam
     t->SetSuperModuleNum(iSM);
 
     // first: overall values for the whole SuperModule
-    inputFile >> CalibMethod >> CalibPass >> AbsoluteCalib;
-    t->SetCalibMethod(CalibMethod);
-    t->SetCalibPass(CalibPass);
-    t->SetAbsoluteCalib(AbsoluteCalib);
+    inputFile >> iCalibMethod >> iCalibPass >> absoluteCalib;
+    t->SetCalibMethod(iCalibMethod);
+    t->SetCalibPass(iCalibPass);
+    t->SetAbsoluteCalib(absoluteCalib);
 
     // third: info for each tower
     for (Int_t j=0; j<nAPDPerSM; j++) {
       inputFile >> iCol >> iRow 
-               >> RelativeCalib;
+               >> relativeCalib;
 
       // assume that this info is already swapped and done for this basis?
       if (swapSides) {
@@ -97,7 +97,7 @@ void AliEMCALCalibAbs::ReadTextCalibAbsInfo(Int_t nSM, const TString &txtFileNam
        iRow = AliEMCALGeoParams::fgkEMCALRows-1 - iRow;
       }
 
-      t->SetRelativeCalib(iCol, iRow, RelativeCalib);
+      t->SetRelativeCalib(iCol, iRow, relativeCalib);
     }
 
   } // i, SuperModule
@@ -123,7 +123,7 @@ void AliEMCALCalibAbs::WriteTextCalibAbsInfo(const TString &txtFileName,
   Int_t iRow = 0;
 
   Int_t nAPDPerSM = AliEMCALGeoParams::fgkEMCALCols * AliEMCALGeoParams::fgkEMCALRows;
-  Float_t RelativeCalib = 0;
+  Float_t relativeCalib = 0;
   for (Int_t i = 0; i < fNSuperModule; i++) {
     AliEMCALSuperModuleCalibAbs * t = (AliEMCALSuperModuleCalibAbs*) fSuperModuleData[i];
 
@@ -138,7 +138,7 @@ void AliEMCALCalibAbs::WriteTextCalibAbsInfo(const TString &txtFileName,
       iCol = j / AliEMCALGeoParams::fgkEMCALRows;
       iRow = j % AliEMCALGeoParams::fgkEMCALRows;
 
-      RelativeCalib = t->GetRelativeCalib(iCol, iRow);
+      relativeCalib = t->GetRelativeCalib(iCol, iRow);
 
       if (swapSides) {
        // C side, oriented differently than A side: swap is requested
@@ -147,7 +147,7 @@ void AliEMCALCalibAbs::WriteTextCalibAbsInfo(const TString &txtFileName,
       }
 
       outputFile << iCol << " " << iRow 
-                << " " << RelativeCalib << endl;
+                << " " << relativeCalib << endl;
     }
 
   } // i, SuperModule
@@ -184,23 +184,23 @@ void AliEMCALCalibAbs::ReadTreeCalibAbsInfo(TTree *tree,
   Int_t iSM = 0; // SuperModule index
   // list of values to be read
   // first: overall values for the whole SuperModule
-  Int_t CalibMethod; 
-  Int_t CalibPass = 0; 
-  Float_t AbsoluteCalib = 0; 
+  Int_t iCalibMethod; 
+  Int_t iCalibPass = 0; 
+  Float_t absoluteCalib = 0; 
   // third: info for each tower
-  Float_t RelativeCalib[AliEMCALGeoParams::fgkEMCALCols][AliEMCALGeoParams::fgkEMCALRows]; 
+  Float_t relativeCalib[AliEMCALGeoParams::fgkEMCALCols][AliEMCALGeoParams::fgkEMCALRows]; 
   // end - all values
 
   // just to make the initializations of the arrays are done correctly, let's use memset
-  memset(RelativeCalib, 0, sizeof(RelativeCalib)); 
+  memset(relativeCalib, 0, sizeof(relativeCalib)); 
 
   // declare the branches
   tree->SetBranchAddress("iSM", &iSM);
-  tree->SetBranchAddress("CalibMethod", &CalibMethod);
-  tree->SetBranchAddress("CalibPass", &CalibPass);
-  tree->SetBranchAddress("AbsoluteCalib", &AbsoluteCalib);
+  tree->SetBranchAddress("CalibMethod", &iCalibMethod);
+  tree->SetBranchAddress("CalibPass", &iCalibPass);
+  tree->SetBranchAddress("AbsoluteCalib", &absoluteCalib);
   //
-  tree->SetBranchAddress("RelativeCalib", RelativeCalib);
+  tree->SetBranchAddress("RelativeCalib", relativeCalib);
 
   // indices for looping over the towers
   Int_t iCol = 0;
@@ -214,9 +214,9 @@ void AliEMCALCalibAbs::ReadTreeCalibAbsInfo(TTree *tree,
 
     t->SetSuperModuleNum(iSM);
     // first, overall values
-    t->SetCalibMethod(CalibMethod);
-    t->SetCalibPass(CalibPass);
-    t->SetAbsoluteCalib(AbsoluteCalib);
+    t->SetCalibMethod(iCalibMethod);
+    t->SetCalibPass(iCalibPass);
+    t->SetAbsoluteCalib(absoluteCalib);
 
     // third: info for each tower
     for (Int_t j=0; j<nAPDPerSM; j++) {
@@ -233,7 +233,7 @@ void AliEMCALCalibAbs::ReadTreeCalibAbsInfo(TTree *tree,
        iRowMod = AliEMCALGeoParams::fgkEMCALRows-1 - iRow;
       }
 
-      t->SetRelativeCalib(iColMod, iRowMod, RelativeCalib[iCol][iRow]);
+      t->SetRelativeCalib(iColMod, iRowMod, relativeCalib[iCol][iRow]);
     }
 
   } // loop over entries
@@ -258,15 +258,15 @@ void AliEMCALCalibAbs::WriteRootCalibAbsInfo(const TString &rootFileName,
   Int_t iSM = 0; // SuperModule index
   // list of values to be written
   // first: overall values for the whole SuperModule
-  Int_t CalibMethod = 0; 
-  Int_t CalibPass = 0; 
-  Float_t AbsoluteCalib = 0; 
+  Int_t iCalibMethod = 0; 
+  Int_t iCalibPass = 0; 
+  Float_t absoluteCalib = 0; 
   // third: info for each tower
-  Float_t RelativeCalib[AliEMCALGeoParams::fgkEMCALCols][AliEMCALGeoParams::fgkEMCALRows]; 
+  Float_t relativeCalib[AliEMCALGeoParams::fgkEMCALCols][AliEMCALGeoParams::fgkEMCALRows]; 
   // end - all values
 
   // just to make the initializations of the arrays are done correctly, let's use memset
-  memset(RelativeCalib, 0, sizeof(RelativeCalib)); 
+  memset(relativeCalib, 0, sizeof(relativeCalib)); 
 
   Int_t nAPDPerSM = AliEMCALGeoParams::fgkEMCALCols * AliEMCALGeoParams::fgkEMCALRows;
   // for looping over towers
@@ -276,20 +276,20 @@ void AliEMCALCalibAbs::WriteRootCalibAbsInfo(const TString &rootFileName,
   // declare the branches
   // first
   tree->Branch("iSM", &iSM, "iSM/I");
-  tree->Branch("CalibMethod", &CalibMethod, "CalibMethod/I");
-  tree->Branch("CalibPass", &CalibPass, "CalibPass/I");
-  tree->Branch("AbsoluteCalib", &AbsoluteCalib, "AbsoluteCalib/F");
+  tree->Branch("CalibMethod", &iCalibMethod, "CalibMethod/I");
+  tree->Branch("CalibPass", &iCalibPass, "CalibPass/I");
+  tree->Branch("AbsoluteCalib", &absoluteCalib, "AbsoluteCalib/F");
   // third: info for each tower; see if a 2D array works OK or if we'll have to use 1D arrays instead 
-  tree->Branch( "RelativeCalib", &RelativeCalib, Form("RelativeCalib[%d][%d]/F", AliEMCALGeoParams::fgkEMCALCols, AliEMCALGeoParams::fgkEMCALRows) );
+  tree->Branch( "RelativeCalib", &relativeCalib, Form("RelativeCalib[%d][%d]/F", AliEMCALGeoParams::fgkEMCALCols, AliEMCALGeoParams::fgkEMCALRows) );
 
   for (iSM = 0; iSM < fNSuperModule; iSM++) {
     AliEMCALSuperModuleCalibAbs * t = (AliEMCALSuperModuleCalibAbs*) fSuperModuleData[iSM];
 
     iSM = t->GetSuperModuleNum();
     // first, overall values
-    CalibMethod = t->GetCalibMethod();
-    CalibPass = t->GetCalibPass();
-    AbsoluteCalib = t->GetAbsoluteCalib();
+    iCalibMethod = t->GetCalibMethod();
+    iCalibPass = t->GetCalibPass();
+    absoluteCalib = t->GetAbsoluteCalib();
 
     // third: info for each tower
     for (Int_t j=0; j<nAPDPerSM; j++) {
@@ -306,7 +306,7 @@ void AliEMCALCalibAbs::WriteRootCalibAbsInfo(const TString &rootFileName,
        iRowMod = AliEMCALGeoParams::fgkEMCALRows-1 - iRow;
       }
 
-      RelativeCalib[iColMod][iRowMod] = t->GetRelativeCalib(iCol, iRow);
+      relativeCalib[iColMod][iRowMod] = t->GetRelativeCalib(iCol, iRow);
     }
 
     tree->Fill();
index 7c16fee..82b888b 100644 (file)
@@ -60,12 +60,12 @@ void AliEMCALCalibMapAPD::ReadTextCalibMapAPDInfo(Int_t nSM, const TString &txtF
   Int_t iRow = 0;
   // list of values to be read
   Int_t iHW = 0;
-  Int_t APDNum = 0;
-  Float_t V30 = 0;     
-  Float_t Par[3] = {0};   
-  Float_t ParErr[3] = {0}; 
-  Int_t BreakDown = 0;
-  Float_t DarkCurrent = 0; 
+  Int_t iAPDNum = 0;
+  Float_t v30 = 0;     
+  Float_t par[3] = {0};   
+  Float_t parErr[3] = {0}; 
+  Int_t iBreakDown = 0;
+  Float_t darkCurrent = 0; 
   // end - all values
 
   Int_t nAPDPerSM = AliEMCALGeoParams::fgkEMCALCols * AliEMCALGeoParams::fgkEMCALRows;
@@ -81,10 +81,10 @@ void AliEMCALCalibMapAPD::ReadTextCalibMapAPDInfo(Int_t nSM, const TString &txtF
 
     for (Int_t j=0; j<nAPDPerSM; j++) {
       inputFile >> iCol >> iRow >> iHW 
-               >> APDNum >> V30 
-               >> Par[0] >> Par[1] >> Par[2]
-               >> ParErr[0] >> ParErr[1] >> ParErr[2]
-               >> BreakDown >> DarkCurrent;
+               >> iAPDNum >> v30 
+               >> par[0] >> par[1] >> par[2]
+               >> parErr[0] >> parErr[1] >> parErr[2]
+               >> iBreakDown >> darkCurrent;
 
       // assume that this info is already swapped and done for this basis?
       if (swapSides) {
@@ -96,16 +96,16 @@ void AliEMCALCalibMapAPD::ReadTextCalibMapAPDInfo(Int_t nSM, const TString &txtF
       AliEMCALCalibMapAPDVal * v = t->GetAPDVal(iCol, iRow);
 
       v->SetHardWareId(iHW);
-      v->SetAPDNum(APDNum);
-      v->SetV30(V30);
-      v->SetPar(0, Par[0]);
-      v->SetPar(1, Par[1]);
-      v->SetPar(2, Par[2]);
-      v->SetParErr(0, ParErr[0]);
-      v->SetParErr(1, ParErr[1]);
-      v->SetParErr(2, ParErr[2]);
-      v->SetBreakDown(BreakDown);
-      v->SetDarkCurrent(DarkCurrent);
+      v->SetAPDNum(iAPDNum);
+      v->SetV30(v30);
+      v->SetPar(0, par[0]);
+      v->SetPar(1, par[1]);
+      v->SetPar(2, par[2]);
+      v->SetParErr(0, parErr[0]);
+      v->SetParErr(1, parErr[1]);
+      v->SetParErr(2, parErr[2]);
+      v->SetBreakDown(iBreakDown);
+      v->SetDarkCurrent(darkCurrent);
     }
 
   } // i, SuperModule
@@ -191,12 +191,12 @@ void AliEMCALCalibMapAPD::ReadTreeCalibMapAPDInfo(TTree *tree,
   Int_t iRow = 0;
   // list of values to be read
   Int_t iHW = 0;
-  Int_t APDNum = 0;
-  Float_t V30 = 0;     
-  Float_t Par[3] = {0};   
-  Float_t ParErr[3] = {0}; 
-  Int_t BreakDown = 0;
-  Float_t DarkCurrent = 0; 
+  Int_t iAPDNum = 0;
+  Float_t v30 = 0;     
+  Float_t par[3] = {0};   
+  Float_t parErr[3] = {0}; 
+  Int_t iBreakDown = 0;
+  Float_t darkCurrent = 0; 
   // end - all values
 
   // declare the branches
@@ -204,12 +204,12 @@ void AliEMCALCalibMapAPD::ReadTreeCalibMapAPDInfo(TTree *tree,
   tree->SetBranchAddress("iCol", &iCol);
   tree->SetBranchAddress("iRow", &iRow);
   tree->SetBranchAddress("iHW", &iHW);
-  tree->SetBranchAddress("APDNum", &APDNum);
-  tree->SetBranchAddress("V30", &V30);
-  tree->SetBranchAddress("Par", Par);
-  tree->SetBranchAddress("ParErr", ParErr);
-  tree->SetBranchAddress("BreakDown", &BreakDown);
-  tree->SetBranchAddress("DarkCurrent", &DarkCurrent);
+  tree->SetBranchAddress("APDNum", &iAPDNum);
+  tree->SetBranchAddress("V30", &v30);
+  tree->SetBranchAddress("Par", par);
+  tree->SetBranchAddress("ParErr", parErr);
+  tree->SetBranchAddress("BreakDown", &iBreakDown);
+  tree->SetBranchAddress("DarkCurrent", &darkCurrent);
 
   for (int ient=0; ient<tree->GetEntries(); ient++) {
     tree->GetEntry(ient);
@@ -228,16 +228,16 @@ void AliEMCALCalibMapAPD::ReadTreeCalibMapAPDInfo(TTree *tree,
     AliEMCALCalibMapAPDVal * v = t->GetAPDVal(iCol, iRow);
 
     v->SetHardWareId(iHW);
-    v->SetAPDNum(APDNum);
-    v->SetV30(V30);
-    v->SetPar(0, Par[0]);
-    v->SetPar(1, Par[1]);
-    v->SetPar(2, Par[2]);
-    v->SetParErr(0, ParErr[0]);
-    v->SetParErr(1, ParErr[1]);
-    v->SetParErr(2, ParErr[2]);
-    v->SetBreakDown(BreakDown);
-    v->SetDarkCurrent(DarkCurrent);
+    v->SetAPDNum(iAPDNum);
+    v->SetV30(v30);
+    v->SetPar(0, par[0]);
+    v->SetPar(1, par[1]);
+    v->SetPar(2, par[2]);
+    v->SetParErr(0, parErr[0]);
+    v->SetParErr(1, parErr[1]);
+    v->SetParErr(2, parErr[2]);
+    v->SetBreakDown(iBreakDown);
+    v->SetDarkCurrent(darkCurrent);
   } // 
 
   return;
@@ -259,12 +259,12 @@ void AliEMCALCalibMapAPD::WriteRootCalibMapAPDInfo(const TString &rootFileName,
   // variables for filling the TTree
   Int_t iSM = 0; // SuperModule index
   Int_t iHW = 0;
-  Int_t APDNum = 0;
-  Float_t V30 = 0;     
-  Float_t Par[3] = {0};   
-  Float_t ParErr[3] = {0}; 
-  Int_t BreakDown = 0;
-  Float_t DarkCurrent = 0; 
+  Int_t iAPDNum = 0;
+  Float_t v30 = 0;     
+  Float_t par[3] = {0};   
+  Float_t parErr[3] = {0}; 
+  Int_t iBreakDown = 0;
+  Float_t darkCurrent = 0; 
   //
   Int_t iCol = 0;
   Int_t iRow = 0;
@@ -273,12 +273,12 @@ void AliEMCALCalibMapAPD::WriteRootCalibMapAPDInfo(const TString &rootFileName,
   tree->Branch("iCol", &iCol, "iCol/I");
   tree->Branch("iRow", &iRow, "iRow/I");
   tree->Branch("iHW", &iHW, "iHW/I");
-  tree->Branch("APDNum", &APDNum, "APDNum/I");
-  tree->Branch("V30", &V30, "V30/F");
-  tree->Branch("Par", &Par, "Par[3]/F");
-  tree->Branch("ParErr", &ParErr, "ParErr[3]/F");
-  tree->Branch("BreakDown", &BreakDown, "BreakDown/I");
-  tree->Branch("DarkCurrent", &DarkCurrent, "DarkCurrent/F");
+  tree->Branch("APDNum", &iAPDNum, "APDNum/I");
+  tree->Branch("V30", &v30, "V30/F");
+  tree->Branch("Par", &par, "Par[3]/F");
+  tree->Branch("ParErr", &parErr, "ParErr[3]/F");
+  tree->Branch("BreakDown", &iBreakDown, "BreakDown/I");
+  tree->Branch("DarkCurrent", &darkCurrent, "DarkCurrent/F");
 
   Int_t nAPDPerSM = AliEMCALGeoParams::fgkEMCALCols * AliEMCALGeoParams::fgkEMCALRows;
 
@@ -298,14 +298,14 @@ void AliEMCALCalibMapAPD::WriteRootCalibMapAPDInfo(const TString &rootFileName,
       }
 
       iHW = v->GetHardWareId(); 
-      APDNum = v->GetAPDNum();
-      V30 = v->GetV30();
+      iAPDNum = v->GetAPDNum();
+      v30 = v->GetV30();
       for (int k=0; k<3; k++) {
-       Par[k] = v->GetPar(k);
-       ParErr[k] = v->GetParErr(k);
+       par[k] = v->GetPar(k);
+       parErr[k] = v->GetParErr(k);
       } 
-      BreakDown = v->GetBreakDown();
-      DarkCurrent = v->GetDarkCurrent();
+      iBreakDown = v->GetBreakDown();
+      darkCurrent = v->GetDarkCurrent();
 
       tree->Fill();
     }
index 89f4591..7b99ce3 100644 (file)
@@ -14,7 +14,9 @@ class TString;
 class TTree;
 
 /*
-  Objects of this class contain info on APD calibration and map info
+  Objects of this class contain info on APD calibration and map info,
+  such as V30 and other parameters from the tests in Catania/Houston,
+  as well as info on which APD is located where.  
 */
 
 // ******* internal class definition *************
@@ -95,8 +97,8 @@ class AliEMCALSuperModuleCalibMapAPD : public TObject {
     { return &fAPDVal[icol][irow]; };
 
  private:
-  Int_t fSuperModuleNum;
-  AliEMCALCalibMapAPDVal fAPDVal[AliEMCALGeoParams::fgkEMCALCols][AliEMCALGeoParams::fgkEMCALRows];
+  Int_t fSuperModuleNum; // SuperModule index
+  AliEMCALCalibMapAPDVal fAPDVal[AliEMCALGeoParams::fgkEMCALCols][AliEMCALGeoParams::fgkEMCALRows]; // APD calibration info
   
   ClassDef(AliEMCALSuperModuleCalibMapAPD, 2) // help class
 };
@@ -123,13 +125,12 @@ public:
   // pointer to stored info.
   Int_t GetNSuperModule() const { return fNSuperModule; }; 
 
-  // - via the index in the stored array:
+  // on a SuperModule level
   virtual AliEMCALSuperModuleCalibMapAPD * GetSuperModuleCalibMapAPDId(Int_t smIndex) const
-   { return (AliEMCALSuperModuleCalibMapAPD*) fSuperModuleData[smIndex]; };
-
-  // - or via the actual SM number
-  virtual AliEMCALSuperModuleCalibMapAPD * GetSuperModuleCalibMapAPDNum(Int_t smNum) const;
+    { return (AliEMCALSuperModuleCalibMapAPD*) fSuperModuleData[smIndex]; }; // - via the index in the stored array:
 
+  virtual AliEMCALSuperModuleCalibMapAPD * GetSuperModuleCalibMapAPDNum(Int_t smNum) const;   // - or via the actual SM number
+  
   // method to calculate gain M from fit parameters, and HV value
   Float_t GetGain(Float_t fitPar[3], Float_t HV) const 
     { return (fitPar[0] + fitPar[1] * exp(fitPar[2]*HV)); };
index 9c84dcf..b0c3d23 100644 (file)
@@ -62,17 +62,17 @@ void AliEMCALCalibReference::ReadTextCalibReferenceInfo(Int_t nSM, const TString
 
   // list of values to be read
   // first: overall values for the whole SuperModule
-  Int_t ReferenceTime; 
+  Int_t iReferenceTime; 
   // second: additional info for LED Reference and SM temperature
-  Float_t LEDRefAmp;
-  Float_t LEDRefAmpRMS;
-  Int_t LEDRefHighLow;
-  Float_t Temperature;
-  Float_t TemperatureRMS;
+  Float_t rLEDRefAmp;
+  Float_t rLEDRefAmpRMS;
+  Int_t iLEDRefHighLow;
+  Float_t temperature;
+  Float_t temperatureRMS;
   // third: info for each tower
-  Int_t HighLow; // 
-  Float_t LEDAmp; // low gain eq. amplitude
-  Float_t LEDAmpRMS; //
+  Int_t iHighLow; // 
+  Float_t rLEDAmp; // low gain eq. amplitude
+  Float_t rLEDAmpRMS; //
   // end - all values
 
   Int_t nAPDPerSM = AliEMCALGeoParams::fgkEMCALCols * AliEMCALGeoParams::fgkEMCALRows;
@@ -87,26 +87,26 @@ void AliEMCALCalibReference::ReadTextCalibReferenceInfo(Int_t nSM, const TString
     t->SetSuperModuleNum(iSM);
 
     // first: overall values for the whole SuperModule
-    inputFile >> ReferenceTime;
-    t->SetReferenceTime(ReferenceTime);
+    inputFile >> iReferenceTime;
+    t->SetReferenceTime(iReferenceTime);
 
     // second: additional info for LED Reference and SM temperature
     for (Int_t j=0; j<AliEMCALGeoParams::fgkEMCALLEDRefs; j++) {
-      inputFile >> id >> LEDRefHighLow >> LEDRefAmp >> LEDRefAmpRMS;
-      t->SetLEDRefHighLow(id, LEDRefHighLow);
-      t->SetLEDRefAmp(id, LEDRefAmp);
-      t->SetLEDRefAmpRMS(id, LEDRefAmpRMS);
+      inputFile >> id >> iLEDRefHighLow >> rLEDRefAmp >> rLEDRefAmpRMS;
+      t->SetLEDRefHighLow(id, iLEDRefHighLow);
+      t->SetLEDRefAmp(id, rLEDRefAmp);
+      t->SetLEDRefAmpRMS(id, rLEDRefAmpRMS);
     }
     for (Int_t j=0; j<AliEMCALGeoParams::fgkEMCALTempSensors; j++) {
-      inputFile >> id >> Temperature >> TemperatureRMS;
-      t->SetTemperature(id, Temperature);
-      t->SetTemperatureRMS(id, TemperatureRMS);
+      inputFile >> id >> temperature >> temperatureRMS;
+      t->SetTemperature(id, temperature);
+      t->SetTemperatureRMS(id, temperatureRMS);
     }
 
     // third: info for each tower
     for (Int_t j=0; j<nAPDPerSM; j++) {
       inputFile >> iCol >> iRow 
-               >> HighLow >> LEDAmp >> LEDAmpRMS;
+               >> iHighLow >> rLEDAmp >> rLEDAmpRMS;
 
       // assume that this info is already swapped and done for this basis?
       if (swapSides) {
@@ -117,9 +117,9 @@ void AliEMCALCalibReference::ReadTextCalibReferenceInfo(Int_t nSM, const TString
 
       AliEMCALCalibReferenceVal * v = t->GetAPDVal(iCol, iRow);
 
-      v->SetHighLow(HighLow);
-      v->SetLEDAmp(LEDAmp);
-      v->SetLEDAmpRMS(LEDAmpRMS);
+      v->SetHighLow(iHighLow);
+      v->SetLEDAmp(rLEDAmp);
+      v->SetLEDAmpRMS(rLEDAmpRMS);
     }
 
   } // i, SuperModule
@@ -216,42 +216,42 @@ void AliEMCALCalibReference::ReadTreeCalibReferenceInfo(TTree *tree,
   Int_t iSM = 0; // SuperModule index
   // list of values to be read
   // first: overall values for the whole SuperModule
-  Int_t ReferenceTime= {0}; 
+  Int_t iReferenceTime= {0}; 
   // second: additional info for LED Reference and SM temperature
-  Float_t LEDRefAmp[AliEMCALGeoParams::fgkEMCALLEDRefs]= {0};
-  Float_t LEDRefAmpRMS[AliEMCALGeoParams::fgkEMCALLEDRefs]= {0};
-  Int_t LEDRefHighLow[AliEMCALGeoParams::fgkEMCALLEDRefs]= {0};
-  Float_t Temperature[AliEMCALGeoParams::fgkEMCALTempSensors]= {0};
-  Float_t TemperatureRMS[AliEMCALGeoParams::fgkEMCALTempSensors]= {0};
+  Float_t rLEDRefAmp[AliEMCALGeoParams::fgkEMCALLEDRefs]= {0};
+  Float_t rLEDRefAmpRMS[AliEMCALGeoParams::fgkEMCALLEDRefs]= {0};
+  Int_t iLEDRefHighLow[AliEMCALGeoParams::fgkEMCALLEDRefs]= {0};
+  Float_t temperature[AliEMCALGeoParams::fgkEMCALTempSensors]= {0};
+  Float_t temperatureRMS[AliEMCALGeoParams::fgkEMCALTempSensors]= {0};
   // third: info for each tower
-  Int_t HighLow[AliEMCALGeoParams::fgkEMCALCols][AliEMCALGeoParams::fgkEMCALRows]; 
-  Float_t LEDAmp[AliEMCALGeoParams::fgkEMCALCols][AliEMCALGeoParams::fgkEMCALRows]; 
-  Float_t LEDAmpRMS[AliEMCALGeoParams::fgkEMCALCols][AliEMCALGeoParams::fgkEMCALRows]; 
+  Int_t iHighLow[AliEMCALGeoParams::fgkEMCALCols][AliEMCALGeoParams::fgkEMCALRows]; 
+  Float_t rLEDAmp[AliEMCALGeoParams::fgkEMCALCols][AliEMCALGeoParams::fgkEMCALRows]; 
+  Float_t rLEDAmpRMS[AliEMCALGeoParams::fgkEMCALCols][AliEMCALGeoParams::fgkEMCALRows]; 
   // end - all values
 
   // just to make the initializations of the arrays are done correctly, let's use memset
-  memset(LEDRefAmp, 0, sizeof(LEDRefAmp)); 
-  memset(LEDRefAmpRMS, 0, sizeof(LEDRefAmpRMS)); 
-  memset(LEDRefHighLow, 0, sizeof(LEDRefHighLow)); 
-  memset(Temperature, 0, sizeof(Temperature)); 
-  memset(TemperatureRMS, 0, sizeof(TemperatureRMS)); 
-  memset(HighLow, 0, sizeof(HighLow)); 
-  memset(LEDAmp, 0, sizeof(LEDAmp)); 
-  memset(LEDAmpRMS, 0, sizeof(LEDAmpRMS)); 
+  memset(rLEDRefAmp, 0, sizeof(rLEDRefAmp)); 
+  memset(rLEDRefAmpRMS, 0, sizeof(rLEDRefAmpRMS)); 
+  memset(iLEDRefHighLow, 0, sizeof(iLEDRefHighLow)); 
+  memset(temperature, 0, sizeof(temperature)); 
+  memset(temperatureRMS, 0, sizeof(temperatureRMS)); 
+  memset(iHighLow, 0, sizeof(iHighLow)); 
+  memset(rLEDAmp, 0, sizeof(rLEDAmp)); 
+  memset(rLEDAmpRMS, 0, sizeof(rLEDAmpRMS)); 
 
   // declare the branches
   tree->SetBranchAddress("iSM", &iSM);
-  tree->SetBranchAddress("ReferenceTime", &ReferenceTime);
+  tree->SetBranchAddress("ReferenceTime", &iReferenceTime);
   //
-  tree->SetBranchAddress("LEDRefAmp", LEDRefAmp);
-  tree->SetBranchAddress("LEDRefAmpRMS", LEDRefAmpRMS);
-  tree->SetBranchAddress("LEDRefHighLow", LEDRefHighLow);
-  tree->SetBranchAddress("Temperature", Temperature);
-  tree->SetBranchAddress("TemperatureRMS", TemperatureRMS);
+  tree->SetBranchAddress("LEDRefAmp", rLEDRefAmp);
+  tree->SetBranchAddress("LEDRefAmpRMS", rLEDRefAmpRMS);
+  tree->SetBranchAddress("LEDRefHighLow", iLEDRefHighLow);
+  tree->SetBranchAddress("Temperature", temperature);
+  tree->SetBranchAddress("TemperatureRMS", temperatureRMS);
   //
-  tree->SetBranchAddress("HighLow", HighLow);
-  tree->SetBranchAddress("LEDAmp", LEDAmp);
-  tree->SetBranchAddress("LEDAmpRMS", LEDAmpRMS);
+  tree->SetBranchAddress("HighLow", iHighLow);
+  tree->SetBranchAddress("LEDAmp", rLEDAmp);
+  tree->SetBranchAddress("LEDAmpRMS", rLEDAmpRMS);
 
   // indices for looping over the towers
   Int_t iCol = 0;
@@ -265,17 +265,17 @@ void AliEMCALCalibReference::ReadTreeCalibReferenceInfo(TTree *tree,
 
     t->SetSuperModuleNum(iSM);
     // first, overall values
-    t->SetReferenceTime(ReferenceTime);
+    t->SetReferenceTime(iReferenceTime);
 
     // second: additional info for LED references and SM temperatures
     for (Int_t j=0; j<AliEMCALGeoParams::fgkEMCALLEDRefs; j++) {
-      t->SetLEDRefAmp(j, LEDRefAmp[j]);
-      t->SetLEDRefAmpRMS(j, LEDRefAmpRMS[j]);
-      t->SetLEDRefHighLow(j, LEDRefHighLow[j]);
+      t->SetLEDRefAmp(j, rLEDRefAmp[j]);
+      t->SetLEDRefAmpRMS(j, rLEDRefAmpRMS[j]);
+      t->SetLEDRefHighLow(j, iLEDRefHighLow[j]);
     }
     for (Int_t j=0; j<AliEMCALGeoParams::fgkEMCALTempSensors; j++) {
-      t->SetTemperature(j, Temperature[j]);
-      t->SetTemperatureRMS(j, TemperatureRMS[j]);
+      t->SetTemperature(j, temperature[j]);
+      t->SetTemperatureRMS(j, temperatureRMS[j]);
     }
 
     // third: info for each tower
@@ -295,9 +295,9 @@ void AliEMCALCalibReference::ReadTreeCalibReferenceInfo(TTree *tree,
 
       AliEMCALCalibReferenceVal * v = t->GetAPDVal(iColMod, iRowMod);
 
-      v->SetHighLow(HighLow[iCol][iRow]);
-      v->SetLEDAmp(LEDAmp[iCol][iRow]);
-      v->SetLEDAmpRMS(LEDAmpRMS[iCol][iRow]);
+      v->SetHighLow(iHighLow[iCol][iRow]);
+      v->SetLEDAmp(rLEDAmp[iCol][iRow]);
+      v->SetLEDAmpRMS(rLEDAmpRMS[iCol][iRow]);
     }
 
   } // loop over entries
@@ -322,28 +322,28 @@ void AliEMCALCalibReference::WriteRootCalibReferenceInfo(const TString &rootFile
   Int_t iSM = 0; // SuperModule index
   // list of values to be written
   // first: overall values for the whole SuperModule
-  Int_t ReferenceTime = 0; 
+  Int_t iReferenceTime = 0; 
   // second: additional info for LED Reference and SM temperature
-  Float_t LEDRefAmp[AliEMCALGeoParams::fgkEMCALLEDRefs] = {0};
-  Float_t LEDRefAmpRMS[AliEMCALGeoParams::fgkEMCALLEDRefs]= {0};
-  Int_t LEDRefHighLow[AliEMCALGeoParams::fgkEMCALLEDRefs]= {0};
-  Float_t Temperature[AliEMCALGeoParams::fgkEMCALTempSensors]= {0};
-  Float_t TemperatureRMS[AliEMCALGeoParams::fgkEMCALTempSensors]= {0};
+  Float_t rLEDRefAmp[AliEMCALGeoParams::fgkEMCALLEDRefs] = {0};
+  Float_t rLEDRefAmpRMS[AliEMCALGeoParams::fgkEMCALLEDRefs]= {0};
+  Int_t iLEDRefHighLow[AliEMCALGeoParams::fgkEMCALLEDRefs]= {0};
+  Float_t temperature[AliEMCALGeoParams::fgkEMCALTempSensors]= {0};
+  Float_t temperatureRMS[AliEMCALGeoParams::fgkEMCALTempSensors]= {0};
   // third: info for each tower
-  Int_t HighLow[AliEMCALGeoParams::fgkEMCALCols][AliEMCALGeoParams::fgkEMCALRows]; 
-  Float_t LEDAmp[AliEMCALGeoParams::fgkEMCALCols][AliEMCALGeoParams::fgkEMCALRows]; 
-  Float_t LEDAmpRMS[AliEMCALGeoParams::fgkEMCALCols][AliEMCALGeoParams::fgkEMCALRows]; 
+  Int_t iHighLow[AliEMCALGeoParams::fgkEMCALCols][AliEMCALGeoParams::fgkEMCALRows]; 
+  Float_t rLEDAmp[AliEMCALGeoParams::fgkEMCALCols][AliEMCALGeoParams::fgkEMCALRows]; 
+  Float_t rLEDAmpRMS[AliEMCALGeoParams::fgkEMCALCols][AliEMCALGeoParams::fgkEMCALRows]; 
   // end - all values
 
   // just to make the initializations of the arrays are done correctly, let's use memset
-  memset(LEDRefAmp, 0, sizeof(LEDRefAmp)); 
-  memset(LEDRefAmpRMS, 0, sizeof(LEDRefAmpRMS)); 
-  memset(LEDRefHighLow, 0, sizeof(LEDRefHighLow)); 
-  memset(Temperature, 0, sizeof(Temperature)); 
-  memset(TemperatureRMS, 0, sizeof(TemperatureRMS)); 
-  memset(HighLow, 0, sizeof(HighLow)); 
-  memset(LEDAmp, 0, sizeof(LEDAmp)); 
-  memset(LEDAmpRMS, 0, sizeof(LEDAmpRMS)); 
+  memset(rLEDRefAmp, 0, sizeof(rLEDRefAmp)); 
+  memset(rLEDRefAmpRMS, 0, sizeof(rLEDRefAmpRMS)); 
+  memset(iLEDRefHighLow, 0, sizeof(iLEDRefHighLow)); 
+  memset(temperature, 0, sizeof(temperature)); 
+  memset(temperatureRMS, 0, sizeof(temperatureRMS)); 
+  memset(iHighLow, 0, sizeof(iHighLow)); 
+  memset(rLEDAmp, 0, sizeof(rLEDAmp)); 
+  memset(rLEDAmpRMS, 0, sizeof(rLEDAmpRMS)); 
 
   Int_t nAPDPerSM = AliEMCALGeoParams::fgkEMCALCols * AliEMCALGeoParams::fgkEMCALRows;
   // for looping over towers
@@ -353,34 +353,34 @@ void AliEMCALCalibReference::WriteRootCalibReferenceInfo(const TString &rootFile
   // declare the branches
   // first
   tree->Branch("iSM", &iSM, "iSM/I");
-  tree->Branch("ReferenceTime", &ReferenceTime, "ReferenceTime/I");
+  tree->Branch("ReferenceTime", &iReferenceTime, "ReferenceTime/I");
   // second  
-  tree->Branch( "LEDRefAmp", &LEDRefAmp, Form("LEDRefAmp[%d]/F", AliEMCALGeoParams::fgkEMCALLEDRefs) );
-  tree->Branch( "LEDRefAmpRMS", &LEDRefAmpRMS, Form("LEDRefAmpRMS[%d]/F", AliEMCALGeoParams::fgkEMCALLEDRefs) );
-  tree->Branch( "LEDRefHighLow", &LEDRefHighLow, Form("LEDRefHighLow[%d]/I", AliEMCALGeoParams::fgkEMCALLEDRefs) );
-  tree->Branch( "Temperature", &Temperature, Form("Temperature[%d]/F", AliEMCALGeoParams::fgkEMCALTempSensors) );
-  tree->Branch( "TemperatureRMS", &TemperatureRMS, Form("TemperatureRMS[%d]/F", AliEMCALGeoParams::fgkEMCALTempSensors) );
+  tree->Branch( "LEDRefAmp", &rLEDRefAmp, Form("LEDRefAmp[%d]/F", AliEMCALGeoParams::fgkEMCALLEDRefs) );
+  tree->Branch( "LEDRefAmpRMS", &rLEDRefAmpRMS, Form("LEDRefAmpRMS[%d]/F", AliEMCALGeoParams::fgkEMCALLEDRefs) );
+  tree->Branch( "LEDRefHighLow", &iLEDRefHighLow, Form("LEDRefHighLow[%d]/I", AliEMCALGeoParams::fgkEMCALLEDRefs) );
+  tree->Branch( "Temperature", &temperature, Form("Temperature[%d]/F", AliEMCALGeoParams::fgkEMCALTempSensors) );
+  tree->Branch( "TemperatureRMS", &temperatureRMS, Form("TemperatureRMS[%d]/F", AliEMCALGeoParams::fgkEMCALTempSensors) );
   // third: info for each tower; see if a 2D array works OK or if we'll have to use 1D arrays instead 
-  tree->Branch( "HighLow", &HighLow, Form("HighLow[%d][%d]/I", AliEMCALGeoParams::fgkEMCALCols, AliEMCALGeoParams::fgkEMCALRows) );
-  tree->Branch( "LEDAmp", &LEDAmp, Form("LEDAmp[%d][%d]/F", AliEMCALGeoParams::fgkEMCALCols, AliEMCALGeoParams::fgkEMCALRows) );
-  tree->Branch( "LEDAmpRMS", &LEDAmpRMS, Form("LEDAmpRMS[%d][%d]/F", AliEMCALGeoParams::fgkEMCALCols, AliEMCALGeoParams::fgkEMCALRows) );
+  tree->Branch( "HighLow", &iHighLow, Form("HighLow[%d][%d]/I", AliEMCALGeoParams::fgkEMCALCols, AliEMCALGeoParams::fgkEMCALRows) );
+  tree->Branch( "LEDAmp", &rLEDAmp, Form("LEDAmp[%d][%d]/F", AliEMCALGeoParams::fgkEMCALCols, AliEMCALGeoParams::fgkEMCALRows) );
+  tree->Branch( "LEDAmpRMS", &rLEDAmpRMS, Form("LEDAmpRMS[%d][%d]/F", AliEMCALGeoParams::fgkEMCALCols, AliEMCALGeoParams::fgkEMCALRows) );
 
   for (iSM = 0; iSM < fNSuperModule; iSM++) {
     AliEMCALSuperModuleCalibReference * t = (AliEMCALSuperModuleCalibReference*) fSuperModuleData[iSM];
 
     iSM = t->GetSuperModuleNum();
     // first, overall values
-    ReferenceTime = t->GetReferenceTime();
+    iReferenceTime = t->GetReferenceTime();
 
     // second: additional info for LED references and SM temperatures
     for (Int_t j=0; j<AliEMCALGeoParams::fgkEMCALLEDRefs; j++) {
-      LEDRefAmp[j] = t->GetLEDRefAmp(j);
-      LEDRefAmpRMS[j] = t->GetLEDRefAmpRMS(j);
-      LEDRefHighLow[j] = t->GetLEDRefHighLow(j);
+      rLEDRefAmp[j] = t->GetLEDRefAmp(j);
+      rLEDRefAmpRMS[j] = t->GetLEDRefAmpRMS(j);
+      iLEDRefHighLow[j] = t->GetLEDRefHighLow(j);
     }
     for (Int_t j=0; j<AliEMCALGeoParams::fgkEMCALTempSensors; j++) {
-      Temperature[j] = t->GetTemperature(j);
-      TemperatureRMS[j] = t->GetTemperatureRMS(j);
+      temperature[j] = t->GetTemperature(j);
+      temperatureRMS[j] = t->GetTemperatureRMS(j);
     }
 
     // third: info for each tower
@@ -400,9 +400,9 @@ void AliEMCALCalibReference::WriteRootCalibReferenceInfo(const TString &rootFile
 
       AliEMCALCalibReferenceVal * v = t->GetAPDVal(iCol, iRow);
 
-      HighLow[iColMod][iRowMod] = v->GetHighLow();
-      LEDAmp[iColMod][iRowMod] = v->GetLEDAmp();
-      LEDAmpRMS[iColMod][iRowMod] = v->GetLEDAmpRMS();
+      iHighLow[iColMod][iRowMod] = v->GetHighLow();
+      rLEDAmp[iColMod][iRowMod] = v->GetLEDAmp();
+      rLEDAmpRMS[iColMod][iRowMod] = v->GetLEDAmpRMS();
     }
 
     tree->Fill();
index ab5ac05..c7b5a9a 100644 (file)
@@ -54,7 +54,7 @@ void AliEMCALCalibTimeDepCorrection::InitCorrection(Int_t nSM, Int_t nBins, Floa
   Int_t iCol = 0;
   Int_t iRow = 0;
   Int_t nCorr = nBins;
-  Float_t Correction = val;
+  Float_t correction = val;
 
   Int_t nAPDPerSM = AliEMCALGeoParams::fgkEMCALCols * AliEMCALGeoParams::fgkEMCALRows;
 
@@ -68,7 +68,7 @@ void AliEMCALCalibTimeDepCorrection::InitCorrection(Int_t nSM, Int_t nBins, Floa
       t->GetCorrection(iCol,iRow)->Set(nCorr);
       for (Int_t k=0; k<nCorr; k++) {
        // add to TArray
-       t->GetCorrection(iCol,iRow)->AddAt(Correction, k); // AddAt = SetAt..
+       t->GetCorrection(iCol,iRow)->AddAt(correction, k); // AddAt = SetAt..
       }
     }
 
@@ -108,7 +108,7 @@ void AliEMCALCalibTimeDepCorrection::ReadTextInfo(Int_t nSM, const TString &txtF
   Int_t iCol = 0;
   Int_t iRow = 0;
   Int_t nCorr = 0;
-  Float_t Correction = 0;
+  Float_t correction = 0;
 
   Int_t nAPDPerSM = AliEMCALGeoParams::fgkEMCALCols * AliEMCALGeoParams::fgkEMCALRows;
 
@@ -138,9 +138,9 @@ void AliEMCALCalibTimeDepCorrection::ReadTextInfo(Int_t nSM, const TString &txtF
       // set size of TArray
       t->GetCorrection(iCol,iRow)->Set(nCorr);
       for (Int_t k=0; k<nCorr; k++) {
-       inputFile >> Correction;
+       inputFile >> correction;
        // add to TArray
-       t->GetCorrection(iCol,iRow)->AddAt(Correction, k);
+       t->GetCorrection(iCol,iRow)->AddAt(correction, k);
       }
     }