changes to calibration-related objects: use TObjArray for streaming to work, and...
authordsilverm <dsilverm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 17 Sep 2009 19:46:09 +0000 (19:46 +0000)
committerdsilverm <dsilverm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 17 Sep 2009 19:46:09 +0000 (19:46 +0000)
EMCAL/AliEMCALBiasAPD.cxx
EMCAL/AliEMCALBiasAPD.h
EMCAL/AliEMCALCalibAbs.cxx
EMCAL/AliEMCALCalibAbs.h
EMCAL/AliEMCALCalibMapAPD.cxx
EMCAL/AliEMCALCalibMapAPD.h
EMCAL/AliEMCALCalibTimeDep.cxx
EMCAL/AliEMCALCalibTimeDepCorrection.cxx
EMCAL/AliEMCALCalibTimeDepCorrection.h

index c11782d..8f9ac02 100644 (file)
@@ -30,11 +30,15 @@ using namespace std;
 ClassImp(AliEMCALBiasAPD)
 
 //____________________________________________________________________________
-AliEMCALBiasAPD::AliEMCALBiasAPD() : 
-  fNSuperModule(0),
-  fSuperModuleData(0)
+AliEMCALBiasAPD::AliEMCALBiasAPD(const int nSM) : 
+  fNSuperModule(nSM), // make space for everyone 
+  fSuperModuleData()
 {
   //Default constructor.
+  for (int i=0; i<fNSuperModule; i++) {
+    fSuperModuleData.Add(new AliEMCALSuperModuleBiasAPD(i));
+  }
+  fSuperModuleData.Compress(); // compress the TObjArray
 }
 
 //____________________________________________________________________________
@@ -50,8 +54,6 @@ void AliEMCALBiasAPD::ReadTextBiasAPDInfo(Int_t nSM, const TString &txtFileName,
   }
 
   fNSuperModule = nSM;
-  if (fSuperModuleData) delete [] fSuperModuleData;
-  fSuperModuleData = new AliEMCALSuperModuleBiasAPD[fNSuperModule];
 
   Int_t iSM = 0; // SuperModule index
   Int_t iCol = 0;
@@ -63,13 +65,14 @@ void AliEMCALBiasAPD::ReadTextBiasAPDInfo(Int_t nSM, const TString &txtFileName,
   Int_t nAPDPerSM = AliEMCALGeoParams::fgkEMCALCols * AliEMCALGeoParams::fgkEMCALRows;
 
   for (Int_t i = 0; i < fNSuperModule; i++) {
-    AliEMCALSuperModuleBiasAPD &t = fSuperModuleData[i];
+    AliEMCALSuperModuleBiasAPD * t = (AliEMCALSuperModuleBiasAPD*) fSuperModuleData[i];
+
     if (!inputFile) {
       printf("AliEMCALBiasAPD::ReadBiasAPDInfo - Error while reading input file; likely EOF..");
       return;
     }
     inputFile >> iSM;
-    t.fSuperModuleNum = iSM;
+    t->SetSuperModuleNum(iSM);
 
     for (Int_t j=0; j<nAPDPerSM; j++) {
       inputFile >> iCol >> iRow >> iElecId >> iDAC >> voltage;
@@ -81,9 +84,9 @@ void AliEMCALBiasAPD::ReadTextBiasAPDInfo(Int_t nSM, const TString &txtFileName,
        iRow = AliEMCALGeoParams::fgkEMCALRows-1 - iRow;
       }
 
-      t.fElecId[iCol][iRow] = iElecId;
-      t.fDAC[iCol][iRow] = iDAC;
-      t.fVoltage[iCol][iRow] = voltage;
+      t->SetElecId(iCol, iRow, iElecId);
+      t->SetDAC(iCol, iRow, iDAC);
+      t->SetVoltage(iCol, iRow, voltage);
     }
 
   } // i, SuperModule
@@ -114,16 +117,16 @@ void AliEMCALBiasAPD::WriteTextBiasAPDInfo(const TString &txtFileName,
   Int_t nAPDPerSM = AliEMCALGeoParams::fgkEMCALCols * AliEMCALGeoParams::fgkEMCALRows;
 
   for (Int_t i = 0; i < fNSuperModule; i++) {
-    AliEMCALSuperModuleBiasAPD &t = fSuperModuleData[i];
-    outputFile << t.fSuperModuleNum << endl;
+    AliEMCALSuperModuleBiasAPD * t = (AliEMCALSuperModuleBiasAPD*) fSuperModuleData[i];
+    outputFile << t->GetSuperModuleNum() << endl;
 
     for (Int_t j=0; j<nAPDPerSM; j++) {
       iCol = j / AliEMCALGeoParams::fgkEMCALRows;
       iRow = j % AliEMCALGeoParams::fgkEMCALRows;
 
-      iElecId = t.fElecId[iCol][iRow];
-      iDAC = t.fDAC[iCol][iRow];
-      voltage = t.fVoltage[iCol][iRow];
+      iElecId = t->GetElecId(iCol, iRow);
+      iDAC = t->GetDAC(iCol, iRow);
+      voltage = t->GetVoltage(iCol, iRow);
 
       if (swapSides) {
        // C side, oriented differently than A side: swap is requested
@@ -167,9 +170,6 @@ void AliEMCALBiasAPD::ReadTreeBiasAPDInfo(TTree *tree,
   Int_t nAPDPerSM = AliEMCALGeoParams::fgkEMCALCols * AliEMCALGeoParams::fgkEMCALRows;
   fNSuperModule = tree->GetEntries() / nAPDPerSM;
 
-  if (fSuperModuleData) delete [] fSuperModuleData;
-  fSuperModuleData = new AliEMCALSuperModuleBiasAPD[fNSuperModule];
-
   Int_t iSM = 0; // SuperModule index
   Int_t iCol = 0;
   Int_t iRow = 0;
@@ -191,8 +191,8 @@ void AliEMCALBiasAPD::ReadTreeBiasAPDInfo(TTree *tree,
     tree->GetEntry(ient);
 
     // assume the index SuperModules come in order: i=iSM
-    AliEMCALSuperModuleBiasAPD &t = fSuperModuleData[iSM];
-    t.fSuperModuleNum = iSM;
+    AliEMCALSuperModuleBiasAPD * t = (AliEMCALSuperModuleBiasAPD*) fSuperModuleData[iSM];
+    t->SetSuperModuleNum(iSM);
 
     // assume that this info is already swapped and done for this basis?
     if (swapSides) {
@@ -201,9 +201,9 @@ void AliEMCALBiasAPD::ReadTreeBiasAPDInfo(TTree *tree,
       iRow = AliEMCALGeoParams::fgkEMCALRows-1 - iRow;
     }
 
-    t.fElecId[iCol][iRow] = iElecId;
-    t.fDAC[iCol][iRow] = iDAC;
-    t.fVoltage[iCol][iRow] = voltage;
+    t->SetElecId(iCol, iRow, iElecId);
+    t->SetDAC(iCol, iRow, iDAC);
+    t->SetVoltage(iCol, iRow, voltage);
 
   } // 
 
@@ -241,15 +241,15 @@ void AliEMCALBiasAPD::WriteRootBiasAPDInfo(const TString &rootFileName,
   Int_t nAPDPerSM = AliEMCALGeoParams::fgkEMCALCols * AliEMCALGeoParams::fgkEMCALRows;
 
   for (iSM = 0; iSM < fNSuperModule; iSM++) {
-    AliEMCALSuperModuleBiasAPD &t = fSuperModuleData[iSM];
+    AliEMCALSuperModuleBiasAPD * t = (AliEMCALSuperModuleBiasAPD*) fSuperModuleData[iSM];
 
     for (Int_t j=0; j<nAPDPerSM; j++) {
       iCol = j / AliEMCALGeoParams::fgkEMCALRows;
       iRow = j % AliEMCALGeoParams::fgkEMCALRows;
 
-      iElecId = t.fElecId[iCol][iRow];
-      iDAC = t.fDAC[iCol][iRow];
-      voltage = t.fVoltage[iCol][iRow];
+      iElecId = t->GetElecId(iCol, iRow);
+      iDAC = t->GetDAC(iCol, iRow);
+      voltage = t->GetVoltage(iCol, iRow);
 
       if (swapSides) {
        // C side, oriented differently than A side: swap is requested
@@ -271,32 +271,20 @@ void AliEMCALBiasAPD::WriteRootBiasAPDInfo(const TString &rootFileName,
 //____________________________________________________________________________
 AliEMCALBiasAPD::~AliEMCALBiasAPD()
 {
-  delete [] fSuperModuleData;
-}
-
-//____________________________________________________________________________
-AliEMCALSuperModuleBiasAPD AliEMCALBiasAPD::GetSuperModuleBiasAPDId(Int_t supModIndex)const
-{
-  AliEMCALSuperModuleBiasAPD t;  // just to maybe prevent a crash, but we are returning something not-initialized so maybe not better really..
-  if (!fSuperModuleData)
-    return t;
-
-  return fSuperModuleData[supModIndex];
+  fSuperModuleData.Delete();
 }
 
 //____________________________________________________________________________
-AliEMCALSuperModuleBiasAPD AliEMCALBiasAPD::GetSuperModuleBiasAPDNum(Int_t supModIndex)const
+AliEMCALSuperModuleBiasAPD * AliEMCALBiasAPD::GetSuperModuleBiasAPDNum(Int_t supModIndex)const
 {
-  AliEMCALSuperModuleBiasAPD t;  // just to maybe prevent a crash, but we are returning something not-initialized so maybe not better really..
-  if (!fSuperModuleData)
-    return t;
-
   for (int i=0; i<fNSuperModule; i++) {
-    if (fSuperModuleData[i].fSuperModuleNum == supModIndex) {
-      return fSuperModuleData[i];
+    AliEMCALSuperModuleBiasAPD * t = (AliEMCALSuperModuleBiasAPD*) fSuperModuleData[i];
+    if (t->GetSuperModuleNum() == supModIndex) {
+      return t;
     }
   }
 
-  return t;
+  // if we arrived here, then nothing was found.. just return a NULL pointer 
+  return NULL;
 }
 
index 0e8d0cd..40f2bea 100644 (file)
@@ -7,6 +7,7 @@
 /* $Id: $ */
 
 #include <TObject.h>
+#include <TObjArray.h>
 #include "AliEMCALGeoParams.h"
 class TString;
 class TTree;
@@ -19,8 +20,8 @@ class TTree;
 // 1 SuperModule's worth of info
 class AliEMCALSuperModuleBiasAPD : public TObject {
  public:
-  AliEMCALSuperModuleBiasAPD() : TObject(), // just init values
-    fSuperModuleNum(0)
+  AliEMCALSuperModuleBiasAPD(const int smNum=0) : TObject(), // just init values
+    fSuperModuleNum(smNum)
     {
       for (int icol=0; icol<AliEMCALGeoParams::fgkEMCALCols; icol++) {
        for (int irow=0; irow<AliEMCALGeoParams::fgkEMCALRows; irow++) {
@@ -32,18 +33,28 @@ class AliEMCALSuperModuleBiasAPD : public TObject {
     }
 
  public:
+  void SetSuperModuleNum(Int_t i) { fSuperModuleNum = i;}; // 
+  Int_t GetSuperModuleNum() const { return fSuperModuleNum;}; // 
+  void SetElecId(int icol, int irow, Int_t i) { fElecId[icol][irow] = i; }; //
+  Int_t GetElecId(int icol, int irow) const { return fElecId[icol][irow]; }; //
+  void SetDAC(int icol, int irow, Int_t i) { fDAC[icol][irow] = i; }; //
+  Int_t GetDAC(int icol, int irow) const { return fDAC[icol][irow]; }; //
+  void SetVoltage(int icol, int irow, Float_t f) { fVoltage[icol][irow] = f; }; //
+  Float_t GetVoltage(int icol, int irow) const { return fVoltage[icol][irow]; }; //
+
+ private:
   Int_t fSuperModuleNum; // SM index
   Int_t fElecId[AliEMCALGeoParams::fgkEMCALCols][AliEMCALGeoParams::fgkEMCALRows]; // ElectronicsIndex/Address - we keep this to help ensure that the column/row info matches with electronics indices
   Int_t fDAC[AliEMCALGeoParams::fgkEMCALCols][AliEMCALGeoParams::fgkEMCALRows]; // 0-0x3ff register
   Float_t fVoltage[AliEMCALGeoParams::fgkEMCALCols][AliEMCALGeoParams::fgkEMCALRows]; // 210 to ca 417 V. (function of DAC setting)
 
-  ClassDef(AliEMCALSuperModuleBiasAPD, 1) // help class
+  ClassDef(AliEMCALSuperModuleBiasAPD, 2) // help class
 };
 // ******* end of internal class definition *************
 
 class AliEMCALBiasAPD : public TObject {
 public:
-  AliEMCALBiasAPD();
+  AliEMCALBiasAPD(const int nSM = AliEMCALGeoParams::fgkEMCALModules);
 
   // Read and Write txt I/O methods are normally not used, but are useful for 
   // filling the object before it is saved in OCDB 
@@ -57,24 +68,25 @@ public:
 
   // pointer to stored info.
   Int_t GetNSuperModule() const { return fNSuperModule; }; 
-  AliEMCALSuperModuleBiasAPD * GetSuperModuleData() const { return fSuperModuleData; };
 
   // - via the index in the stored array:
-  virtual AliEMCALSuperModuleBiasAPD GetSuperModuleBiasAPDId(Int_t smIndex) const;
+  virtual AliEMCALSuperModuleBiasAPD * GetSuperModuleBiasAPDId(Int_t smIndex) const
+    { return (AliEMCALSuperModuleBiasAPD*) fSuperModuleData[smIndex]; };
+
   // - or via the actual SM number
-  virtual AliEMCALSuperModuleBiasAPD GetSuperModuleBiasAPDNum(Int_t smNum) const;
+  virtual AliEMCALSuperModuleBiasAPD * GetSuperModuleBiasAPDNum(Int_t smNum) const;
 
 protected:
 
   Int_t          fNSuperModule; // Number of supermodules.
-  AliEMCALSuperModuleBiasAPD *fSuperModuleData; // SuperModule data
+  TObjArray fSuperModuleData; // SuperModule data
 
 private:
 
   AliEMCALBiasAPD(const AliEMCALBiasAPD &);
   AliEMCALBiasAPD &operator = (const AliEMCALBiasAPD &);
 
-  ClassDef(AliEMCALBiasAPD, 2) //BiasAPD data reader
+  ClassDef(AliEMCALBiasAPD, 3) //BiasAPD data info
 };
 
 #endif
index 02bc142..95c5ed6 100644 (file)
@@ -30,11 +30,15 @@ using namespace std;
 ClassImp(AliEMCALCalibAbs)
 
 //____________________________________________________________________________
-AliEMCALCalibAbs::AliEMCALCalibAbs() : 
-  fNSuperModule(0),
-  fSuperModuleData(0)
+AliEMCALCalibAbs::AliEMCALCalibAbs(const int nSM) : 
+  fNSuperModule(nSM),
+  fSuperModuleData()
 {
   //Default constructor.
+  for (int i=0; i<fNSuperModule; i++) {
+    fSuperModuleData.Add(new AliEMCALSuperModuleCalibAbs(i));
+  }
+  fSuperModuleData.Compress(); // compress the TObjArray
 }
 
 //____________________________________________________________________________
@@ -50,8 +54,6 @@ void AliEMCALCalibAbs::ReadTextCalibAbsInfo(Int_t nSM, const TString &txtFileNam
   }
 
   fNSuperModule = nSM;
-  if (fSuperModuleData) delete [] fSuperModuleData;
-  fSuperModuleData = new AliEMCALSuperModuleCalibAbs[fNSuperModule];
 
   Int_t iSM = 0; // SuperModule index
   Int_t iCol = 0;
@@ -82,33 +84,33 @@ void AliEMCALCalibAbs::ReadTextCalibAbsInfo(Int_t nSM, const TString &txtFileNam
   Int_t nAPDPerSM = AliEMCALGeoParams::fgkEMCALCols * AliEMCALGeoParams::fgkEMCALRows;
 
   for (Int_t i = 0; i < fNSuperModule; i++) {
-    AliEMCALSuperModuleCalibAbs &t = fSuperModuleData[i];
+    AliEMCALSuperModuleCalibAbs * t = (AliEMCALSuperModuleCalibAbs*) fSuperModuleData[i];
     if (!inputFile) {
       printf("AliEMCALCalibAbs::ReadCalibAbsInfo - Error while reading input file; likely EOF..");
       return;
     }
     inputFile >> iSM;
-    t.fSuperModuleNum = iSM;
+    t->SetSuperModuleNum(iSM);
 
     // first: overall values for the whole SuperModule
     inputFile >> CalibMethod >> CalibPass >> CalibTime >> AbsoluteGain;
-    t.fCalibMethod = CalibMethod;
-    t.fCalibPass = CalibPass;
-    t.fCalibTime = CalibTime;
-    t.fAbsoluteGain = AbsoluteGain;
+    t->SetCalibMethod(CalibMethod);
+    t->SetCalibPass(CalibPass);
+    t->SetCalibTime(CalibTime);
+    t->SetAbsoluteGain(AbsoluteGain);
 
     // second: additional info for LED Reference and SM temperature
     for (Int_t j=0; j<AliEMCALGeoParams::fgkEMCALLEDRefs; j++) {
       inputFile >> id >> LEDRefAmp >> LEDRefAmpRMS >> LEDRefHighLowRatio >> LEDRefHighLow;
-      t.fLEDRefAmp[id] = LEDRefAmp;
-      t.fLEDRefAmpRMS[id] = LEDRefAmpRMS;
-      t.fLEDRefHighLowRatio[id] = LEDRefHighLowRatio;
-      t.fLEDRefHighLow[id] = LEDRefHighLow;
+      t->SetLEDRefAmp(id, LEDRefAmp);
+      t->SetLEDRefAmpRMS(id, LEDRefAmpRMS);
+      t->SetLEDRefHighLowRatio(id, LEDRefHighLowRatio);
+      t->SetLEDRefHighLow(id, LEDRefHighLow);
     }
     for (Int_t j=0; j<AliEMCALGeoParams::fgkEMCALTempSensors; j++) {
       inputFile >> id >> Temperature >> TemperatureRMS;
-      t.fTemperature[id] = Temperature;
-      t.fTemperatureRMS[id] = TemperatureRMS;
+      t->SetTemperature(id, Temperature);
+      t->SetTemperatureRMS(id, TemperatureRMS);
     }
 
     // third: info for each tower
@@ -123,13 +125,13 @@ void AliEMCALCalibAbs::ReadTextCalibAbsInfo(Int_t nSM, const TString &txtFileNam
        iRow = AliEMCALGeoParams::fgkEMCALRows-1 - iRow;
       }
 
-      AliEMCALCalibAbsVal &v = t.fAPDVal[iCol][iRow];
+      AliEMCALCalibAbsVal * v = t->GetAPDVal(iCol, iRow);
 
-      v.fRelativeGain = RelativeGain;
-      v.fHighLowRatio = HighLowRatio;
-      v.fHighLow = HighLow;
-      v.fLEDAmp = LEDAmp;
-      v.fLEDAmpRMS = LEDAmpRMS;
+      v->SetRelativeGain(RelativeGain);
+      v->SetHighLowRatio(HighLowRatio);
+      v->SetHighLow(HighLow);
+      v->SetLEDAmp(LEDAmp);
+      v->SetLEDAmpRMS(LEDAmpRMS);
     }
 
   } // i, SuperModule
@@ -157,22 +159,23 @@ void AliEMCALCalibAbs::WriteTextCalibAbsInfo(const TString &txtFileName,
   Int_t nAPDPerSM = AliEMCALGeoParams::fgkEMCALCols * AliEMCALGeoParams::fgkEMCALRows;
 
   for (Int_t i = 0; i < fNSuperModule; i++) {
-    AliEMCALSuperModuleCalibAbs &t = fSuperModuleData[i];
+    AliEMCALSuperModuleCalibAbs * t = (AliEMCALSuperModuleCalibAbs*) fSuperModuleData[i];
+
     // first: overall values for the whole SuperModule
-    outputFile << t.fSuperModuleNum << endl;
-    outputFile << t.fCalibMethod << " " 
-              << t.fCalibPass << " " 
-              << t.fCalibTime << " " 
-              << t.fAbsoluteGain << endl;
+    outputFile << t->GetSuperModuleNum() << endl;
+    outputFile << t->GetCalibMethod() << " " 
+              << t->GetCalibPass() << " " 
+              << t->GetCalibTime() << " " 
+              << t->GetAbsoluteGain() << endl;
 
     // second: additional info for LED Reference and SM temperature
     for (Int_t j=0; j<AliEMCALGeoParams::fgkEMCALLEDRefs; j++) {
-      outputFile << j << " " << t.fLEDRefAmp[j] << " " << t.fLEDRefAmpRMS[j] 
-                << " " << t.fLEDRefHighLowRatio[j] << " " << t.fLEDRefHighLow[j] 
+      outputFile << j << " " << t->GetLEDRefAmp(j) << " " << t->GetLEDRefAmpRMS(j) 
+                << " " << t->GetLEDRefHighLowRatio(j) << " " << t->GetLEDRefHighLow(j) 
                 << endl;
     }
     for (Int_t j=0; j<AliEMCALGeoParams::fgkEMCALTempSensors; j++) {
-      outputFile << j << " " << t.fTemperature[j] << " " << t.fTemperatureRMS[j] << endl;
+      outputFile << j << " " << t->GetTemperature(j) << " " << t->GetTemperatureRMS(j) << endl;
     }
 
     // third: info for each tower
@@ -180,7 +183,7 @@ void AliEMCALCalibAbs::WriteTextCalibAbsInfo(const TString &txtFileName,
       iCol = j / AliEMCALGeoParams::fgkEMCALRows;
       iRow = j % AliEMCALGeoParams::fgkEMCALRows;
 
-      AliEMCALCalibAbsVal &v = t.fAPDVal[iCol][iRow];
+      AliEMCALCalibAbsVal * v = t->GetAPDVal(iCol, iRow);
 
       if (swapSides) {
        // C side, oriented differently than A side: swap is requested
@@ -189,11 +192,11 @@ void AliEMCALCalibAbs::WriteTextCalibAbsInfo(const TString &txtFileName,
       }
 
       outputFile << iCol << " " << iRow 
-                << " " << v.fRelativeGain
-                << " " << v.fHighLowRatio 
-                << " " << v.fHighLow 
-                << " " << v.fLEDAmp 
-                << " " << v.fLEDAmpRMS << endl;
+                << " " << v->GetRelativeGain()
+                << " " << v->GetHighLowRatio() 
+                << " " << v->GetHighLow() 
+                << " " << v->GetLEDAmp() 
+                << " " << v->GetLEDAmpRMS() << endl;
     }
 
   } // i, SuperModule
@@ -227,9 +230,6 @@ void AliEMCALCalibAbs::ReadTreeCalibAbsInfo(TTree *tree,
   Int_t nAPDPerSM = AliEMCALGeoParams::fgkEMCALCols * AliEMCALGeoParams::fgkEMCALRows;
   fNSuperModule = tree->GetEntries() / nAPDPerSM;
 
-  if (fSuperModuleData) delete [] fSuperModuleData;
-  fSuperModuleData = new AliEMCALSuperModuleCalibAbs[fNSuperModule];
-
   Int_t iSM = 0; // SuperModule index
   // list of values to be read
   // first: overall values for the whole SuperModule
@@ -293,24 +293,25 @@ void AliEMCALCalibAbs::ReadTreeCalibAbsInfo(TTree *tree,
     tree->GetEntry(ient);
 
     // assume the index SuperModules come in order: i=iSM
-    AliEMCALSuperModuleCalibAbs &t = fSuperModuleData[iSM];
-    t.fSuperModuleNum = iSM;
+    AliEMCALSuperModuleCalibAbs * t = (AliEMCALSuperModuleCalibAbs*) fSuperModuleData[iSM];
+
+    t->SetSuperModuleNum(iSM);
     // first, overall values
-    t.fCalibMethod = CalibMethod;
-    t.fCalibPass = CalibPass;
-    t.fCalibTime = CalibTime;
-    t.fAbsoluteGain = AbsoluteGain;
+    t->SetCalibMethod(CalibMethod);
+    t->SetCalibPass(CalibPass);
+    t->SetCalibTime(CalibTime);
+    t->SetAbsoluteGain(AbsoluteGain);
 
     // second: additional info for LED references and SM temperatures
     for (Int_t j=0; j<AliEMCALGeoParams::fgkEMCALLEDRefs; j++) {
-      t.fLEDRefAmp[j] = LEDRefAmp[j];
-      t.fLEDRefAmpRMS[j] = LEDRefAmpRMS[j];
-      t.fLEDRefHighLowRatio[j] = LEDRefHighLowRatio[j];
-      t.fLEDRefHighLow[j] = LEDRefHighLow[j];
+      t->SetLEDRefAmp(j, LEDRefAmp[j]);
+      t->SetLEDRefAmpRMS(j, LEDRefAmpRMS[j]);
+      t->SetLEDRefHighLowRatio(j, LEDRefHighLowRatio[j]);
+      t->SetLEDRefHighLow(j, LEDRefHighLow[j]);
     }
     for (Int_t j=0; j<AliEMCALGeoParams::fgkEMCALTempSensors; j++) {
-      t.fTemperature[j] = Temperature[j];
-      t.fTemperatureRMS[j] = TemperatureRMS[j];
+      t->SetTemperature(j, Temperature[j]);
+      t->SetTemperatureRMS(j, TemperatureRMS[j]);
     }
 
     // third: info for each tower
@@ -328,13 +329,13 @@ void AliEMCALCalibAbs::ReadTreeCalibAbsInfo(TTree *tree,
        iRowMod = AliEMCALGeoParams::fgkEMCALRows-1 - iRow;
       }
 
-      AliEMCALCalibAbsVal &v = t.fAPDVal[iColMod][iRowMod];
+      AliEMCALCalibAbsVal * v = t->GetAPDVal(iCol, iRow);
 
-      v.fRelativeGain = RelativeGain[iCol][iRow];
-      v.fHighLowRatio = HighLowRatio[iCol][iRow];
-      v.fHighLow = HighLow[iCol][iRow];
-      v.fLEDAmp = LEDAmp[iCol][iRow];
-      v.fLEDAmpRMS = LEDAmpRMS[iCol][iRow];
+      v->SetRelativeGain(RelativeGain[iCol][iRow]);
+      v->SetHighLowRatio(HighLowRatio[iCol][iRow]);
+      v->SetHighLow(HighLow[iCol][iRow]);
+      v->SetLEDAmp(LEDAmp[iCol][iRow]);
+      v->SetLEDAmpRMS(LEDAmpRMS[iCol][iRow]);
     }
 
   } // loop over entries
@@ -418,25 +419,25 @@ void AliEMCALCalibAbs::WriteRootCalibAbsInfo(const TString &rootFileName,
   tree->Branch( "LEDAmpRMS", &LEDAmpRMS, Form("LEDAmpRMS[%d][%d]/F", AliEMCALGeoParams::fgkEMCALCols, AliEMCALGeoParams::fgkEMCALRows) );
 
   for (iSM = 0; iSM < fNSuperModule; iSM++) {
-    AliEMCALSuperModuleCalibAbs &t = fSuperModuleData[iSM];
+    AliEMCALSuperModuleCalibAbs * t = (AliEMCALSuperModuleCalibAbs*) fSuperModuleData[iSM];
 
-    iSM = t.fSuperModuleNum;
+    iSM = t->GetSuperModuleNum();
     // first, overall values
-    CalibMethod = t.fCalibMethod;
-    CalibPass = t.fCalibPass;
-    CalibTime = t.fCalibTime;
-    AbsoluteGain = t.fAbsoluteGain;
+    CalibMethod = t->GetCalibMethod();
+    CalibPass = t->GetCalibPass();
+    CalibTime = t->GetCalibTime();
+    AbsoluteGain = t->GetAbsoluteGain();
 
     // second: additional info for LED references and SM temperatures
     for (Int_t j=0; j<AliEMCALGeoParams::fgkEMCALLEDRefs; j++) {
-      LEDRefAmp[j] = t.fLEDRefAmp[j];
-      LEDRefAmpRMS[j] = t.fLEDRefAmpRMS[j];
-      LEDRefHighLowRatio[j] = t.fLEDRefHighLowRatio[j];
-      LEDRefHighLow[j] = t.fLEDRefHighLow[j];
+      LEDRefAmp[j] = t->GetLEDRefAmp(j);
+      LEDRefAmpRMS[j] = t->GetLEDRefAmpRMS(j);
+      LEDRefHighLowRatio[j] = t->GetLEDRefHighLowRatio(j);
+      LEDRefHighLow[j] = t->GetLEDRefHighLow(j);
     }
     for (Int_t j=0; j<AliEMCALGeoParams::fgkEMCALTempSensors; j++) {
-      Temperature[j] = t.fTemperature[j];
-      TemperatureRMS[j] = t.fTemperatureRMS[j];
+      Temperature[j] = t->GetTemperature(j);
+      TemperatureRMS[j] = t->GetTemperatureRMS(j);
     }
 
     // third: info for each tower
@@ -454,13 +455,13 @@ void AliEMCALCalibAbs::WriteRootCalibAbsInfo(const TString &rootFileName,
        iRowMod = AliEMCALGeoParams::fgkEMCALRows-1 - iRow;
       }
 
-      AliEMCALCalibAbsVal &v = t.fAPDVal[iColMod][iRowMod];
+      AliEMCALCalibAbsVal * v = t->GetAPDVal(iCol, iRow);
 
-      RelativeGain[iCol][iRow] = v.fRelativeGain;
-      HighLowRatio[iCol][iRow] = v.fHighLowRatio;
-      HighLow[iCol][iRow] = v.fHighLow;
-      LEDAmp[iCol][iRow] = v.fLEDAmp;
-      LEDAmpRMS[iCol][iRow] = v.fLEDAmpRMS;
+      RelativeGain[iCol][iRow] = v->GetRelativeGain();
+      HighLowRatio[iCol][iRow] = v->GetHighLowRatio();
+      HighLow[iCol][iRow] = v->GetHighLow();
+      LEDAmp[iCol][iRow] = v->GetLEDAmp();
+      LEDAmpRMS[iCol][iRow] = v->GetLEDAmpRMS();
     }
 
     tree->Fill();
@@ -475,32 +476,20 @@ void AliEMCALCalibAbs::WriteRootCalibAbsInfo(const TString &rootFileName,
 //____________________________________________________________________________
 AliEMCALCalibAbs::~AliEMCALCalibAbs()
 {
-  delete [] fSuperModuleData;
+  fSuperModuleData.Delete();
 }
 
 //____________________________________________________________________________
-AliEMCALSuperModuleCalibAbs AliEMCALCalibAbs::GetSuperModuleCalibAbsId(Int_t supModIndex)const
+AliEMCALSuperModuleCalibAbs * AliEMCALCalibAbs::GetSuperModuleCalibAbsNum(Int_t supModIndex)const
 {
-  AliEMCALSuperModuleCalibAbs t;  // just to maybe prevent a crash, but we are returning something not-initialized so maybe not better really..
-  if (!fSuperModuleData)
-    return t;
-
-  return fSuperModuleData[supModIndex];
-}
-
-//____________________________________________________________________________
-AliEMCALSuperModuleCalibAbs AliEMCALCalibAbs::GetSuperModuleCalibAbsNum(Int_t supModIndex)const
-{
-  AliEMCALSuperModuleCalibAbs t;  // just to maybe prevent a crash, but we are returning something not-initialized so maybe not better really..
-  if (!fSuperModuleData)
-    return t;
-
   for (int i=0; i<fNSuperModule; i++) {
-    if (fSuperModuleData[i].fSuperModuleNum == supModIndex) {
-      return fSuperModuleData[i];
+    AliEMCALSuperModuleCalibAbs * t = (AliEMCALSuperModuleCalibAbs*) fSuperModuleData[i];
+    if (t->GetSuperModuleNum() == supModIndex) {
+      return t;
     }
   }
 
-  return t;
+  // if we arrived here, then nothing was found.. just return a NULL pointer 
+  return NULL;
 }
 
index 67bb35f..f55c908 100644 (file)
@@ -7,6 +7,7 @@
 /* $Id: $ */
 
 #include <TObject.h>
+#include <TObjArray.h>
 #include "AliEMCALGeoParams.h"
 class TString;
 class TTree;
@@ -45,21 +46,33 @@ class AliEMCALCalibAbsVal : public TObject {
   }
 
  public:
+  void SetRelativeGain(Float_t f) { fRelativeGain = f; }; //
+  Float_t GetRelativeGain() const { return fRelativeGain; }; //
+  void SetHighLowRatio(Float_t f) { fHighLowRatio = f; }; //
+  Float_t GetHighLowRatio() const { return fHighLowRatio; }; //
+  void SetHighLow(Int_t i) { fHighLow = i; }; //
+  Int_t GetHighLow() const { return fHighLow; }; //
+  void SetLEDAmp(Float_t f) { fLEDAmp = f; }; //
+  Float_t GetLEDAmp() const { return fLEDAmp; }; //
+  void SetLEDAmpRMS(Float_t f) { fLEDAmpRMS = f; }; //
+  Float_t GetLEDAmpRMS() const { return fLEDAmpRMS; }; //
+
+ private:
   Float_t fRelativeGain; // (ADC>GeV relative gain/conversion), value around 1
   Float_t fHighLowRatio; // value around 16 or so
   Int_t fHighLow; // 0 (low) or 1 (high) gain, used for LEDAmp info
   Float_t fLEDAmp; // LED amplitude
   Float_t fLEDAmpRMS; // RMS
 
-  ClassDef(AliEMCALCalibAbsVal, 1) // help class
+  ClassDef(AliEMCALCalibAbsVal, 2) // help class
 };
 
 // 1 SuperModule's worth of info: info on where the different APDs are
 class AliEMCALSuperModuleCalibAbs : public TObject {
 
  public:
-  AliEMCALSuperModuleCalibAbs() : TObject(), // just init values
-    fSuperModuleNum(0),
+  AliEMCALSuperModuleCalibAbs(const int smNum=0) : TObject(), // just init values
+    fSuperModuleNum(smNum),
     fCalibMethod(0),
     fCalibPass(0),
     fCalibTime(0),
@@ -85,6 +98,38 @@ class AliEMCALSuperModuleCalibAbs : public TObject {
     }
 
  public:
+  // first
+  void SetSuperModuleNum(Int_t i) { fSuperModuleNum = i;}; // 
+  Int_t GetSuperModuleNum() const { return fSuperModuleNum;}; // 
+  void SetCalibMethod(Int_t i) { fCalibMethod = i;}; // 
+  Int_t GetCalibMethod() const { return fCalibMethod;}; // 
+  void SetCalibPass(Int_t i) { fCalibPass = i;}; // 
+  Int_t GetCalibPass() const { return fCalibPass;}; // 
+  void SetCalibTime(Int_t i) { fCalibTime = i;}; // 
+  Int_t GetCalibTime() const { return fCalibTime;}; // 
+  void SetAbsoluteGain(Float_t f) { fAbsoluteGain = f;}; // 
+  Float_t GetAbsoluteGain() const { return fAbsoluteGain;}; // 
+
+  // second
+  void SetLEDRefAmp(int iLEDRef, Float_t f) { fLEDRefAmp[iLEDRef] = f;}; // 
+  Float_t GetLEDRefAmp(int iLEDRef) const { return fLEDRefAmp[iLEDRef];}; // 
+  void SetLEDRefAmpRMS(int iLEDRef, Float_t f) { fLEDRefAmpRMS[iLEDRef] = f;}; // 
+  Float_t GetLEDRefAmpRMS(int iLEDRef) const { return fLEDRefAmpRMS[iLEDRef];}; // 
+  void SetLEDRefHighLowRatio(int iLEDRef, Float_t f) { fLEDRefHighLowRatio[iLEDRef] = f;}; // 
+  Float_t GetLEDRefHighLowRatio(int iLEDRef) const { return fLEDRefHighLowRatio[iLEDRef];}; // 
+  void SetLEDRefHighLow(int iLEDRef, Int_t i) { fLEDRefHighLow[iLEDRef] = i;}; // 
+  Int_t GetLEDRefHighLow(int iLEDRef) const { return fLEDRefHighLow[iLEDRef];}; // 
+
+  void SetTemperature(int itemp, Float_t f) { fTemperature[itemp] = f;}; // 
+  Float_t GetTemperature(int itemp) const { return fTemperature[itemp];}; // 
+  void SetTemperatureRMS(int itemp, Float_t f) { fTemperatureRMS[itemp] = f;}; // 
+  Float_t GetTemperatureRMS(int itemp) const { return fTemperatureRMS[itemp];}; // 
+
+  // third
+  AliEMCALCalibAbsVal * GetAPDVal(int icol, int irow) 
+    { return &fAPDVal[icol][irow]; };
+
+ private:
   // first: overall values for the whole SuperModule
   Int_t fSuperModuleNum; // which SuperModule is this?
   Int_t fCalibMethod; // a la 0=cosmics, 1=pi0, 2=electrons,3=using ecore,
@@ -104,7 +149,7 @@ class AliEMCALSuperModuleCalibAbs : public TObject {
   // third: individual info for each tower
   AliEMCALCalibAbsVal fAPDVal[AliEMCALGeoParams::fgkEMCALCols][AliEMCALGeoParams::fgkEMCALRows]; // at t0
 
-  ClassDef(AliEMCALSuperModuleCalibAbs, 1) // help class
+  ClassDef(AliEMCALSuperModuleCalibAbs, 2) // help class
 };
 // ******* end of internal class definition *************
 
@@ -114,7 +159,7 @@ public:
 
   enum kProblemType {kNoLED=-999};// code in possible problems
 
-  AliEMCALCalibAbs();
+  AliEMCALCalibAbs(const int nSM = AliEMCALGeoParams::fgkEMCALModules);
 
   // Read and Write txt I/O methods are normally not used, but are useful for 
   // filling the object before it is saved in OCDB 
@@ -128,24 +173,25 @@ public:
 
   // pointer to stored info.
   Int_t GetNSuperModule() const { return fNSuperModule; }; 
-  AliEMCALSuperModuleCalibAbs * GetSuperModuleData() const { return fSuperModuleData; };
 
   // - via the index in the stored array:
-  virtual AliEMCALSuperModuleCalibAbs GetSuperModuleCalibAbsId(Int_t smIndex) const;
+  virtual AliEMCALSuperModuleCalibAbs * GetSuperModuleCalibAbsId(Int_t smIndex) const
+   { return (AliEMCALSuperModuleCalibAbs*) fSuperModuleData[smIndex]; };
+
   // - or via the actual SM number
-  virtual AliEMCALSuperModuleCalibAbs GetSuperModuleCalibAbsNum(Int_t smNum) const;
+  virtual AliEMCALSuperModuleCalibAbs * GetSuperModuleCalibAbsNum(Int_t smNum) const;
 
 protected:
 
   Int_t          fNSuperModule; // Number of supermodules.
-  AliEMCALSuperModuleCalibAbs *fSuperModuleData; // SuperModule data
+  TObjArray fSuperModuleData; // SuperModule data
 
 private:
 
   AliEMCALCalibAbs(const AliEMCALCalibAbs &);
   AliEMCALCalibAbs &operator = (const AliEMCALCalibAbs &);
 
-  ClassDef(AliEMCALCalibAbs, 2) //CalibAbs data reader
+  ClassDef(AliEMCALCalibAbs, 3) //CalibAbs data info
 };
 
 #endif
index 8b89940..7c16fee 100644 (file)
@@ -30,11 +30,15 @@ using namespace std;
 ClassImp(AliEMCALCalibMapAPD)
 
 //____________________________________________________________________________
-AliEMCALCalibMapAPD::AliEMCALCalibMapAPD() : 
-  fNSuperModule(0),
-  fSuperModuleData(0)
+AliEMCALCalibMapAPD::AliEMCALCalibMapAPD(const int nSM) : 
+  fNSuperModule(nSM),
+  fSuperModuleData()
 {
   //Default constructor.
+  for (int i=0; i<fNSuperModule; i++) {
+    fSuperModuleData.Add(new AliEMCALSuperModuleCalibMapAPD(i));
+  }
+  fSuperModuleData.Compress(); // compress the TObjArray
 }
 
 //____________________________________________________________________________
@@ -50,8 +54,6 @@ void AliEMCALCalibMapAPD::ReadTextCalibMapAPDInfo(Int_t nSM, const TString &txtF
   }
 
   fNSuperModule = nSM;
-  if (fSuperModuleData) delete [] fSuperModuleData;
-  fSuperModuleData = new AliEMCALSuperModuleCalibMapAPD[fNSuperModule];
 
   Int_t iSM = 0; // SuperModule index
   Int_t iCol = 0;
@@ -69,13 +71,13 @@ void AliEMCALCalibMapAPD::ReadTextCalibMapAPDInfo(Int_t nSM, const TString &txtF
   Int_t nAPDPerSM = AliEMCALGeoParams::fgkEMCALCols * AliEMCALGeoParams::fgkEMCALRows;
 
   for (Int_t i = 0; i < fNSuperModule; i++) {
-    AliEMCALSuperModuleCalibMapAPD &t = fSuperModuleData[i];
+    AliEMCALSuperModuleCalibMapAPD * t = (AliEMCALSuperModuleCalibMapAPD*) fSuperModuleData[i];
     if (!inputFile) {
       printf("AliEMCALCalibMapAPD::ReadCalibMapAPDInfo - Error while reading input file; likely EOF..");
       return;
     }
     inputFile >> iSM;
-    t.fSuperModuleNum = iSM;
+    t->SetSuperModuleNum(iSM);
 
     for (Int_t j=0; j<nAPDPerSM; j++) {
       inputFile >> iCol >> iRow >> iHW 
@@ -91,19 +93,19 @@ void AliEMCALCalibMapAPD::ReadTextCalibMapAPDInfo(Int_t nSM, const TString &txtF
        iRow = AliEMCALGeoParams::fgkEMCALRows-1 - iRow;
       }
 
-      AliEMCALCalibMapAPDVal &v = t.fAPDVal[iCol][iRow];
-
-      v.fHardWareId = iHW;
-      v.fAPDNum = APDNum;
-      v.fV30 = V30;
-      v.fPar[0] = Par[0];
-      v.fPar[1] = Par[1];
-      v.fPar[2] = Par[2];
-      v.fParErr[0] = ParErr[0];
-      v.fParErr[1] = ParErr[1];
-      v.fParErr[2] = ParErr[2];
-      v.fBreakDown = BreakDown;
-      v.fDarkCurrent = DarkCurrent;
+      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);
     }
 
   } // i, SuperModule
@@ -131,14 +133,14 @@ void AliEMCALCalibMapAPD::WriteTextCalibMapAPDInfo(const TString &txtFileName,
   Int_t nAPDPerSM = AliEMCALGeoParams::fgkEMCALCols * AliEMCALGeoParams::fgkEMCALRows;
 
   for (Int_t i = 0; i < fNSuperModule; i++) {
-    AliEMCALSuperModuleCalibMapAPD &t = fSuperModuleData[i];
-    outputFile << t.fSuperModuleNum << endl;
+    AliEMCALSuperModuleCalibMapAPD * t = (AliEMCALSuperModuleCalibMapAPD*) fSuperModuleData[i];
+    outputFile << t->GetSuperModuleNum() << endl;
 
     for (Int_t j=0; j<nAPDPerSM; j++) {
       iCol = j / AliEMCALGeoParams::fgkEMCALRows;
       iRow = j % AliEMCALGeoParams::fgkEMCALRows;
 
-      AliEMCALCalibMapAPDVal &v = t.fAPDVal[iCol][iRow];
+      AliEMCALCalibMapAPDVal * v = t->GetAPDVal(iCol, iRow);
 
       if (swapSides) {
        // C side, oriented differently than A side: swap is requested
@@ -146,11 +148,11 @@ void AliEMCALCalibMapAPD::WriteTextCalibMapAPDInfo(const TString &txtFileName,
        iRow = AliEMCALGeoParams::fgkEMCALRows-1 - iRow;
       }
 
-      outputFile << iCol << " " << iRow << " " << v.fHardWareId 
-                << " " << v.fAPDNum << " " << v.fV30 
-                << " " << v.fPar[0] << " " << v.fPar[1] << " " << v.fPar[2]
-                << " " << v.fParErr[0] << " " << v.fParErr[1] << " " << v.fParErr[2]
-                << " " << v.fBreakDown << " " << v.fDarkCurrent << endl;
+      outputFile << iCol << " " << iRow << " " << v->GetHardWareId() 
+                << " " << v->GetAPDNum() << " " << v->GetV30() 
+                << " " << v->GetPar(0) << " " << v->GetPar(1) << " " << v->GetPar(2)
+                << " " << v->GetParErr(0) << " " << v->GetParErr(1) << " " << v->GetParErr(2)
+                << " " << v->GetBreakDown() << " " << v->GetDarkCurrent() << endl;
     }
 
   } // i, SuperModule
@@ -184,9 +186,6 @@ void AliEMCALCalibMapAPD::ReadTreeCalibMapAPDInfo(TTree *tree,
   Int_t nAPDPerSM = AliEMCALGeoParams::fgkEMCALCols * AliEMCALGeoParams::fgkEMCALRows;
   fNSuperModule = tree->GetEntries() / nAPDPerSM;
 
-  if (fSuperModuleData) delete [] fSuperModuleData;
-  fSuperModuleData = new AliEMCALSuperModuleCalibMapAPD[fNSuperModule];
-
   Int_t iSM = 0; // SuperModule index
   Int_t iCol = 0;
   Int_t iRow = 0;
@@ -216,8 +215,8 @@ void AliEMCALCalibMapAPD::ReadTreeCalibMapAPDInfo(TTree *tree,
     tree->GetEntry(ient);
 
     // assume the index SuperModules come in order: i=iSM
-    AliEMCALSuperModuleCalibMapAPD &t = fSuperModuleData[iSM];
-    t.fSuperModuleNum = iSM;
+    AliEMCALSuperModuleCalibMapAPD * t = (AliEMCALSuperModuleCalibMapAPD*) fSuperModuleData[iSM];
+    t->SetSuperModuleNum(iSM);
 
     // assume that this info is already swapped and done for this basis?
     if (swapSides) {
@@ -226,20 +225,19 @@ void AliEMCALCalibMapAPD::ReadTreeCalibMapAPDInfo(TTree *tree,
       iRow = AliEMCALGeoParams::fgkEMCALRows-1 - iRow;
     }
 
-    AliEMCALCalibMapAPDVal &v = t.fAPDVal[iCol][iRow];
-
-    v.fHardWareId = iHW;
-    v.fAPDNum = APDNum;
-    v.fV30 = V30;
-    v.fPar[0] = Par[0];
-    v.fPar[1] = Par[1];
-    v.fPar[2] = Par[2];
-    v.fParErr[0] = ParErr[0];
-    v.fParErr[1] = ParErr[1];
-    v.fParErr[2] = ParErr[2];
-    v.fBreakDown = BreakDown;
-    v.fDarkCurrent = DarkCurrent;
-
+    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);
   } // 
 
   return;
@@ -285,13 +283,13 @@ void AliEMCALCalibMapAPD::WriteRootCalibMapAPDInfo(const TString &rootFileName,
   Int_t nAPDPerSM = AliEMCALGeoParams::fgkEMCALCols * AliEMCALGeoParams::fgkEMCALRows;
 
   for (iSM = 0; iSM < fNSuperModule; iSM++) {
-    AliEMCALSuperModuleCalibMapAPD &t = fSuperModuleData[iSM];
+    AliEMCALSuperModuleCalibMapAPD * t = (AliEMCALSuperModuleCalibMapAPD *) fSuperModuleData[iSM];
 
     for (Int_t j=0; j<nAPDPerSM; j++) {
       iCol = j / AliEMCALGeoParams::fgkEMCALRows;
       iRow = j % AliEMCALGeoParams::fgkEMCALRows;
 
-      AliEMCALCalibMapAPDVal &v = t.fAPDVal[iCol][iRow];
+      AliEMCALCalibMapAPDVal * v = t->GetAPDVal(iCol, iRow);
 
       if (swapSides) {
        // C side, oriented differently than A side: swap is requested
@@ -299,15 +297,15 @@ void AliEMCALCalibMapAPD::WriteRootCalibMapAPDInfo(const TString &rootFileName,
        iRow = AliEMCALGeoParams::fgkEMCALRows-1 - iRow;
       }
 
-      iHW = v.fHardWareId; 
-      APDNum = v.fAPDNum;
-      V30 = v.fV30;
+      iHW = v->GetHardWareId(); 
+      APDNum = v->GetAPDNum();
+      V30 = v->GetV30();
       for (int k=0; k<3; k++) {
-       Par[k] = v.fPar[k];
-       ParErr[k] = v.fParErr[k];
+       Par[k] = v->GetPar(k);
+       ParErr[k] = v->GetParErr(k);
       } 
-      BreakDown = v.fBreakDown;
-      DarkCurrent = v.fDarkCurrent;
+      BreakDown = v->GetBreakDown();
+      DarkCurrent = v->GetDarkCurrent();
 
       tree->Fill();
     }
@@ -323,32 +321,20 @@ void AliEMCALCalibMapAPD::WriteRootCalibMapAPDInfo(const TString &rootFileName,
 //____________________________________________________________________________
 AliEMCALCalibMapAPD::~AliEMCALCalibMapAPD()
 {
-  delete [] fSuperModuleData;
+  fSuperModuleData.Delete();
 }
 
 //____________________________________________________________________________
-AliEMCALSuperModuleCalibMapAPD AliEMCALCalibMapAPD::GetSuperModuleCalibMapAPDId(Int_t supModIndex)const
+AliEMCALSuperModuleCalibMapAPD * AliEMCALCalibMapAPD::GetSuperModuleCalibMapAPDNum(Int_t supModIndex)const
 {
-  AliEMCALSuperModuleCalibMapAPD t;  // just to maybe prevent a crash, but we are returning something not-initialized so maybe not better really..
-  if (!fSuperModuleData)
-    return t;
-
-  return fSuperModuleData[supModIndex];
-}
-
-//____________________________________________________________________________
-AliEMCALSuperModuleCalibMapAPD AliEMCALCalibMapAPD::GetSuperModuleCalibMapAPDNum(Int_t supModIndex)const
-{
-  AliEMCALSuperModuleCalibMapAPD t;  // just to maybe prevent a crash, but we are returning something not-initialized so maybe not better really..
-  if (!fSuperModuleData)
-    return t;
-
   for (int i=0; i<fNSuperModule; i++) {
-    if (fSuperModuleData[i].fSuperModuleNum == supModIndex) {
-      return fSuperModuleData[i];
+    AliEMCALSuperModuleCalibMapAPD * t = (AliEMCALSuperModuleCalibMapAPD*) fSuperModuleData[i];
+    if (t->GetSuperModuleNum() == supModIndex) {
+      return t;
     }
   }
 
-  return t;
+  // if we arrived here, then nothing was found.. just return a NULL pointer 
+  return NULL;
 }
 
index bd74e2b..89f4591 100644 (file)
@@ -7,6 +7,7 @@
 /* $Id: $ */
 
 #include <TObject.h>
+#include <TObjArray.h>
 #include "AliEMCALGeoParams.h"
 #include <cmath>
 class TString;
@@ -45,6 +46,22 @@ class AliEMCALCalibMapAPDVal : public TObject {
   }
   
  public:
+  void SetHardWareId(Int_t i) { fHardWareId = i; }; //
+  Int_t GetHardWareId() const { return fHardWareId; }; //
+  void SetAPDNum(Int_t i) { fAPDNum = i; }; //
+  Int_t GetAPDNum() const { return fAPDNum; }; //
+  void SetV30(Float_t f) { fV30 = f; }; //
+  Float_t GetV30() const { return fV30; }; // 
+  void SetPar(int ip, Float_t f) { fPar[ip] = f; }; //
+  Float_t GetPar(int ip) const { return fPar[ip]; }; // 
+  void SetParErr(int ip, Float_t f) { fParErr[ip] = f; }; //
+  Float_t GetParErr(int ip) const { return fParErr[ip]; }; // 
+  void SetBreakDown(Int_t i) { fBreakDown = i; }; //
+  Int_t GetBreakDown() const { return fBreakDown; }; //
+  void SetDarkCurrent(Float_t f) { fDarkCurrent = f; }; //
+  Float_t GetDarkCurrent() const { return fDarkCurrent; }; // 
+
+ private:
   Int_t fHardWareId; // HardWareIndex
   // info from APD calibrations
   Int_t fAPDNum;    // assigned APD-PA number; Catania 10000-, Houston: 20000-
@@ -55,15 +72,14 @@ class AliEMCALCalibMapAPDVal : public TObject {
   Int_t fBreakDown; // Hamamatsu Breakdown Voltage (V) 
   Float_t fDarkCurrent; // Hamamatsu Dark Current (A)  
   
-  ClassDef(AliEMCALCalibMapAPDVal, 1) // help class
+  ClassDef(AliEMCALCalibMapAPDVal, 2) // help class
 }; // AliEMCALCalibAPDVal
 
 // 1 SuperModule's worth of info: info on where the different APDs are
 class AliEMCALSuperModuleCalibMapAPD : public TObject {
  public:
-  //    AliEMCALSuperModuleCalibMapAPD(Int_t nSM = 0);
-  AliEMCALSuperModuleCalibMapAPD() : TObject(), // just init values
-    fSuperModuleNum(0)
+  AliEMCALSuperModuleCalibMapAPD(const int smNum=0) : TObject(), // just init values
+    fSuperModuleNum(smNum)
     {
       for (int icol=0; icol<AliEMCALGeoParams::fgkEMCALCols; icol++) {
        for (int irow=0; irow<AliEMCALGeoParams::fgkEMCALRows; irow++) {
@@ -73,10 +89,16 @@ class AliEMCALSuperModuleCalibMapAPD : public TObject {
     }
   
  public:
+  void SetSuperModuleNum(Int_t i) { fSuperModuleNum = i;}; // 
+  Int_t GetSuperModuleNum() const { return fSuperModuleNum;}; // 
+  AliEMCALCalibMapAPDVal * GetAPDVal(int icol, int irow) 
+    { return &fAPDVal[icol][irow]; };
+
+ private:
   Int_t fSuperModuleNum;
   AliEMCALCalibMapAPDVal fAPDVal[AliEMCALGeoParams::fgkEMCALCols][AliEMCALGeoParams::fgkEMCALRows];
   
-  ClassDef(AliEMCALSuperModuleCalibMapAPD, 1) // help class
+  ClassDef(AliEMCALSuperModuleCalibMapAPD, 2) // help class
 };
 // ******* end of internal class definition *************    
     
@@ -86,7 +108,7 @@ public:
 
   enum kValType {kCalibTemp=25};// 25 deg C used for all APD calibrations
 
-  AliEMCALCalibMapAPD();
+  AliEMCALCalibMapAPD(const int nSM = AliEMCALGeoParams::fgkEMCALModules);
 
   // Read and Write txt I/O methods are normally not used, but are useful for 
   // filling the object before it is saved in OCDB 
@@ -100,12 +122,13 @@ public:
 
   // pointer to stored info.
   Int_t GetNSuperModule() const { return fNSuperModule; }; 
-  AliEMCALSuperModuleCalibMapAPD * GetSuperModuleData() const { return fSuperModuleData; };
 
   // - via the index in the stored array:
-  virtual AliEMCALSuperModuleCalibMapAPD GetSuperModuleCalibMapAPDId(Int_t smIndex) const;
+  virtual AliEMCALSuperModuleCalibMapAPD * GetSuperModuleCalibMapAPDId(Int_t smIndex) const
+   { return (AliEMCALSuperModuleCalibMapAPD*) fSuperModuleData[smIndex]; };
+
   // - or via the actual SM number
-  virtual AliEMCALSuperModuleCalibMapAPD GetSuperModuleCalibMapAPDNum(Int_t smNum) const;
+  virtual AliEMCALSuperModuleCalibMapAPD * GetSuperModuleCalibMapAPDNum(Int_t smNum) const;
 
   // method to calculate gain M from fit parameters, and HV value
   Float_t GetGain(Float_t fitPar[3], Float_t HV) const 
@@ -116,14 +139,14 @@ public:
 protected:
 
   Int_t          fNSuperModule; // Number of supermodules.
-  AliEMCALSuperModuleCalibMapAPD *fSuperModuleData; // SuperModule data
+  TObjArray fSuperModuleData; // SuperModule data
 
 private:
 
   AliEMCALCalibMapAPD(const AliEMCALCalibMapAPD &);
   AliEMCALCalibMapAPD &operator = (const AliEMCALCalibMapAPD &);
 
-  ClassDef(AliEMCALCalibMapAPD, 2) //CalibMapAPD data info
+  ClassDef(AliEMCALCalibMapAPD, 3) //CalibMapAPD data info
 };
 
 #endif
index 8cc58db..c634203 100644 (file)
@@ -441,7 +441,7 @@ void AliEMCALCalibTimeDep::GetBiasAPDInfo()
   // pick up Preprocessor output, based on fRun (most recent version)
   AliCDBEntry* entry = AliCDBManager::Instance()->Get("EMCAL/Calib/BiasAPD", fRun);
   if (entry) {
-    fBiasAPD->ReadTreeBiasAPDInfo( (TTree *) entry->GetObject() );
+    fBiasAPD = (AliEMCALBiasAPD *) entry->GetObject();
   }
 
   if (fBiasAPD) { 
@@ -461,7 +461,7 @@ void AliEMCALCalibTimeDep::GetCalibMapAPDInfo()
   AliCDBEntry* entry = AliCDBManager::Instance()->Get("EMCAL/Calib/MapAPD", fRun);
   // stored object should be a TTree; read the info
   if (entry) {
-    fCalibMapAPD->ReadTreeCalibMapAPDInfo( (TTree *) entry->GetObject() );
+    fCalibMapAPD = (AliEMCALCalibMapAPD *) entry->GetObject();
   }
 
   if (fCalibMapAPD) { 
@@ -480,7 +480,7 @@ void AliEMCALCalibTimeDep::GetCalibAbsInfo()
   // pick up Preprocessor output, based on fRun (most recent version)
   AliCDBEntry* entry = AliCDBManager::Instance()->Get("EMCAL/Calib/MapAPD", fRun);
   if (entry) {
-    fCalibAbs->ReadTreeCalibAbsInfo( (TTree *) entry->GetObject() );
+    fCalibAbs = (AliEMCALCalibAbs *) entry->GetObject();
   }
 
   if (fCalibAbs) { 
@@ -504,12 +504,12 @@ Int_t AliEMCALCalibTimeDep::CalcLEDCorrection(Int_t nSM, Int_t nBins)
   Int_t nRemaining = 0; // we count the towers for which we could not get valid data
 
   // sanity check; same SuperModule indices for corrections as for regular calibrations
-  AliEMCALSuperModuleCalibAbs * CalibAbsData = fCalibAbs->GetSuperModuleData();
-  AliEMCALSuperModuleCalibTimeDepCorrection * CalibTimeDepCorrectionData = fCalibTimeDepCorrection->GetSuperModuleData();
-
   for (int i = 0; i < nSM; i++) {
-    int iSMAbs = CalibAbsData[i].fSuperModuleNum;
-    int iSMCorr = CalibTimeDepCorrectionData[i].fSuperModuleNum;
+    AliEMCALSuperModuleCalibAbs * CalibAbsData = fCalibAbs->GetSuperModuleCalibAbsNum(i);
+    AliEMCALSuperModuleCalibTimeDepCorrection * CalibTimeDepCorrectionData = fCalibTimeDepCorrection->GetSuperModuleCalibTimeDepCorrectionNum(i);
+
+    int iSMAbs = CalibAbsData->GetSuperModuleNum();
+    int iSMCorr = CalibTimeDepCorrectionData->GetSuperModuleNum();
     if (iSMAbs != iSMCorr) {
       AliWarning( Form("AliEMCALCalibTimeDep - SuperModule index mismatch: %d != %d", iSMAbs, iSMCorr) );
       nRemaining = nSM * AliEMCALGeoParams::fgkEMCALCols * AliEMCALGeoParams::fgkEMCALRows * nBins;
@@ -654,20 +654,23 @@ Int_t AliEMCALCalibTimeDep::CalcLEDCorrection(Int_t nSM, Int_t nBins)
   Int_t refGain = 0; // typically use low gain for LED reference amplitude (high gain typically well beyond saturation)
 
   for (int i = 0; i < nSM; i++) {
-    iSM = CalibAbsData[i].fSuperModuleNum;
+    AliEMCALSuperModuleCalibAbs * CalibAbsData = fCalibAbs->GetSuperModuleCalibAbsNum(i);
+    AliEMCALSuperModuleCalibTimeDepCorrection * CalibTimeDepCorrectionData = fCalibTimeDepCorrection->GetSuperModuleCalibTimeDepCorrectionNum(i);
+    iSM = CalibAbsData->GetSuperModuleNum();
+
     for (iCol = 0; iCol < AliEMCALGeoParams::fgkEMCALCols; iCol++) {
       //      iStrip = AliEMCALGeoParams::GetStripModule(iSM, iCol);
       iStrip = (iSM%2==0) ? iCol/2 : AliEMCALGeoParams::fgkEMCALLEDRefs - 1 - iCol/2; //TMP, FIXME
       for (iRow = 0; iRow < AliEMCALGeoParams::fgkEMCALRows; iRow++) {
 
        // Calc. R(t0):
-       AliEMCALCalibAbsVal &v = CalibAbsData[i].fAPDVal[iCol][iRow];
-       iGain = v.fHighLow; // gain value used for abs. calibration     
-       refGain = CalibAbsData[i].fLEDRefHighLow[iStrip]; // LED reference gain value used for abs. calibration 
+       AliEMCALCalibAbsVal * absVal = CalibAbsData->GetAPDVal(iCol, iRow);
+       iGain = absVal->GetHighLow(); // gain value used for abs. calibration   
+       refGain = CalibAbsData->GetLEDRefHighLow(iStrip); // LED reference gain value used for abs. calibration 
 
        // valid amplitude values should be larger than 0
-       if (v.fLEDAmp>0 && CalibAbsData[i].fLEDRefAmp[iStrip]>0) {
-         Rt0 =  v.fLEDAmp / CalibAbsData[i].fLEDRefAmp[iStrip];
+       if (absVal->GetLEDAmp()>0 && CalibAbsData->GetLEDRefAmp(iStrip)>0) {
+         Rt0 =  absVal->GetLEDAmp() / CalibAbsData->GetLEDRefAmp(iStrip);
        }
        else {
          Rt0 = fkErrorCode;
@@ -686,7 +689,7 @@ Int_t AliEMCALCalibTimeDep::CalcLEDCorrection(Int_t nSM, Int_t nBins)
            if ( (ampT[iSM][iCol][iRow][iGain].At(j)>AliEMCALGeoParams::fgkOverflowCut && iGain==1) ||
                 (ampLEDRefT[iSM][iStrip][refGain].At(j)>AliEMCALGeoParams::fgkOverflowCut && refGain==1) ) { // presumably the gains should then both be changed.. can look into possibly only changing one in the future
              RT = ampT[iSM][iCol][iRow][0].At(j) / ampLEDRefT[iSM][iStrip][0].At(j); 
-             RT *= v.fHighLowRatio/CalibAbsData[i].fLEDRefHighLowRatio[iStrip]; // compensate for using different gain than in the absolute calibration
+             RT *= absVal->GetHighLowRatio()/CalibAbsData->GetLEDRefHighLowRatio(iStrip); // compensate for using different gain than in the absolute calibration
            }
          }
          else {
@@ -703,7 +706,7 @@ Int_t AliEMCALCalibTimeDep::CalcLEDCorrection(Int_t nSM, Int_t nBins)
          }
 
          // Store the value
-         CalibTimeDepCorrectionData[i].fCorrection[iCol][iRow].AddAt(correction, j);
+         CalibTimeDepCorrectionData->GetCorrection(iCol,iRow)->AddAt(correction, j);
          /* Check that
          fTimeDepCorrection->SetCorrection(i, iCol, iRow, j, correction);
          also works OK */
@@ -723,8 +726,6 @@ Int_t AliEMCALCalibTimeDep::CalcLEDCorrectionStripBasis(Int_t nSM, Int_t nBins)
   // go over fTimeDepCorrection info
   Int_t nRemaining = 0; // we count the towers for which we could not get valid data
 
-  AliEMCALSuperModuleCalibTimeDepCorrection * CalibTimeDepCorrectionData = fCalibTimeDepCorrection->GetSuperModuleData();
-
   // for calculating StripAverage info
   int nValidTower = 0;
   Float_t StripAverage = 0;
@@ -738,7 +739,9 @@ Int_t AliEMCALCalibTimeDep::CalcLEDCorrectionStripBasis(Int_t nSM, Int_t nBins)
   int lastCol = 0;
 
   for (int i = 0; i < nSM; i++) {
-    iSM = CalibTimeDepCorrectionData[i].fSuperModuleNum;
+    AliEMCALSuperModuleCalibTimeDepCorrection * CalibTimeDepCorrectionData = fCalibTimeDepCorrection->GetSuperModuleCalibTimeDepCorrectionNum(i);
+    iSM = CalibTimeDepCorrectionData->GetSuperModuleNum();
+
     for (int j = 0; j < nBins; j++) {
 
       nValidTower = 0;
@@ -753,7 +756,7 @@ Int_t AliEMCALCalibTimeDep::CalcLEDCorrectionStripBasis(Int_t nSM, Int_t nBins)
 
        for (iCol = firstCol; iCol <= lastCol; iCol++) {
          for (iRow = 0; iRow < AliEMCALGeoParams::fgkEMCALRows; iRow++) {
-           val = CalibTimeDepCorrectionData[i].fCorrection[iCol][iRow].At(j);
+           val = CalibTimeDepCorrectionData->GetCorrection(iCol,iRow)->At(j);
            if (val>0) { // valid value; error code is negative
              StripAverage += val;
              nValidTower++;
@@ -766,9 +769,9 @@ Int_t AliEMCALCalibTimeDep::CalcLEDCorrectionStripBasis(Int_t nSM, Int_t nBins)
          StripAverage /= nValidTower;
          for (iCol = firstCol; iCol <= lastCol; iCol++) {
            for (iRow = 0; iRow < AliEMCALGeoParams::fgkEMCALRows; iRow++) {
-             val = CalibTimeDepCorrectionData[i].fCorrection[iCol][iRow].At(j);
+             val = CalibTimeDepCorrectionData->GetCorrection(iCol,iRow)->At(j);
              if (val<0) { // invalid value; error code is negative
-               CalibTimeDepCorrectionData[i].fCorrection[iCol][iRow].AddAt(val, j);
+               CalibTimeDepCorrectionData->GetCorrection(iCol,iRow)->AddAt(val, j);
              }
            }
          }
@@ -793,13 +796,6 @@ Int_t AliEMCALCalibTimeDep::CalcTemperatureCorrection(Int_t nSM, Int_t nBins)
   // For this, we'll need the info from 3 classes (+temperature array), and output the values in a 4th class 
   Int_t nRemaining = 0;
 
-  // info containers
-  AliEMCALSuperModuleBiasAPD * BiasAPDData = fBiasAPD->GetSuperModuleData();
-  AliEMCALSuperModuleCalibMapAPD * CalibMapAPDData = fCalibMapAPD->GetSuperModuleData();
-  AliEMCALSuperModuleCalibAbs * CalibAbsData = fCalibAbs->GetSuperModuleData();
-  // correction container
-  AliEMCALSuperModuleCalibTimeDepCorrection * CalibTimeDepCorrectionData = fCalibTimeDepCorrection->GetSuperModuleData();
-
   int iSM = 0;
   int iCol = 0;
   int iRow = 0;
@@ -811,15 +807,20 @@ Int_t AliEMCALCalibTimeDep::CalcTemperatureCorrection(Int_t nSM, Int_t nBins)
   Double_t secondsPerBin = (3600/fTimeBinsPerHour);
 
   for (int i = 0; i < nSM; i++) {
-    iSM = CalibTimeDepCorrectionData[i].fSuperModuleNum;
+    AliEMCALSuperModuleCalibTimeDepCorrection * CalibTimeDepCorrectionData = fCalibTimeDepCorrection->GetSuperModuleCalibTimeDepCorrectionNum(iSM);
+    iSM = CalibTimeDepCorrectionData->GetSuperModuleNum();
+
+    AliEMCALSuperModuleCalibAbs * CalibAbsData = fCalibAbs->GetSuperModuleCalibAbsNum(iSM);
+    AliEMCALSuperModuleCalibMapAPD * CalibMapAPDData = fCalibMapAPD->GetSuperModuleCalibMapAPDNum(iSM);
+    AliEMCALSuperModuleBiasAPD * BiasAPDData = fBiasAPD->GetSuperModuleBiasAPDNum(iSM);
     
     // first calculate the M=Gain values, and TemperatureCoeff, for all towers in this SuperModule, from BiasAPD and CalibMapAPD info
     for (iCol = 0; iCol < AliEMCALGeoParams::fgkEMCALCols; iCol++) {
       for (iRow = 0; iRow < AliEMCALGeoParams::fgkEMCALRows; iRow++) {
-       AliEMCALCalibMapAPDVal &mapAPD = CalibMapAPDData[i].fAPDVal[iCol][iRow];
-       MGain =  fCalibMapAPD->GetGain(mapAPD.fPar[0], mapAPD.fPar[1], mapAPD.fPar[2], 
-                                      BiasAPDData[i].fVoltage[iCol][iRow]);
-       TempCoeff[iCol][iRow] = GetTempCoeff(mapAPD.fDarkCurrent, MGain);
+       AliEMCALCalibMapAPDVal * mapAPD = CalibMapAPDData->GetAPDVal(iCol, iRow);
+       MGain =  fCalibMapAPD->GetGain(mapAPD->GetPar(0), mapAPD->GetPar(1), mapAPD->GetPar(2), 
+                                      BiasAPDData->GetVoltage(iCol, iRow));
+       TempCoeff[iCol][iRow] = GetTempCoeff(mapAPD->GetDarkCurrent(), MGain);
       }
     }
     
@@ -827,8 +828,8 @@ Int_t AliEMCALCalibTimeDep::CalcTemperatureCorrection(Int_t nSM, Int_t nBins)
     Double_t ReferenceTemperature = 0;
     int nVal = 0;
     for (int iSensor = 0; iSensor<AliEMCALGeoParams::fgkEMCALTempSensors ; iSensor++) {
-      if (CalibAbsData[i].fTemperature[iSensor]>0) { // hopefully OK value
-       ReferenceTemperature += CalibAbsData[i].fTemperature[iSensor];
+      if (CalibAbsData->GetTemperature(iSensor)>0) { // hopefully OK value
+       ReferenceTemperature += CalibAbsData->GetTemperature(iSensor);
        nVal++;
       }
     }
@@ -853,7 +854,7 @@ Int_t AliEMCALCalibTimeDep::CalcTemperatureCorrection(Int_t nSM, Int_t nBins)
            for (iRow = 0; iRow < AliEMCALGeoParams::fgkEMCALRows; iRow++) {
 
              correction = TemperatureDiff * TempCoeff[iCol][iRow];
-             CalibTimeDepCorrectionData[i].fCorrection[iCol][iRow].AddAt(correction, j);
+             CalibTimeDepCorrectionData->GetCorrection(iCol,iRow)->AddAt(correction, j);
            }
          }
 
@@ -862,7 +863,7 @@ Int_t AliEMCALCalibTimeDep::CalcTemperatureCorrection(Int_t nSM, Int_t nBins)
          correction = 1;
          for (iCol = 0; iCol < AliEMCALGeoParams::fgkEMCALCols; iCol++) {
            for (iRow = 0; iRow < AliEMCALGeoParams::fgkEMCALRows; iRow++) {
-             CalibTimeDepCorrectionData[i].fCorrection[iCol][iRow].AddAt(correction, j);
+             CalibTimeDepCorrectionData->GetCorrection(iCol,iRow)->AddAt(correction, j);
            }
          }
        } // else
index 8b6c1e1..54a3129 100644 (file)
@@ -20,7 +20,6 @@
 
 #include <fstream>
 #include <TString.h>
-#include <TArrayF.h>
 #include <TFile.h>
 #include <TTree.h>
 
@@ -31,14 +30,18 @@ using namespace std;
 ClassImp(AliEMCALCalibTimeDepCorrection)
 
 //____________________________________________________________________________
-AliEMCALCalibTimeDepCorrection::AliEMCALCalibTimeDepCorrection() : 
-  fNSuperModule(0),
-  fSuperModuleData(0),
+AliEMCALCalibTimeDepCorrection::AliEMCALCalibTimeDepCorrection(const int nSM) : 
+  fNSuperModule(nSM),
+  fSuperModuleData(),
   fStartTime(0),
   fNTimeBins(0),
   fTimeBinSize(0)
 {
   //Default constructor.
+  for (int i=0; i<fNSuperModule; i++) {
+    fSuperModuleData.Add(new AliEMCALSuperModuleCalibTimeDepCorrection(i));
+  }
+  fSuperModuleData.Compress(); // compress the TObjArray
 }
 
 //____________________________________________________________________________
@@ -46,8 +49,6 @@ void AliEMCALCalibTimeDepCorrection::InitCorrection(Int_t nSM, Int_t nBins, Floa
 {
   // This methods assumes that you are using SuperModules 0..nSM-1
   fNSuperModule = nSM;
-  if (fSuperModuleData) delete [] fSuperModuleData;
-  fSuperModuleData = new AliEMCALSuperModuleCalibTimeDepCorrection[fNSuperModule];
 
   Int_t iSM = 0; // SuperModule index
   Int_t iCol = 0;
@@ -58,16 +59,16 @@ void AliEMCALCalibTimeDepCorrection::InitCorrection(Int_t nSM, Int_t nBins, Floa
   Int_t nAPDPerSM = AliEMCALGeoParams::fgkEMCALCols * AliEMCALGeoParams::fgkEMCALRows;
 
   for (Int_t i = 0; i < fNSuperModule; i++) {
-    AliEMCALSuperModuleCalibTimeDepCorrection &t = fSuperModuleData[i];
-    t.fSuperModuleNum = iSM; // assume SMs are coming in order
+    AliEMCALSuperModuleCalibTimeDepCorrection * t = (AliEMCALSuperModuleCalibTimeDepCorrection*) fSuperModuleData[i];
+    t->SetSuperModuleNum(iSM); // assume SMs are coming in order
 
     for (Int_t j=0; j<nAPDPerSM; j++) {
 
       // set size of TArray
-      t.fCorrection[iCol][iRow].Set(nCorr);
+      t->GetCorrection(iCol,iRow)->Set(nCorr);
       for (Int_t k=0; k<nCorr; k++) {
        // add to TArray
-       t.fCorrection[iCol][iRow].AddAt(Correction, k); // AddAt = SetAt..
+       t->GetCorrection(iCol,iRow)->AddAt(Correction, k); // AddAt = SetAt..
       }
     }
 
@@ -79,14 +80,14 @@ void AliEMCALCalibTimeDepCorrection::InitCorrection(Int_t nSM, Int_t nBins, Floa
 //____________________________________________________________________________
 void AliEMCALCalibTimeDepCorrection::SetCorrection(Int_t supModIndex, Int_t iCol, Int_t iRow, Int_t iBin, Float_t val)
 { // if you call for non-existing data, there may be a crash..
-  fSuperModuleData[supModIndex].fCorrection[iCol][iRow].AddAt(val, iBin); // AddAt = SetAt..
+  ((AliEMCALSuperModuleCalibTimeDepCorrection*)fSuperModuleData[supModIndex])->GetCorrection(iCol,iRow)->AddAt(val, iBin); // AddAt = SetAt..
  return; 
 }
 
 //____________________________________________________________________________
-Float_t AliEMCALCalibTimeDepCorrection::GetCorrection(Int_t supModIndex, Int_t iCol, Int_t iRow, Int_t iBin)const
+Float_t AliEMCALCalibTimeDepCorrection::GetCorrection(Int_t supModIndex, Int_t iCol, Int_t iRow, Int_t iBin) const
 { // if you call for non-existing data, there may be a crash..
-  return fSuperModuleData[supModIndex].fCorrection[iCol][iRow].At(iBin);
+  ((AliEMCALSuperModuleCalibTimeDepCorrection*)fSuperModuleData[supModIndex])->GetCorrection(iCol,iRow)->At(iBin);
 }
 
 //____________________________________________________________________________
@@ -102,8 +103,6 @@ void AliEMCALCalibTimeDepCorrection::ReadTextInfo(Int_t nSM, const TString &txtF
   }
 
   fNSuperModule = nSM;
-  if (fSuperModuleData) delete [] fSuperModuleData;
-  fSuperModuleData = new AliEMCALSuperModuleCalibTimeDepCorrection[fNSuperModule];
 
   Int_t iSM = 0; // SuperModule index
   Int_t iCol = 0;
@@ -117,13 +116,14 @@ void AliEMCALCalibTimeDepCorrection::ReadTextInfo(Int_t nSM, const TString &txtF
   inputFile >> fStartTime >> fNTimeBins >> fTimeBinSize;
 
   for (Int_t i = 0; i < fNSuperModule; i++) {
-    AliEMCALSuperModuleCalibTimeDepCorrection &t = fSuperModuleData[i];
+    AliEMCALSuperModuleCalibTimeDepCorrection * t = (AliEMCALSuperModuleCalibTimeDepCorrection*) fSuperModuleData[i];
+
     if (!inputFile) {
       printf("AliEMCALCalibTimeDepCorrection::ReadTextInfo - Error while reading input file; likely EOF..");
       return;
     }
     inputFile >> iSM;
-    t.fSuperModuleNum = iSM;
+    t->SetSuperModuleNum(iSM);
 
     for (Int_t j=0; j<nAPDPerSM; j++) {
       inputFile >> iCol >> iRow >> nCorr;
@@ -136,11 +136,11 @@ void AliEMCALCalibTimeDepCorrection::ReadTextInfo(Int_t nSM, const TString &txtF
       }
 
       // set size of TArray
-      t.fCorrection[iCol][iRow].Set(nCorr);
+      t->GetCorrection(iCol,iRow)->Set(nCorr);
       for (Int_t k=0; k<nCorr; k++) {
        inputFile >> Correction;
        // add to TArray
-       t.fCorrection[iCol][iRow].AddAt(Correction, k);
+       t->GetCorrection(iCol,iRow)->AddAt(Correction, k);
       }
     }
 
@@ -173,14 +173,14 @@ void AliEMCALCalibTimeDepCorrection::WriteTextInfo(const TString &txtFileName,
   outputFile << fStartTime << " " << fNTimeBins << " " << fTimeBinSize << endl;
 
   for (Int_t i = 0; i < fNSuperModule; i++) {
-    AliEMCALSuperModuleCalibTimeDepCorrection &t = fSuperModuleData[i];
-    outputFile << t.fSuperModuleNum << endl;
+    AliEMCALSuperModuleCalibTimeDepCorrection * t = (AliEMCALSuperModuleCalibTimeDepCorrection*) fSuperModuleData[i];
+    outputFile << t->GetSuperModuleNum() << endl;
 
     for (Int_t j=0; j<nAPDPerSM; j++) {
       iCol = j / AliEMCALGeoParams::fgkEMCALRows;
       iRow = j % AliEMCALGeoParams::fgkEMCALRows;
 
-      nCorr = t.fCorrection[iCol][iRow].GetSize();
+      nCorr = t->GetCorrection(iCol,iRow)->GetSize();
 
       if (swapSides) {
        // C side, oriented differently than A side: swap is requested
@@ -190,7 +190,7 @@ void AliEMCALCalibTimeDepCorrection::WriteTextInfo(const TString &txtFileName,
 
       outputFile << iCol << " " << iRow << " " << nCorr << endl;
       for (Int_t k=0; k<nCorr; k++) {
-       outputFile << t.fCorrection[iCol][iRow].At(k) << " ";
+       outputFile << t->GetCorrection(iCol,iRow)->At(k) << " ";
       }
       outputFile << endl;
 
@@ -234,9 +234,6 @@ void AliEMCALCalibTimeDepCorrection::ReadTreeInfo(TTree *treeGlob, TTree *treeCo
   treeGlob->SetBranchAddress("fTimeBinSize", &fTimeBinSize);
   treeGlob->GetEntry(0); 
 
-  if (fSuperModuleData) delete [] fSuperModuleData;
-  fSuperModuleData = new AliEMCALSuperModuleCalibTimeDepCorrection[fNSuperModule];
-
   Int_t iSM = 0; // SuperModule index
   Int_t iCol = 0;
   Int_t iRow = 0;
@@ -258,8 +255,8 @@ void AliEMCALCalibTimeDepCorrection::ReadTreeInfo(TTree *treeGlob, TTree *treeCo
     treeCorr->GetEntry(ient);
 
     // assume the index SuperModules come in order: i=iSM
-    AliEMCALSuperModuleCalibTimeDepCorrection &t = fSuperModuleData[iSM];
-    t.fSuperModuleNum = iSM;
+    AliEMCALSuperModuleCalibTimeDepCorrection * t = (AliEMCALSuperModuleCalibTimeDepCorrection*) fSuperModuleData[iSM];
+    t->SetSuperModuleNum(iSM);
 
     // assume that this info is already swapped and done for this basis?
     if (swapSides) {
@@ -270,10 +267,10 @@ void AliEMCALCalibTimeDepCorrection::ReadTreeInfo(TTree *treeGlob, TTree *treeCo
 
 
     // set size of TArray
-    t.fCorrection[iCol][iRow].Set(nCorr);
+    t->GetCorrection(iCol,iRow)->Set(nCorr);
     for (Int_t k=0; k<nCorr; k++) {
       // add to TArray
-      t.fCorrection[iCol][iRow].AddAt(correction[k], k);
+      t->GetCorrection(iCol,iRow)->AddAt(correction[k], k);
     }
 
   } // entry
@@ -320,13 +317,13 @@ void AliEMCALCalibTimeDepCorrection::WriteRootInfo(const TString &rootFileName,
   Int_t nAPDPerSM = AliEMCALGeoParams::fgkEMCALCols * AliEMCALGeoParams::fgkEMCALRows;
 
   for (iSM = 0; iSM < fNSuperModule; iSM++) {
-    AliEMCALSuperModuleCalibTimeDepCorrection &t = fSuperModuleData[iSM];
+    AliEMCALSuperModuleCalibTimeDepCorrection * t = (AliEMCALSuperModuleCalibTimeDepCorrection*) fSuperModuleData[iSM];
 
     for (Int_t j=0; j<nAPDPerSM; j++) {
       iCol = j / AliEMCALGeoParams::fgkEMCALRows;
       iRow = j % AliEMCALGeoParams::fgkEMCALRows;
 
-      nCorr = t.fCorrection[iCol][iRow].GetSize();
+      nCorr = t->GetCorrection(iCol,iRow)->GetSize();
       if (nCorr > fgkMaxTimeBins) {
        printf("AliEMCALCalibTimeDepCorrection::WriteRootInfo - too many correction/timebins %d kept\n", nCorr);
        return;
@@ -339,7 +336,7 @@ void AliEMCALCalibTimeDepCorrection::WriteRootInfo(const TString &rootFileName,
       }
 
       for (Int_t k=0; k<nCorr; k++) {
-       correction[k] = t.fCorrection[iCol][iRow].At(k);
+       correction[k] = t->GetCorrection(iCol,iRow)->At(k);
       }
 
       treeCorr->Fill();
@@ -357,32 +354,20 @@ void AliEMCALCalibTimeDepCorrection::WriteRootInfo(const TString &rootFileName,
 //____________________________________________________________________________
 AliEMCALCalibTimeDepCorrection::~AliEMCALCalibTimeDepCorrection()
 {
-  delete [] fSuperModuleData;
-}
-
-//____________________________________________________________________________
-AliEMCALSuperModuleCalibTimeDepCorrection AliEMCALCalibTimeDepCorrection::GetSuperModuleCalibTimeDepCorrectionId(Int_t supModIndex)const
-{
-  AliEMCALSuperModuleCalibTimeDepCorrection t;  // just to maybe prevent a crash, but we are returning something not-initialized so maybe not better really..
-  if (!fSuperModuleData)
-    return t;
-
-  return fSuperModuleData[supModIndex];
+  fSuperModuleData.Delete();
 }
 
 //____________________________________________________________________________
-AliEMCALSuperModuleCalibTimeDepCorrection AliEMCALCalibTimeDepCorrection::GetSuperModuleCalibTimeDepCorrectionNum(Int_t supModIndex)const
+AliEMCALSuperModuleCalibTimeDepCorrection * AliEMCALCalibTimeDepCorrection::GetSuperModuleCalibTimeDepCorrectionNum(Int_t supModIndex)const
 {
-  AliEMCALSuperModuleCalibTimeDepCorrection t;  // just to maybe prevent a crash, but we are returning something not-initialized so maybe not better really..
-  if (!fSuperModuleData)
-    return t;
-
   for (int i=0; i<fNSuperModule; i++) {
-    if (fSuperModuleData[i].fSuperModuleNum == supModIndex) {
-      return fSuperModuleData[i];
+    AliEMCALSuperModuleCalibTimeDepCorrection * t = (AliEMCALSuperModuleCalibTimeDepCorrection*) fSuperModuleData[i];
+    if (t->GetSuperModuleNum() == supModIndex) {
+      return t;
     }
   }
 
-  return t;
+  // if we arrived here, then nothing was found.. just return a NULL pointer 
+  return NULL;
 }
 
index 83cf965..d7650da 100644 (file)
@@ -7,6 +7,7 @@
 /* $Id: $ */
 
 #include <TObject.h>
+#include <TObjArray.h>
 #include <TArrayF.h>
 #include "AliEMCALGeoParams.h"
 class TString;
@@ -20,8 +21,8 @@ class TTree;
 // 1 SuperModule's worth of info
 class AliEMCALSuperModuleCalibTimeDepCorrection : public TObject {
  public:
-  AliEMCALSuperModuleCalibTimeDepCorrection() : TObject(), // just init values
-    fSuperModuleNum(0)
+  AliEMCALSuperModuleCalibTimeDepCorrection(const int smNum=0) : TObject(), // just init values
+    fSuperModuleNum(smNum)
     {
       for (int icol=0; icol<AliEMCALGeoParams::fgkEMCALCols; icol++) {
        for (int irow=0; irow<AliEMCALGeoParams::fgkEMCALRows; irow++) {
@@ -31,16 +32,22 @@ class AliEMCALSuperModuleCalibTimeDepCorrection : public TObject {
     }
 
  public:
+  void SetSuperModuleNum(Int_t i) { fSuperModuleNum = i;}; // 
+  Int_t GetSuperModuleNum() const { return fSuperModuleNum;}; // 
+  TArrayF * GetCorrection(int icol, int irow) 
+    { return &fCorrection[icol][irow]; };
+
+ private:
   Int_t fSuperModuleNum;
   TArrayF fCorrection[AliEMCALGeoParams::fgkEMCALCols][AliEMCALGeoParams::fgkEMCALRows]; 
 
-  ClassDef(AliEMCALSuperModuleCalibTimeDepCorrection, 1) // help class
+  ClassDef(AliEMCALSuperModuleCalibTimeDepCorrection, 2) // help class
 };
 // ******* end of internal class definition *************
 
 class AliEMCALCalibTimeDepCorrection : public TObject {
  public:
-  AliEMCALCalibTimeDepCorrection();
+  AliEMCALCalibTimeDepCorrection(const int nSM = AliEMCALGeoParams::fgkEMCALModules);
 
   // interface methods; getting the whole struct should be more efficient though
   void InitCorrection(Int_t nSM, Int_t nBins, Float_t val); // assign a certain value to all 
@@ -48,7 +55,6 @@ class AliEMCALCalibTimeDepCorrection : public TObject {
   void SetCorrection(Int_t smIndex, Int_t iCol, Int_t iRow, Int_t iBin, Float_t val=1.0); // assign a certain value to a given bin
   Float_t GetCorrection(Int_t smIndex, Int_t iCol, Int_t iRow, Int_t iBin) const; // assign a certain value to a given bin
  
-
   // Read and Write txt I/O methods are normally not used, but are useful for 
   // filling the object before it is saved in OCDB 
   void ReadTextInfo(Int_t nSM, const TString &txtFileName, Bool_t swapSides=kFALSE); // info file is for nSm=1 to 12 SuperModules
@@ -61,12 +67,13 @@ class AliEMCALCalibTimeDepCorrection : public TObject {
 
   // pointer to stored info.
   Int_t GetNSuperModule() const { return fNSuperModule; }; 
-  AliEMCALSuperModuleCalibTimeDepCorrection * GetSuperModuleData() const { return fSuperModuleData; };
-
   // - via the index in the stored array:
-  virtual AliEMCALSuperModuleCalibTimeDepCorrection GetSuperModuleCalibTimeDepCorrectionId(Int_t smIndex) const;
+  virtual AliEMCALSuperModuleCalibTimeDepCorrection * GetSuperModuleCalibTimeDepCorrectionId(Int_t smIndex) const
+    { return (AliEMCALSuperModuleCalibTimeDepCorrection*) fSuperModuleData[smIndex]; };
+
   // - or via the actual SM number
-  virtual AliEMCALSuperModuleCalibTimeDepCorrection GetSuperModuleCalibTimeDepCorrectionNum(Int_t smNum) const;
+  virtual AliEMCALSuperModuleCalibTimeDepCorrection * GetSuperModuleCalibTimeDepCorrectionNum(Int_t smNum) const;
 
   void SetStartTime(UInt_t ui) { fStartTime = ui; } //
   void SetNTimeBins(Int_t i) { fNTimeBins = i; } // 
@@ -81,7 +88,7 @@ class AliEMCALCalibTimeDepCorrection : public TObject {
 protected:
 
   Int_t          fNSuperModule; // Number of supermodules.
-  AliEMCALSuperModuleCalibTimeDepCorrection *fSuperModuleData; // SuperModule data
+  TObjArray fSuperModuleData; // SuperModule data
 
 private:
 
@@ -94,7 +101,7 @@ private:
 
   static const Int_t fgkMaxTimeBins = 50; // we are not going to have more correction time bins than this for a single runnumber.. 
 
-  ClassDef(AliEMCALCalibTimeDepCorrection, 2) //
+  ClassDef(AliEMCALCalibTimeDepCorrection, 3) //
 };
 
 #endif