intermediate calibration class commit: struct changed to classes and added root i/o
authordsilverm <dsilverm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 9 Sep 2009 13:46:39 +0000 (13:46 +0000)
committerdsilverm <dsilverm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 9 Sep 2009 13:46:39 +0000 (13: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 7480984..c11782d 100644 (file)
@@ -20,6 +20,8 @@
 
 #include <fstream>
 #include <TString.h>
+#include <TFile.h>
+#include <TTree.h>
 
 #include "AliEMCALBiasAPD.h"
 
@@ -36,8 +38,8 @@ AliEMCALBiasAPD::AliEMCALBiasAPD() :
 }
 
 //____________________________________________________________________________
-void AliEMCALBiasAPD::ReadBiasAPDInfo(Int_t nSM, const TString &txtFileName,
-                                     Bool_t swapSides)
+void AliEMCALBiasAPD::ReadTextBiasAPDInfo(Int_t nSM, const TString &txtFileName,
+                                         Bool_t swapSides)
 {
   //Read data from txt file. ; coordinates given on SuperModule basis
 
@@ -92,8 +94,8 @@ void AliEMCALBiasAPD::ReadBiasAPDInfo(Int_t nSM, const TString &txtFileName,
 }
 
 //____________________________________________________________________________
-void AliEMCALBiasAPD::WriteBiasAPDInfo(const TString &txtFileName,
-                                      Bool_t swapSides)
+void AliEMCALBiasAPD::WriteTextBiasAPDInfo(const TString &txtFileName,
+                                          Bool_t swapSides)
 {
   // write data to txt file. ; coordinates given on SuperModule basis
 
@@ -142,13 +144,138 @@ void AliEMCALBiasAPD::WriteBiasAPDInfo(const TString &txtFileName,
 }
 
 //____________________________________________________________________________
+void AliEMCALBiasAPD::ReadRootBiasAPDInfo(const TString &rootFileName,
+                                         Bool_t swapSides)
+{
+  //Read data from root file. ; coordinates given on SuperModule basis
+  TFile inputFile(rootFileName, "read");  
+
+  TTree *tree = (TTree*) inputFile.Get("tree");
+
+  ReadTreeBiasAPDInfo(tree, swapSides);
+
+  inputFile.Close();
+
+  return;
+}
+
+//____________________________________________________________________________
+void AliEMCALBiasAPD::ReadTreeBiasAPDInfo(TTree *tree,
+                                         Bool_t swapSides)
+{
+ // how many SuperModule's worth of entries / APDs do we have?
+  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;
+  // list of values to be read
+  Int_t iElecId = 0;
+  Int_t iDAC = 0;
+  Float_t voltage = 0;     
+  // end - all values
+
+  // declare the branches
+  tree->SetBranchAddress("iSM", &iSM);
+  tree->SetBranchAddress("iCol", &iCol);
+  tree->SetBranchAddress("iRow", &iRow);
+  tree->SetBranchAddress("iElecId", &iElecId);
+  tree->SetBranchAddress("iDAC", &iDAC);
+  tree->SetBranchAddress("voltage", &voltage);
+
+  for (int ient=0; ient<tree->GetEntries(); ient++) {
+    tree->GetEntry(ient);
+
+    // assume the index SuperModules come in order: i=iSM
+    AliEMCALSuperModuleBiasAPD &t = fSuperModuleData[iSM];
+    t.fSuperModuleNum = iSM;
+
+    // assume that this info is already swapped and done for this basis?
+    if (swapSides) {
+      // C side, oriented differently than A side: swap is requested
+      iCol = AliEMCALGeoParams::fgkEMCALCols-1 - iCol;
+      iRow = AliEMCALGeoParams::fgkEMCALRows-1 - iRow;
+    }
+
+    t.fElecId[iCol][iRow] = iElecId;
+    t.fDAC[iCol][iRow] = iDAC;
+    t.fVoltage[iCol][iRow] = voltage;
+
+  } // 
+
+  return;
+}
+
+//____________________________________________________________________________
+void AliEMCALBiasAPD::WriteRootBiasAPDInfo(const TString &rootFileName,
+                                          Bool_t swapSides)
+{
+  // write data to root file. ; coordinates given on SuperModule basis
+  TFile destFile(rootFileName, "recreate");  
+  if (destFile.IsZombie()) {
+    return;
+  }  
+  destFile.cd();
+
+  TTree *tree = new TTree("tree","");
+
+  // variables for filling the TTree
+  Int_t iSM = 0; // SuperModule index
+  Int_t iCol = 0;
+  Int_t iRow = 0;
+  Int_t iElecId = 0;
+  Int_t iDAC = 0;
+  Float_t voltage = 0;
+  // declare the branches
+  tree->Branch("iSM", &iSM, "iSM/I");
+  tree->Branch("iCol", &iCol, "iCol/I");
+  tree->Branch("iRow", &iRow, "iRow/I");
+  tree->Branch("iElecId", &iElecId, "iElecId/I");
+  tree->Branch("iDAC", &iDAC, "iDAC/I");
+  tree->Branch("voltage", &voltage, "voltage/F");
+
+  Int_t nAPDPerSM = AliEMCALGeoParams::fgkEMCALCols * AliEMCALGeoParams::fgkEMCALRows;
+
+  for (iSM = 0; iSM < fNSuperModule; iSM++) {
+    AliEMCALSuperModuleBiasAPD &t = 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];
+
+      if (swapSides) {
+       // C side, oriented differently than A side: swap is requested
+       iCol = AliEMCALGeoParams::fgkEMCALCols-1 - iCol;
+       iRow = AliEMCALGeoParams::fgkEMCALRows-1 - iRow;
+      }
+
+      tree->Fill();
+    }
+
+  } // i, SuperModule
+
+  tree->Write();
+  destFile.Close();
+
+  return;
+}
+
+//____________________________________________________________________________
 AliEMCALBiasAPD::~AliEMCALBiasAPD()
 {
   delete [] fSuperModuleData;
 }
 
 //____________________________________________________________________________
-AliEMCALBiasAPD::AliEMCALSuperModuleBiasAPD AliEMCALBiasAPD::GetSuperModuleBiasAPDId(Int_t supModIndex)const
+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)
@@ -158,7 +285,7 @@ AliEMCALBiasAPD::AliEMCALSuperModuleBiasAPD AliEMCALBiasAPD::GetSuperModuleBiasA
 }
 
 //____________________________________________________________________________
-AliEMCALBiasAPD::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)
index 578a050..0e8d0cd 100644 (file)
@@ -9,31 +9,52 @@
 #include <TObject.h>
 #include "AliEMCALGeoParams.h"
 class TString;
+class TTree;
 
 /*
-  Objects of this class read txt file with APD data
-  AliEMCALBiasAPD inherits TObject only to use AliLog "functions".
+  Objects of this class contain info on APD bias settings/voltages
 */
 
+// ******* internal class definition *************
+// 1 SuperModule's worth of info
+class AliEMCALSuperModuleBiasAPD : public TObject {
+ public:
+  AliEMCALSuperModuleBiasAPD() : TObject(), // just init values
+    fSuperModuleNum(0)
+    {
+      for (int icol=0; icol<AliEMCALGeoParams::fgkEMCALCols; icol++) {
+       for (int irow=0; irow<AliEMCALGeoParams::fgkEMCALRows; irow++) {
+         fElecId[icol][irow] = 0;
+         fDAC[icol][irow] = 0;
+         fVoltage[icol][irow] = 0;
+       }
+      }
+    }
+
+ public:
+  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
+};
+// ******* end of internal class definition *************
+
 class AliEMCALBiasAPD : public TObject {
 public:
   AliEMCALBiasAPD();
 
   // 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 ReadBiasAPDInfo(Int_t nSM, const TString &txtFileName, Bool_t swapSides=kFALSE); // info file is for nSm=1 to 12 SuperModules
-
-  void WriteBiasAPDInfo(const TString &txtFileName, Bool_t swapSides=kFALSE); // info file is for nSm=1 to 12 SuperModules
+  void ReadTextBiasAPDInfo(Int_t nSM, const TString &txtFileName, Bool_t swapSides=kFALSE); // info file is for nSm=1 to 12 SuperModules
+  void WriteTextBiasAPDInfo(const TString &txtFileName, Bool_t swapSides=kFALSE); // info file is for nSm=1 to 12 SuperModules
+  void ReadRootBiasAPDInfo(const TString &rootFileName, Bool_t swapSides=kFALSE); // info file is for nSm=1 to 12 SuperModules
+  void ReadTreeBiasAPDInfo(TTree *tree, Bool_t swapSides=kFALSE); // info file is for nSm=1 to 12 SuperModules
+  void WriteRootBiasAPDInfo(const TString &rootFileName, Bool_t swapSides=kFALSE); // info file is for nSm=1 to 12 SuperModules
 
   virtual ~AliEMCALBiasAPD();
 
-  struct AliEMCALSuperModuleBiasAPD {
-    Int_t fSuperModuleNum;
-    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)
-  };
-
   // pointer to stored info.
   Int_t GetNSuperModule() const { return fNSuperModule; }; 
   AliEMCALSuperModuleBiasAPD * GetSuperModuleData() const { return fSuperModuleData; };
@@ -53,7 +74,7 @@ private:
   AliEMCALBiasAPD(const AliEMCALBiasAPD &);
   AliEMCALBiasAPD &operator = (const AliEMCALBiasAPD &);
 
-  ClassDef(AliEMCALBiasAPD, 1) //BiasAPD data reader
+  ClassDef(AliEMCALBiasAPD, 2) //BiasAPD data reader
 };
 
 #endif
index 2d21563..02bc142 100644 (file)
@@ -20,6 +20,8 @@
 
 #include <fstream>
 #include <TString.h>
+#include <TFile.h>
+#include <TTree.h>
 
 #include "AliEMCALCalibAbs.h"
 
@@ -36,8 +38,8 @@ AliEMCALCalibAbs::AliEMCALCalibAbs() :
 }
 
 //____________________________________________________________________________
-void AliEMCALCalibAbs::ReadCalibAbsInfo(Int_t nSM, const TString &txtFileName,
-                                     Bool_t swapSides)
+void AliEMCALCalibAbs::ReadTextCalibAbsInfo(Int_t nSM, const TString &txtFileName,
+                                           Bool_t swapSides)
 {
   //Read data from txt file. ; coordinates given on SuperModule basis
 
@@ -138,8 +140,8 @@ void AliEMCALCalibAbs::ReadCalibAbsInfo(Int_t nSM, const TString &txtFileName,
 }
 
 //____________________________________________________________________________
-void AliEMCALCalibAbs::WriteCalibAbsInfo(const TString &txtFileName,
-                                      Bool_t swapSides)
+void AliEMCALCalibAbs::WriteTextCalibAbsInfo(const TString &txtFileName,
+                                            Bool_t swapSides)
 {
   // write data to txt file. ; coordinates given on SuperModule basis
 
@@ -173,6 +175,7 @@ void AliEMCALCalibAbs::WriteCalibAbsInfo(const TString &txtFileName,
       outputFile << j << " " << t.fTemperature[j] << " " << t.fTemperatureRMS[j] << endl;
     }
 
+    // third: info for each tower
     for (Int_t j=0; j<nAPDPerSM; j++) {
       iCol = j / AliEMCALGeoParams::fgkEMCALRows;
       iRow = j % AliEMCALGeoParams::fgkEMCALRows;
@@ -201,13 +204,282 @@ void AliEMCALCalibAbs::WriteCalibAbsInfo(const TString &txtFileName,
 }
 
 //____________________________________________________________________________
+void AliEMCALCalibAbs::ReadRootCalibAbsInfo(const TString &rootFileName,
+                                           Bool_t swapSides)
+{
+  //Read data from root file. ; coordinates given on SuperModule basis
+  TFile inputFile(rootFileName, "read");  
+
+  TTree *tree = (TTree*) inputFile.Get("tree");
+
+  ReadTreeCalibAbsInfo(tree, swapSides);
+
+  inputFile.Close();
+
+  return;
+}
+
+//____________________________________________________________________________
+void AliEMCALCalibAbs::ReadTreeCalibAbsInfo(TTree *tree,
+                                           Bool_t swapSides)
+{
+  // how many SuperModule's worth of entries / APDs do we have?
+  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
+  Int_t CalibMethod; 
+  Int_t CalibPass= {0}; 
+  Int_t CalibTime= {0}; 
+  Float_t AbsoluteGain= {0}; 
+  // second: additional info for LED Reference and SM temperature
+  Float_t LEDRefAmp[AliEMCALGeoParams::fgkEMCALLEDRefs]= {0};
+  Float_t LEDRefAmpRMS[AliEMCALGeoParams::fgkEMCALLEDRefs]= {0};
+  Float_t LEDRefHighLowRatio[AliEMCALGeoParams::fgkEMCALLEDRefs]= {0};
+  Int_t LEDRefHighLow[AliEMCALGeoParams::fgkEMCALLEDRefs]= {0};
+  Float_t Temperature[AliEMCALGeoParams::fgkEMCALTempSensors]= {0};
+  Float_t TemperatureRMS[AliEMCALGeoParams::fgkEMCALTempSensors]= {0};
+  // third: info for each tower
+  Float_t RelativeGain[AliEMCALGeoParams::fgkEMCALCols][AliEMCALGeoParams::fgkEMCALRows]= {0}; 
+  Float_t HighLowRatio[AliEMCALGeoParams::fgkEMCALCols][AliEMCALGeoParams::fgkEMCALRows]= {0}; 
+  Int_t HighLow[AliEMCALGeoParams::fgkEMCALCols][AliEMCALGeoParams::fgkEMCALRows]= {0}; 
+  Float_t LEDAmp[AliEMCALGeoParams::fgkEMCALCols][AliEMCALGeoParams::fgkEMCALRows]= {0}; 
+  Float_t LEDAmpRMS[AliEMCALGeoParams::fgkEMCALCols][AliEMCALGeoParams::fgkEMCALRows]= {0}; 
+  // 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(LEDRefHighLowRatio, 0, sizeof(LEDRefHighLowRatio)); 
+  memset(LEDRefHighLow, 0, sizeof(LEDRefHighLow)); 
+  memset(Temperature, 0, sizeof(Temperature)); 
+  memset(TemperatureRMS, 0, sizeof(TemperatureRMS)); 
+  memset(RelativeGain, 0, sizeof(RelativeGain)); 
+  memset(HighLowRatio, 0, sizeof(HighLowRatio)); 
+  memset(HighLow, 0, sizeof(HighLow)); 
+  memset(LEDAmp, 0, sizeof(LEDAmp)); 
+  memset(LEDAmpRMS, 0, sizeof(LEDAmpRMS)); 
+
+  // declare the branches
+  tree->SetBranchAddress("iSM", &iSM);
+  tree->SetBranchAddress("CalibMethod", &CalibMethod);
+  tree->SetBranchAddress("CalibPass", &CalibPass);
+  tree->SetBranchAddress("CalibTime", &CalibTime);
+  tree->SetBranchAddress("AbsoluteGain", &AbsoluteGain);
+  //
+  tree->SetBranchAddress("LEDRefAmp", LEDRefAmp);
+  tree->SetBranchAddress("LEDRefAmpRMS", LEDRefAmpRMS);
+  tree->SetBranchAddress("LEDRefHighLowRatio", LEDRefHighLowRatio);
+  tree->SetBranchAddress("LEDRefHighLow", LEDRefHighLow);
+  tree->SetBranchAddress("Temperature", Temperature);
+  tree->SetBranchAddress("TemperatureRMS", TemperatureRMS);
+  //
+  tree->SetBranchAddress("RelativeGain", RelativeGain);
+  tree->SetBranchAddress("HighLowRatio", HighLowRatio);
+  tree->SetBranchAddress("HighLow", HighLow);
+  tree->SetBranchAddress("LEDAmp", LEDAmp);
+  tree->SetBranchAddress("LEDAmpRMS", LEDAmpRMS);
+
+  // indices for looping over the towers
+  Int_t iCol = 0;
+  Int_t iRow = 0;
+
+  for (int ient=0; ient<tree->GetEntries(); ient++) {
+    tree->GetEntry(ient);
+
+    // assume the index SuperModules come in order: i=iSM
+    AliEMCALSuperModuleCalibAbs &t = fSuperModuleData[iSM];
+    t.fSuperModuleNum = iSM;
+    // first, overall values
+    t.fCalibMethod = CalibMethod;
+    t.fCalibPass = CalibPass;
+    t.fCalibTime = CalibTime;
+    t.fAbsoluteGain = 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];
+    }
+    for (Int_t j=0; j<AliEMCALGeoParams::fgkEMCALTempSensors; j++) {
+      t.fTemperature[j] = Temperature[j];
+      t.fTemperatureRMS[j] = TemperatureRMS[j];
+    }
+
+    // third: info for each tower
+    for (Int_t j=0; j<nAPDPerSM; j++) {
+      iCol = j / AliEMCALGeoParams::fgkEMCALRows;
+      iRow = j % AliEMCALGeoParams::fgkEMCALRows;
+
+      // help variables: possibly modified or swapped indices
+      int iColMod = iCol;
+      int iRowMod = iRow;
+      // assume that this info is already swapped and done for this basis?
+      if (swapSides) {
+       // C side, oriented differently than A side: swap is requested
+       iColMod = AliEMCALGeoParams::fgkEMCALCols-1 - iCol;
+       iRowMod = AliEMCALGeoParams::fgkEMCALRows-1 - iRow;
+      }
+
+      AliEMCALCalibAbsVal &v = t.fAPDVal[iColMod][iRowMod];
+
+      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];
+    }
+
+  } // loop over entries
+
+  return;
+}
+
+//____________________________________________________________________________
+void AliEMCALCalibAbs::WriteRootCalibAbsInfo(const TString &rootFileName,
+                                            Bool_t swapSides)
+{
+  // write data to root file. ; coordinates given on SuperModule basis
+  TFile destFile(rootFileName, "recreate");  
+  if (destFile.IsZombie()) {
+    return;
+  }  
+  destFile.cd();
+
+  TTree *tree = new TTree("tree","");
+
+  // variables for filling the TTree
+  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; 
+  Int_t CalibTime = 0; 
+  Float_t AbsoluteGain = 0; 
+  // second: additional info for LED Reference and SM temperature
+  Float_t LEDRefAmp[AliEMCALGeoParams::fgkEMCALLEDRefs] = {0};
+  Float_t LEDRefAmpRMS[AliEMCALGeoParams::fgkEMCALLEDRefs]= {0};
+  Float_t LEDRefHighLowRatio[AliEMCALGeoParams::fgkEMCALLEDRefs]= {0};
+  Int_t LEDRefHighLow[AliEMCALGeoParams::fgkEMCALLEDRefs]= {0};
+  Float_t Temperature[AliEMCALGeoParams::fgkEMCALTempSensors]= {0};
+  Float_t TemperatureRMS[AliEMCALGeoParams::fgkEMCALTempSensors]= {0};
+  // third: info for each tower
+  Float_t RelativeGain[AliEMCALGeoParams::fgkEMCALCols][AliEMCALGeoParams::fgkEMCALRows]= {0}; 
+  Float_t HighLowRatio[AliEMCALGeoParams::fgkEMCALCols][AliEMCALGeoParams::fgkEMCALRows]= {0}; 
+  Int_t HighLow[AliEMCALGeoParams::fgkEMCALCols][AliEMCALGeoParams::fgkEMCALRows]= {0}; 
+  Float_t LEDAmp[AliEMCALGeoParams::fgkEMCALCols][AliEMCALGeoParams::fgkEMCALRows]= {0}; 
+  Float_t LEDAmpRMS[AliEMCALGeoParams::fgkEMCALCols][AliEMCALGeoParams::fgkEMCALRows]= {0}; 
+  // 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(LEDRefHighLowRatio, 0, sizeof(LEDRefHighLowRatio)); 
+  memset(LEDRefHighLow, 0, sizeof(LEDRefHighLow)); 
+  memset(Temperature, 0, sizeof(Temperature)); 
+  memset(TemperatureRMS, 0, sizeof(TemperatureRMS)); 
+  memset(RelativeGain, 0, sizeof(RelativeGain)); 
+  memset(HighLowRatio, 0, sizeof(HighLowRatio)); 
+  memset(HighLow, 0, sizeof(HighLow)); 
+  memset(LEDAmp, 0, sizeof(LEDAmp)); 
+  memset(LEDAmpRMS, 0, sizeof(LEDAmpRMS)); 
+
+  Int_t nAPDPerSM = AliEMCALGeoParams::fgkEMCALCols * AliEMCALGeoParams::fgkEMCALRows;
+  // for looping over towers
+  Int_t iCol = 0;
+  Int_t iRow = 0;
+
+  // declare the branches
+  // first
+  tree->Branch("iSM", &iSM, "iSM/I");
+  tree->Branch("CalibMethod", &CalibMethod, "CalibMethod/I");
+  tree->Branch("CalibPass", &CalibPass, "CalibPass/I");
+  tree->Branch("CalibTime", &CalibTime, "CalibTime/I");
+  tree->Branch("AbsoluteGain", &AbsoluteGain, "AbsoluteGain/F");
+  // second  
+  tree->Branch( "LEDRefAmp", &LEDRefAmp, Form("LEDRefAmp[%d]/F", AliEMCALGeoParams::fgkEMCALLEDRefs) );
+  tree->Branch( "LEDRefAmpRMS", &LEDRefAmpRMS, Form("LEDRefAmpRMS[%d]/F", AliEMCALGeoParams::fgkEMCALLEDRefs) );
+  tree->Branch( "LEDRefHighLowRatio", &LEDRefHighLowRatio, Form("LEDRefHighLowRatio[%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) );
+  // third: info for each tower; see if a 2D array works OK or if we'll have to use 1D arrays instead 
+  tree->Branch( "RelativeGain", &RelativeGain, Form("RelativeGain[%d][%d]/F", AliEMCALGeoParams::fgkEMCALCols, AliEMCALGeoParams::fgkEMCALRows) );
+  tree->Branch( "HighLowRatio", &HighLowRatio, Form("HighLowRatio[%d][%d]/F", AliEMCALGeoParams::fgkEMCALCols, AliEMCALGeoParams::fgkEMCALRows) );
+  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) );
+
+  for (iSM = 0; iSM < fNSuperModule; iSM++) {
+    AliEMCALSuperModuleCalibAbs &t = fSuperModuleData[iSM];
+
+    iSM = t.fSuperModuleNum;
+    // first, overall values
+    CalibMethod = t.fCalibMethod;
+    CalibPass = t.fCalibPass;
+    CalibTime = t.fCalibTime;
+    AbsoluteGain = t.fAbsoluteGain;
+
+    // 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];
+    }
+    for (Int_t j=0; j<AliEMCALGeoParams::fgkEMCALTempSensors; j++) {
+      Temperature[j] = t.fTemperature[j];
+      TemperatureRMS[j] = t.fTemperatureRMS[j];
+    }
+
+    // third: info for each tower
+    for (Int_t j=0; j<nAPDPerSM; j++) {
+      iCol = j / AliEMCALGeoParams::fgkEMCALRows;
+      iRow = j % AliEMCALGeoParams::fgkEMCALRows;
+
+      // help variables: possibly modified or swapped indices
+      int iColMod = iCol;
+      int iRowMod = iRow;
+      // assume that this info is already swapped and done for this basis?
+      if (swapSides) {
+       // C side, oriented differently than A side: swap is requested
+       iColMod = AliEMCALGeoParams::fgkEMCALCols-1 - iCol;
+       iRowMod = AliEMCALGeoParams::fgkEMCALRows-1 - iRow;
+      }
+
+      AliEMCALCalibAbsVal &v = t.fAPDVal[iColMod][iRowMod];
+
+      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;
+    }
+
+    tree->Fill();
+  } // i, SuperModule
+
+  tree->Write();
+  destFile.Close();
+
+  return;
+}
+
+//____________________________________________________________________________
 AliEMCALCalibAbs::~AliEMCALCalibAbs()
 {
   delete [] fSuperModuleData;
 }
 
 //____________________________________________________________________________
-AliEMCALCalibAbs::AliEMCALSuperModuleCalibAbs AliEMCALCalibAbs::GetSuperModuleCalibAbsId(Int_t supModIndex)const
+AliEMCALSuperModuleCalibAbs AliEMCALCalibAbs::GetSuperModuleCalibAbsId(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)
@@ -217,7 +489,7 @@ AliEMCALCalibAbs::AliEMCALSuperModuleCalibAbs AliEMCALCalibAbs::GetSuperModuleCa
 }
 
 //____________________________________________________________________________
-AliEMCALCalibAbs::AliEMCALSuperModuleCalibAbs AliEMCALCalibAbs::GetSuperModuleCalibAbsNum(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)
index 7ec3ad3..67bb35f 100644 (file)
 #include <TObject.h>
 #include "AliEMCALGeoParams.h"
 class TString;
+class TTree;
 
 /*
   Objects of this class contain basis for absolute calibrations
-  AliEMCALCalibAbs inherits TObject only to use AliLog "functions".
 */
 
+// total calibration factor is a product of
+// a) overall calibration factor [fAbsoluteGain]
+// b) individual gain factor per tower [fRelativeGain]
+// c) time-dependent correction
+// In this class we store a), b) and the needed static ingredients for c)
+
+// ******* internal class definition *************
+// values per single tower
+class AliEMCALCalibAbsVal : public TObject {
+
+ public:
+  AliEMCALCalibAbsVal() : TObject(), // just init values
+    fRelativeGain(0),
+    fHighLowRatio(0),
+    fHighLow(0),
+    fLEDAmp(0),
+    fLEDAmpRMS(0)
+    {
+    }
+  
+  void Init() {
+    fRelativeGain = 0;
+    fHighLowRatio = 0;
+    fHighLow = 0;
+    fLEDAmp = 0;
+    fLEDAmpRMS = 0;
+    return;
+  }
+
+ public:
+  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
+};
+
+// 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),
+    fCalibMethod(0),
+    fCalibPass(0),
+    fCalibTime(0),
+    fAbsoluteGain(0)
+    {
+      for (int iref=0; iref<AliEMCALGeoParams::fgkEMCALLEDRefs; iref++) {
+       fLEDRefAmp[iref] = 0;
+       fLEDRefAmpRMS[iref] = 0;
+       fLEDRefHighLowRatio[iref] = 0;
+       fLEDRefHighLow[iref] = 0;
+      }
+
+      for (int itemp=0; itemp<AliEMCALGeoParams::fgkEMCALTempSensors; itemp++) {
+       fTemperature[itemp] = 0;
+       fTemperatureRMS[itemp] = 0;
+      }
+
+      for (int icol=0; icol<AliEMCALGeoParams::fgkEMCALCols; icol++) {
+       for (int irow=0; irow<AliEMCALGeoParams::fgkEMCALRows; irow++) {
+         fAPDVal[icol][irow].Init();
+       }
+      }
+    }
+
+ public:
+  // 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,
+  Int_t fCalibPass; // which analysis iteration is this.. 1,2,..N
+  Int_t fCalibTime; // t0, unix timestamp
+  Float_t fAbsoluteGain; // (ADC>GeV absolute gain/conversion)
+  
+  // second: additional info for LED Reference and SM temperature
+  Float_t fLEDRefAmp[AliEMCALGeoParams::fgkEMCALLEDRefs]; // LED amplitude at  t0, low gain equivalent
+  Float_t fLEDRefAmpRMS[AliEMCALGeoParams::fgkEMCALLEDRefs]; // RMS
+  Float_t fLEDRefHighLowRatio[AliEMCALGeoParams::fgkEMCALLEDRefs]; // value around 16 or so
+  Int_t fLEDRefHighLow[AliEMCALGeoParams::fgkEMCALLEDRefs]; // 0 (low) or 1 (high) gain
+  
+  Float_t fTemperature[AliEMCALGeoParams::fgkEMCALTempSensors]; // temperature at t0
+  Float_t fTemperatureRMS[AliEMCALGeoParams::fgkEMCALTempSensors]; // RMS
+  
+  // third: individual info for each tower
+  AliEMCALCalibAbsVal fAPDVal[AliEMCALGeoParams::fgkEMCALCols][AliEMCALGeoParams::fgkEMCALRows]; // at t0
+
+  ClassDef(AliEMCALSuperModuleCalibAbs, 1) // help class
+};
+// ******* end of internal class definition *************
+
 class AliEMCALCalibAbs : public TObject {
 
 public:
@@ -24,52 +117,16 @@ public:
   AliEMCALCalibAbs();
 
   // Read and Write txt I/O methods are normally not used, but are useful for 
-  // debug purposes
-  void ReadCalibAbsInfo(Int_t nSM, const TString &txtFileName, Bool_t swapSides=kFALSE); // info file is for nSm=1 to 12 SuperModules
-
-  void WriteCalibAbsInfo(const TString &txtFileName, Bool_t swapSides=kFALSE); // info file is for nSm=1 to 12 SuperModules
+  // filling the object before it is saved in OCDB 
+  void ReadTextCalibAbsInfo(Int_t nSM, const TString &txtFileName, Bool_t swapSides=kFALSE); // info file is for nSm=1 to 12 SuperModules
+  void WriteTextCalibAbsInfo(const TString &txtFileName, Bool_t swapSides=kFALSE); // info file is for nSm=1 to 12 SuperModules
+  void ReadRootCalibAbsInfo(const TString &rootFileName, Bool_t swapSides=kFALSE); // info file is for nSm=1 to 12 SuperModules
+  void ReadTreeCalibAbsInfo(TTree *tree, Bool_t swapSides=kFALSE); // info file is for nSm=1 to 12 SuperModules
+  void WriteRootCalibAbsInfo(const TString &rootFileName, Bool_t swapSides=kFALSE); // info file is for nSm=1 to 12 SuperModules
 
   virtual ~AliEMCALCalibAbs();
 
-  // total calibration factor is a product of
-  // a) overall calibration factor [fAbsoluteGain]
-  // b) individual gain factor per tower [fRelativeGain]
-  // c) time-dependent correction
-  // In this class we store a), b) and the needed static ingredients for c)
-
-  // values per single tower
-  struct AliEMCALCalibAbsVal {
-    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
-  };
-
-  // 1 SuperModule's worth of info: info on where the different APDs are
-  struct AliEMCALSuperModuleCalibAbs {
-    // 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,
-    Int_t fCalibPass; // which analysis iteration is this.. 1,2,..N
-    Int_t fCalibTime; // t0, unix timestamp
-    Float_t fAbsoluteGain; // (ADC>GeV absolute gain/conversion)
-
-    // second: additional info for LED Reference and SM temperature
-    Float_t fLEDRefAmp[AliEMCALGeoParams::fgkEMCALLEDRefs]; // LED amplitude at  t0, low gain equivalent
-    Float_t fLEDRefAmpRMS[AliEMCALGeoParams::fgkEMCALLEDRefs]; // RMS
-    Float_t fLEDRefHighLowRatio[AliEMCALGeoParams::fgkEMCALLEDRefs]; // value around 16 or so
-    Int_t fLEDRefHighLow[AliEMCALGeoParams::fgkEMCALLEDRefs]; // 0 (low) or 1 (high) gain
-
-    Float_t fTemperature[AliEMCALGeoParams::fgkEMCALTempSensors]; // temperature at t0
-    Float_t fTemperatureRMS[AliEMCALGeoParams::fgkEMCALTempSensors]; // RMS
-
-    // third: individual info for each tower
-    AliEMCALCalibAbsVal fAPDVal[AliEMCALGeoParams::fgkEMCALCols][AliEMCALGeoParams::fgkEMCALRows]; // at t0
-  };
-
   // pointer to stored info.
-
   Int_t GetNSuperModule() const { return fNSuperModule; }; 
   AliEMCALSuperModuleCalibAbs * GetSuperModuleData() const { return fSuperModuleData; };
 
@@ -88,7 +145,7 @@ private:
   AliEMCALCalibAbs(const AliEMCALCalibAbs &);
   AliEMCALCalibAbs &operator = (const AliEMCALCalibAbs &);
 
-  ClassDef(AliEMCALCalibAbs, 1) //CalibAbs data reader
+  ClassDef(AliEMCALCalibAbs, 2) //CalibAbs data reader
 };
 
 #endif
index 8f8573e..8b89940 100644 (file)
@@ -20,6 +20,8 @@
 
 #include <fstream>
 #include <TString.h>
+#include <TFile.h>
+#include <TTree.h>
 
 #include "AliEMCALCalibMapAPD.h"
 
@@ -36,8 +38,8 @@ AliEMCALCalibMapAPD::AliEMCALCalibMapAPD() :
 }
 
 //____________________________________________________________________________
-void AliEMCALCalibMapAPD::ReadCalibMapAPDInfo(Int_t nSM, const TString &txtFileName,
-                                     Bool_t swapSides)
+void AliEMCALCalibMapAPD::ReadTextCalibMapAPDInfo(Int_t nSM, const TString &txtFileName,
+                                                 Bool_t swapSides)
 {
   //Read data from txt file. ; coordinates given on SuperModule basis
 
@@ -112,8 +114,8 @@ void AliEMCALCalibMapAPD::ReadCalibMapAPDInfo(Int_t nSM, const TString &txtFileN
 }
 
 //____________________________________________________________________________
-void AliEMCALCalibMapAPD::WriteCalibMapAPDInfo(const TString &txtFileName,
-                                      Bool_t swapSides)
+void AliEMCALCalibMapAPD::WriteTextCalibMapAPDInfo(const TString &txtFileName,
+                                                  Bool_t swapSides)
 {
   // write data to txt file. ; coordinates given on SuperModule basis
 
@@ -159,13 +161,173 @@ void AliEMCALCalibMapAPD::WriteCalibMapAPDInfo(const TString &txtFileName,
 }
 
 //____________________________________________________________________________
+void AliEMCALCalibMapAPD::ReadRootCalibMapAPDInfo(const TString &rootFileName,
+                                                 Bool_t swapSides)
+{
+  //Read data from root file. ; coordinates given on SuperModule basis
+  TFile inputFile(rootFileName, "read");  
+
+  TTree *tree = (TTree*) inputFile.Get("tree");
+
+  ReadTreeCalibMapAPDInfo(tree, swapSides);
+
+  inputFile.Close();
+
+  return;
+}
+
+//____________________________________________________________________________
+void AliEMCALCalibMapAPD::ReadTreeCalibMapAPDInfo(TTree *tree,
+                                                 Bool_t swapSides)
+{
+  // how many SuperModule's worth of entries / APDs do we have?
+  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;
+  // 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; 
+  // end - all values
+
+  // declare the branches
+  tree->SetBranchAddress("iSM", &iSM);
+  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);
+
+  for (int ient=0; ient<tree->GetEntries(); ient++) {
+    tree->GetEntry(ient);
+
+    // assume the index SuperModules come in order: i=iSM
+    AliEMCALSuperModuleCalibMapAPD &t = fSuperModuleData[iSM];
+    t.fSuperModuleNum = iSM;
+
+    // assume that this info is already swapped and done for this basis?
+    if (swapSides) {
+      // C side, oriented differently than A side: swap is requested
+      iCol = AliEMCALGeoParams::fgkEMCALCols-1 - iCol;
+      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;
+
+  } // 
+
+  return;
+}
+
+//____________________________________________________________________________
+void AliEMCALCalibMapAPD::WriteRootCalibMapAPDInfo(const TString &rootFileName,
+                                      Bool_t swapSides)
+{
+  // write data to root file. ; coordinates given on SuperModule basis
+  TFile destFile(rootFileName, "recreate");  
+  if (destFile.IsZombie()) {
+    return;
+  }  
+  destFile.cd();
+
+  TTree *tree = new TTree("tree","");
+
+  // 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 iCol = 0;
+  Int_t iRow = 0;
+  // declare the branches
+  tree->Branch("iSM", &iSM, "iSM/I");
+  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");
+
+  Int_t nAPDPerSM = AliEMCALGeoParams::fgkEMCALCols * AliEMCALGeoParams::fgkEMCALRows;
+
+  for (iSM = 0; iSM < fNSuperModule; iSM++) {
+    AliEMCALSuperModuleCalibMapAPD &t = fSuperModuleData[iSM];
+
+    for (Int_t j=0; j<nAPDPerSM; j++) {
+      iCol = j / AliEMCALGeoParams::fgkEMCALRows;
+      iRow = j % AliEMCALGeoParams::fgkEMCALRows;
+
+      AliEMCALCalibMapAPDVal &v = t.fAPDVal[iCol][iRow];
+
+      if (swapSides) {
+       // C side, oriented differently than A side: swap is requested
+       iCol = AliEMCALGeoParams::fgkEMCALCols-1 - iCol;
+       iRow = AliEMCALGeoParams::fgkEMCALRows-1 - iRow;
+      }
+
+      iHW = v.fHardWareId; 
+      APDNum = v.fAPDNum;
+      V30 = v.fV30;
+      for (int k=0; k<3; k++) {
+       Par[k] = v.fPar[k];
+       ParErr[k] = v.fParErr[k];
+      } 
+      BreakDown = v.fBreakDown;
+      DarkCurrent = v.fDarkCurrent;
+
+      tree->Fill();
+    }
+
+  } // i, SuperModule
+
+  tree->Write();
+  destFile.Close();
+
+  return;
+}
+
+//____________________________________________________________________________
 AliEMCALCalibMapAPD::~AliEMCALCalibMapAPD()
 {
   delete [] fSuperModuleData;
 }
 
 //____________________________________________________________________________
-AliEMCALCalibMapAPD::AliEMCALSuperModuleCalibMapAPD AliEMCALCalibMapAPD::GetSuperModuleCalibMapAPDId(Int_t supModIndex)const
+AliEMCALSuperModuleCalibMapAPD AliEMCALCalibMapAPD::GetSuperModuleCalibMapAPDId(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)
@@ -175,7 +337,7 @@ AliEMCALCalibMapAPD::AliEMCALSuperModuleCalibMapAPD AliEMCALCalibMapAPD::GetSupe
 }
 
 //____________________________________________________________________________
-AliEMCALCalibMapAPD::AliEMCALSuperModuleCalibMapAPD AliEMCALCalibMapAPD::GetSuperModuleCalibMapAPDNum(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)
index c473034..bd74e2b 100644 (file)
 #include "AliEMCALGeoParams.h"
 #include <cmath>
 class TString;
+class TTree;
 
 /*
-  Objects of this class read txt file with APD data
-  AliEMCALCalibMapAPD inherits TObject only to use AliLog "functions".
+  Objects of this class contain info on APD calibration and map info
 */
 
+// ******* internal class definition *************
+// values per single APD
+class AliEMCALCalibMapAPDVal : public TObject {
+
+ public:
+  AliEMCALCalibMapAPDVal() : TObject(), // just init values
+    fHardWareId(0),
+    fAPDNum(0),
+    fV30(0),
+    fBreakDown(0),
+    fDarkCurrent(0) 
+    {
+      Init();
+    }
+  
+  void Init() {
+    fHardWareId = 0;
+    fAPDNum = 0;
+    fV30 = 0;
+    fBreakDown = 0;
+    fDarkCurrent = 0; 
+    for (int i=0; i<3; i++) {
+      fPar[i] = 0;
+      fParErr[i] = 0;
+    }
+    return;
+  }
+  
+ public:
+  Int_t fHardWareId; // HardWareIndex
+  // info from APD calibrations
+  Int_t fAPDNum;    // assigned APD-PA number; Catania 10000-, Houston: 20000-
+  Float_t fV30;      // Catania/Houston Voltage V30 (V) at T = 25 deg C
+  Float_t fPar[3];   // fit parameters, p0,p1,p2 - for ADC vs bias measurement
+  Float_t fParErr[3]; // error on fit parameters       
+  
+  Int_t fBreakDown; // Hamamatsu Breakdown Voltage (V) 
+  Float_t fDarkCurrent; // Hamamatsu Dark Current (A)  
+  
+  ClassDef(AliEMCALCalibMapAPDVal, 1) // 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)
+    {
+      for (int icol=0; icol<AliEMCALGeoParams::fgkEMCALCols; icol++) {
+       for (int irow=0; irow<AliEMCALGeoParams::fgkEMCALRows; irow++) {
+         fAPDVal[icol][irow].Init();
+       }
+      }
+    }
+  
+ public:
+  Int_t fSuperModuleNum;
+  AliEMCALCalibMapAPDVal fAPDVal[AliEMCALGeoParams::fgkEMCALCols][AliEMCALGeoParams::fgkEMCALRows];
+  
+  ClassDef(AliEMCALSuperModuleCalibMapAPD, 1) // help class
+};
+// ******* end of internal class definition *************    
+    
 class AliEMCALCalibMapAPD : public TObject {
 
 public:
@@ -26,34 +90,15 @@ public:
 
   // 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 ReadCalibMapAPDInfo(Int_t nSM, const TString &txtFileName, Bool_t swapSides=kFALSE); // info file is for nSm=1 to 12 SuperModules
-
-  void WriteCalibMapAPDInfo(const TString &txtFileName, Bool_t swapSides=kFALSE); // info file is for nSm=1 to 12 SuperModules
+  void ReadTextCalibMapAPDInfo(Int_t nSM, const TString &txtFileName, Bool_t swapSides=kFALSE); // info file is for nSm=1 to 12 SuperModules
+  void WriteTextCalibMapAPDInfo(const TString &txtFileName, Bool_t swapSides=kFALSE); // info file is for nSm=1 to 12 SuperModules
+  void ReadRootCalibMapAPDInfo(const TString &rootFileName, Bool_t swapSides=kFALSE); // info file is for nSm=1 to 12 SuperModules
+  void ReadTreeCalibMapAPDInfo(TTree *tree, Bool_t swapSides=kFALSE); // info file is for nSm=1 to 12 SuperModules
+  void WriteRootCalibMapAPDInfo(const TString &rootFileName, Bool_t swapSides=kFALSE); // info file is for nSm=1 to 12 SuperModules
 
   virtual ~AliEMCALCalibMapAPD();
 
-  // values per single APD
-  struct AliEMCALCalibMapAPDVal {
-
-    Int_t fHardWareId; // HardWareIndex
-    // info from APD calibrations
-    Int_t fAPDNum;    // assigned APD-PA number; Catania 10000-, Houston: 20000-
-    Float_t fV30;      // Catania/Houston Voltage V30 (V) at T = 25 deg C
-    Float_t fPar[3];   // fit parameters, p0,p1,p2 - for ADC vs bias measurement
-    Float_t fParErr[3]; // error on fit parameters     
-
-    Int_t fBreakDown; // Hamamatsu Breakdown Voltage (V)       
-    Float_t fDarkCurrent; // Hamamatsu Dark Current (A)        
-  };
-
-  // 1 SuperModule's worth of info: info on where the different APDs are
-  struct AliEMCALSuperModuleCalibMapAPD {
-    Int_t fSuperModuleNum;
-    AliEMCALCalibMapAPDVal fAPDVal[AliEMCALGeoParams::fgkEMCALCols][AliEMCALGeoParams::fgkEMCALRows];
-  };
-
   // pointer to stored info.
-
   Int_t GetNSuperModule() const { return fNSuperModule; }; 
   AliEMCALSuperModuleCalibMapAPD * GetSuperModuleData() const { return fSuperModuleData; };
 
@@ -78,7 +123,7 @@ private:
   AliEMCALCalibMapAPD(const AliEMCALCalibMapAPD &);
   AliEMCALCalibMapAPD &operator = (const AliEMCALCalibMapAPD &);
 
-  ClassDef(AliEMCALCalibMapAPD, 1) //MapAPD data reader
+  ClassDef(AliEMCALCalibMapAPD, 2) //CalibMapAPD data info
 };
 
 #endif
index 3389596..8cc58db 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 = (AliEMCALBiasAPD *) entry->GetObject();
+    fBiasAPD->ReadTreeBiasAPDInfo( (TTree *) entry->GetObject() );
   }
 
   if (fBiasAPD) { 
@@ -459,8 +459,9 @@ void AliEMCALCalibTimeDep::GetCalibMapAPDInfo()
 {
   // pick up Preprocessor output, based on fRun (most recent version)
   AliCDBEntry* entry = AliCDBManager::Instance()->Get("EMCAL/Calib/MapAPD", fRun);
+  // stored object should be a TTree; read the info
   if (entry) {
-    fCalibMapAPD = (AliEMCALCalibMapAPD *) entry->GetObject();
+    fCalibMapAPD->ReadTreeCalibMapAPDInfo( (TTree *) entry->GetObject() );
   }
 
   if (fCalibMapAPD) { 
@@ -479,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 = (AliEMCALCalibAbs *) entry->GetObject();
+    fCalibAbs->ReadTreeCalibAbsInfo( (TTree *) entry->GetObject() );
   }
 
   if (fCalibAbs) { 
@@ -503,8 +504,8 @@ 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
-  AliEMCALCalibAbs::AliEMCALSuperModuleCalibAbs * CalibAbsData = fCalibAbs->GetSuperModuleData();
-  AliEMCALCalibTimeDepCorrection::AliEMCALSuperModuleCalibTimeDepCorrection * CalibTimeDepCorrectionData = fCalibTimeDepCorrection->GetSuperModuleData();
+  AliEMCALSuperModuleCalibAbs * CalibAbsData = fCalibAbs->GetSuperModuleData();
+  AliEMCALSuperModuleCalibTimeDepCorrection * CalibTimeDepCorrectionData = fCalibTimeDepCorrection->GetSuperModuleData();
 
   for (int i = 0; i < nSM; i++) {
     int iSMAbs = CalibAbsData[i].fSuperModuleNum;
@@ -660,7 +661,7 @@ Int_t AliEMCALCalibTimeDep::CalcLEDCorrection(Int_t nSM, Int_t nBins)
       for (iRow = 0; iRow < AliEMCALGeoParams::fgkEMCALRows; iRow++) {
 
        // Calc. R(t0):
-       AliEMCALCalibAbs::AliEMCALCalibAbsVal &v = CalibAbsData[i].fAPDVal[iCol][iRow];
+       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 
 
@@ -722,7 +723,7 @@ 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
 
-  AliEMCALCalibTimeDepCorrection::AliEMCALSuperModuleCalibTimeDepCorrection * CalibTimeDepCorrectionData = fCalibTimeDepCorrection->GetSuperModuleData();
+  AliEMCALSuperModuleCalibTimeDepCorrection * CalibTimeDepCorrectionData = fCalibTimeDepCorrection->GetSuperModuleData();
 
   // for calculating StripAverage info
   int nValidTower = 0;
@@ -793,11 +794,11 @@ Int_t AliEMCALCalibTimeDep::CalcTemperatureCorrection(Int_t nSM, Int_t nBins)
   Int_t nRemaining = 0;
 
   // info containers
-  AliEMCALBiasAPD::AliEMCALSuperModuleBiasAPD * BiasAPDData = fBiasAPD->GetSuperModuleData();
-  AliEMCALCalibMapAPD::AliEMCALSuperModuleCalibMapAPD * CalibMapAPDData = fCalibMapAPD->GetSuperModuleData();
-  AliEMCALCalibAbs::AliEMCALSuperModuleCalibAbs * CalibAbsData = fCalibAbs->GetSuperModuleData();
+  AliEMCALSuperModuleBiasAPD * BiasAPDData = fBiasAPD->GetSuperModuleData();
+  AliEMCALSuperModuleCalibMapAPD * CalibMapAPDData = fCalibMapAPD->GetSuperModuleData();
+  AliEMCALSuperModuleCalibAbs * CalibAbsData = fCalibAbs->GetSuperModuleData();
   // correction container
-  AliEMCALCalibTimeDepCorrection::AliEMCALSuperModuleCalibTimeDepCorrection * CalibTimeDepCorrectionData = fCalibTimeDepCorrection->GetSuperModuleData();
+  AliEMCALSuperModuleCalibTimeDepCorrection * CalibTimeDepCorrectionData = fCalibTimeDepCorrection->GetSuperModuleData();
 
   int iSM = 0;
   int iCol = 0;
@@ -815,7 +816,7 @@ Int_t AliEMCALCalibTimeDep::CalcTemperatureCorrection(Int_t nSM, Int_t nBins)
     // 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++) {
-       AliEMCALCalibMapAPD::AliEMCALCalibMapAPDVal &mapAPD = CalibMapAPDData[i].fAPDVal[iCol][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);
index 6178d29..8b6c1e1 100644 (file)
 
 /* $Id: $ */
 
-// Objects of this class contain info on APD bias settings/voltages
+// Objects of this class contain info on time-dependent corrections
 //
 
 #include <fstream>
 #include <TString.h>
 #include <TArrayF.h>
+#include <TFile.h>
+#include <TTree.h>
 
 #include "AliEMCALCalibTimeDepCorrection.h"
 
@@ -40,7 +42,7 @@ AliEMCALCalibTimeDepCorrection::AliEMCALCalibTimeDepCorrection() :
 }
 
 //____________________________________________________________________________
-void AliEMCALCalibTimeDepCorrection::InitCorrection(Int_t nSM, Int_t nBins, Float_t val)
+void AliEMCALCalibTimeDepCorrection::InitCorrection(Int_t nSM, Int_t nBins, Float_t val=1.0)
 {
   // This methods assumes that you are using SuperModules 0..nSM-1
   fNSuperModule = nSM;
@@ -88,14 +90,14 @@ Float_t AliEMCALCalibTimeDepCorrection::GetCorrection(Int_t supModIndex, Int_t i
 }
 
 //____________________________________________________________________________
-void AliEMCALCalibTimeDepCorrection::ReadCalibTimeDepCorrectionInfo(Int_t nSM, const TString &txtFileName,
-                                                                   Bool_t swapSides)
+void AliEMCALCalibTimeDepCorrection::ReadTextInfo(Int_t nSM, const TString &txtFileName,
+                                                 Bool_t swapSides)
 {
   //Read data from txt file. ; coordinates given on SuperModule basis
 
   std::ifstream inputFile(txtFileName.Data());
   if (!inputFile) {
-    printf("AliEMCALCalibTimeDepCorrection::ReadCalibTimeDepCorrectionInfo - Cannot open the APD info file %s\n", txtFileName.Data());
+    printf("AliEMCALCalibTimeDepCorrection::ReadTextInfo - Cannot open the APD info file %s\n", txtFileName.Data());
     return;
   }
 
@@ -111,10 +113,13 @@ void AliEMCALCalibTimeDepCorrection::ReadCalibTimeDepCorrectionInfo(Int_t nSM, c
 
   Int_t nAPDPerSM = AliEMCALGeoParams::fgkEMCALCols * AliEMCALGeoParams::fgkEMCALRows;
 
+  // read header info 
+  inputFile >> fStartTime >> fNTimeBins >> fTimeBinSize;
+
   for (Int_t i = 0; i < fNSuperModule; i++) {
     AliEMCALSuperModuleCalibTimeDepCorrection &t = fSuperModuleData[i];
     if (!inputFile) {
-      printf("AliEMCALCalibTimeDepCorrection::ReadCalibTimeDepCorrectionInfo - Error while reading input file; likely EOF..");
+      printf("AliEMCALCalibTimeDepCorrection::ReadTextInfo - Error while reading input file; likely EOF..");
       return;
     }
     inputFile >> iSM;
@@ -147,14 +152,14 @@ void AliEMCALCalibTimeDepCorrection::ReadCalibTimeDepCorrectionInfo(Int_t nSM, c
 }
 
 //____________________________________________________________________________
-void AliEMCALCalibTimeDepCorrection::WriteCalibTimeDepCorrectionInfo(const TString &txtFileName,
-                                                                    Bool_t swapSides)
+void AliEMCALCalibTimeDepCorrection::WriteTextInfo(const TString &txtFileName,
+                                                  Bool_t swapSides)
 {
   // write data to txt file. ; coordinates given on SuperModule basis
 
   std::ofstream outputFile(txtFileName.Data());
   if (!outputFile) {
-    printf("AliEMCALCalibTimeDepCorrection::WriteCalibTimeDepCorrectionInfo - Cannot open the APD output file %s\n", txtFileName.Data());
+    printf("AliEMCALCalibTimeDepCorrection::WriteTextInfo - Cannot open the APD output file %s\n", txtFileName.Data());
     return;
   }
 
@@ -164,6 +169,9 @@ void AliEMCALCalibTimeDepCorrection::WriteCalibTimeDepCorrectionInfo(const TStri
 
   Int_t nAPDPerSM = AliEMCALGeoParams::fgkEMCALCols * AliEMCALGeoParams::fgkEMCALRows;
 
+  // write header info 
+  outputFile << fStartTime << " " << fNTimeBins << " " << fTimeBinSize << endl;
+
   for (Int_t i = 0; i < fNSuperModule; i++) {
     AliEMCALSuperModuleCalibTimeDepCorrection &t = fSuperModuleData[i];
     outputFile << t.fSuperModuleNum << endl;
@@ -196,13 +204,164 @@ void AliEMCALCalibTimeDepCorrection::WriteCalibTimeDepCorrectionInfo(const TStri
 }
 
 //____________________________________________________________________________
+void AliEMCALCalibTimeDepCorrection::ReadRootInfo(const TString &rootFileName,
+                                                 Bool_t swapSides)
+{
+  //Read data from root file. ; coordinates given on SuperModule basis
+  TFile inputFile(rootFileName, "read");  
+
+  TTree *treeGlob = (TTree*) inputFile.Get("treeGlob");
+  TTree *treeCorr = (TTree*) inputFile.Get("treeCorr");
+
+  ReadTreeInfo(treeGlob, treeCorr, swapSides);
+
+  inputFile.Close();
+
+  return;
+}
+
+//____________________________________________________________________________
+void AliEMCALCalibTimeDepCorrection::ReadTreeInfo(TTree *treeGlob, TTree *treeCorr,
+                                                 Bool_t swapSides)
+{
+ // how many SuperModule's worth of entries / APDs do we have?
+  Int_t nAPDPerSM = AliEMCALGeoParams::fgkEMCALCols * AliEMCALGeoParams::fgkEMCALRows;
+  fNSuperModule = treeCorr->GetEntries() / nAPDPerSM;
+
+  // global variables : only one entry
+  treeGlob->SetBranchAddress("fStartTime", &fStartTime);
+  treeGlob->SetBranchAddress("fNTimeBins", &fNTimeBins);
+  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;
+  // list of values to be read
+  Int_t nCorr = 0;
+  Float_t correction[fgkMaxTimeBins] = {0};
+  // make sure it's really initialized correctly
+  memset(correction, 0, sizeof(correction)); // better safe than sorry
+  // end - all values
+
+  // declare the branches
+  treeCorr->SetBranchAddress("iSM", &iSM);
+  treeCorr->SetBranchAddress("iCol", &iCol);
+  treeCorr->SetBranchAddress("iRow", &iRow);
+  treeCorr->SetBranchAddress("nCorr", &nCorr);
+  treeCorr->SetBranchAddress("correction", correction);
+
+  for (int ient=0; ient<treeCorr->GetEntries(); ient++) {
+    treeCorr->GetEntry(ient);
+
+    // assume the index SuperModules come in order: i=iSM
+    AliEMCALSuperModuleCalibTimeDepCorrection &t = fSuperModuleData[iSM];
+    t.fSuperModuleNum = iSM;
+
+    // assume that this info is already swapped and done for this basis?
+    if (swapSides) {
+      // C side, oriented differently than A side: swap is requested
+      iCol = AliEMCALGeoParams::fgkEMCALCols-1 - iCol;
+      iRow = AliEMCALGeoParams::fgkEMCALRows-1 - iRow;
+    }
+
+
+    // set size of TArray
+    t.fCorrection[iCol][iRow].Set(nCorr);
+    for (Int_t k=0; k<nCorr; k++) {
+      // add to TArray
+      t.fCorrection[iCol][iRow].AddAt(correction[k], k);
+    }
+
+  } // entry
+
+  return;
+}
+
+//____________________________________________________________________________
+void AliEMCALCalibTimeDepCorrection::WriteRootInfo(const TString &rootFileName,
+                                                  Bool_t swapSides)
+{
+  // write data to root file. ; coordinates given on SuperModule basis
+  TFile destFile(rootFileName, "recreate");  
+  if (destFile.IsZombie()) {
+    return;
+  }  
+  destFile.cd();
+
+  TTree *treeGlob = new TTree("treeGlob","");
+  TTree *treeCorr = new TTree("treeCorr","");
+
+  // global part only has one entry
+  treeGlob->Branch("fStartTime", &fStartTime, "fStartTime/I"); // really unsigned int..
+  treeGlob->Branch("fNTimeBins", &fNTimeBins, "fNTimeBins/I");
+  treeGlob->Branch("fTimeBinSize", &fTimeBinSize, "fTimeBinSize/I");
+  treeGlob->Fill();
+
+  // variables for filling the TTree
+  Int_t iSM = 0; // SuperModule index
+  Int_t iCol = 0;
+  Int_t iRow = 0;
+  Int_t nCorr = 0;
+  Float_t correction[fgkMaxTimeBins] = {0};
+  // make sure it's really initialized correctly
+  memset(correction, 0, sizeof(correction)); // better safe than sorry
+
+  // declare the branches
+  treeCorr->Branch("iSM", &iSM, "iSM/I");
+  treeCorr->Branch("iCol", &iCol, "iCol/I");
+  treeCorr->Branch("iRow", &iRow, "iRow/I");
+  treeCorr->Branch("nCorr", &nCorr, "nCorr/I");
+  treeCorr->Branch("correction", &correction, "correction[nCorr]/F");
+
+  Int_t nAPDPerSM = AliEMCALGeoParams::fgkEMCALCols * AliEMCALGeoParams::fgkEMCALRows;
+
+  for (iSM = 0; iSM < fNSuperModule; iSM++) {
+    AliEMCALSuperModuleCalibTimeDepCorrection &t = fSuperModuleData[iSM];
+
+    for (Int_t j=0; j<nAPDPerSM; j++) {
+      iCol = j / AliEMCALGeoParams::fgkEMCALRows;
+      iRow = j % AliEMCALGeoParams::fgkEMCALRows;
+
+      nCorr = t.fCorrection[iCol][iRow].GetSize();
+      if (nCorr > fgkMaxTimeBins) {
+       printf("AliEMCALCalibTimeDepCorrection::WriteRootInfo - too many correction/timebins %d kept\n", nCorr);
+       return;
+      }
+
+      if (swapSides) {
+       // C side, oriented differently than A side: swap is requested
+       iCol = AliEMCALGeoParams::fgkEMCALCols-1 - iCol;
+       iRow = AliEMCALGeoParams::fgkEMCALRows-1 - iRow;
+      }
+
+      for (Int_t k=0; k<nCorr; k++) {
+       correction[k] = t.fCorrection[iCol][iRow].At(k);
+      }
+
+      treeCorr->Fill();
+    }
+
+  } // i, SuperModule
+
+  treeGlob->Write();
+  treeCorr->Write();
+  destFile.Close();
+
+  return;
+}
+
+//____________________________________________________________________________
 AliEMCALCalibTimeDepCorrection::~AliEMCALCalibTimeDepCorrection()
 {
   delete [] fSuperModuleData;
 }
 
 //____________________________________________________________________________
-AliEMCALCalibTimeDepCorrection::AliEMCALSuperModuleCalibTimeDepCorrection AliEMCALCalibTimeDepCorrection::GetSuperModuleCalibTimeDepCorrectionId(Int_t supModIndex)const
+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)
@@ -212,7 +371,7 @@ AliEMCALCalibTimeDepCorrection::AliEMCALSuperModuleCalibTimeDepCorrection AliEMC
 }
 
 //____________________________________________________________________________
-AliEMCALCalibTimeDepCorrection::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)
index 7db1d86..83cf965 100644 (file)
 #include <TArrayF.h>
 #include "AliEMCALGeoParams.h"
 class TString;
-class TArrayF;
+class TTree;
 
 /*
-  Objects of this class read txt file with APD data
-  AliEMCALCalibTimeDepCorrection inherits TObject only to use AliLog "functions".
+  Objects of this class contain info on time-dependent corrections
 */
 
+// ******* internal class definition *************
+// 1 SuperModule's worth of info
+class AliEMCALSuperModuleCalibTimeDepCorrection : public TObject {
+ public:
+  AliEMCALSuperModuleCalibTimeDepCorrection() : TObject(), // just init values
+    fSuperModuleNum(0)
+    {
+      for (int icol=0; icol<AliEMCALGeoParams::fgkEMCALCols; icol++) {
+       for (int irow=0; irow<AliEMCALGeoParams::fgkEMCALRows; irow++) {
+         fCorrection[icol][irow].Reset();
+       }
+      }
+    }
+
+ public:
+  Int_t fSuperModuleNum;
+  TArrayF fCorrection[AliEMCALGeoParams::fgkEMCALCols][AliEMCALGeoParams::fgkEMCALRows]; 
+
+  ClassDef(AliEMCALSuperModuleCalibTimeDepCorrection, 1) // help class
+};
+// ******* end of internal class definition *************
+
 class AliEMCALCalibTimeDepCorrection : public TObject {
-public:
+ public:
   AliEMCALCalibTimeDepCorrection();
 
   // interface methods; getting the whole struct should be more efficient though
-  void InitCorrection(Int_t nSM, Int_t nBins, Float_t val=1.0); // assign a certain value to all 
+  void InitCorrection(Int_t nSM, Int_t nBins, Float_t val); // assign a certain value to all 
   // use the methods below with caution: take care that your argument ranges are valid
   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
@@ -30,17 +51,14 @@ public:
 
   // 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 ReadCalibTimeDepCorrectionInfo(Int_t nSM, const TString &txtFileName, Bool_t swapSides=kFALSE); // info file is for nSm=1 to 12 SuperModules
-
-  void WriteCalibTimeDepCorrectionInfo(const TString &txtFileName, Bool_t swapSides=kFALSE); // info file is for nSm=1 to 12 SuperModules
+  void ReadTextInfo(Int_t nSM, const TString &txtFileName, Bool_t swapSides=kFALSE); // info file is for nSm=1 to 12 SuperModules
+  void WriteTextInfo(const TString &txtFileName, Bool_t swapSides=kFALSE); // info file is for nSm=1 to 12 SuperModules
+  void ReadRootInfo(const TString &rootFileName, Bool_t swapSides=kFALSE); // info file is for nSm=1 to 12 SuperModules
+  void ReadTreeInfo(TTree *treeGlob, TTree *treeCorr, Bool_t swapSides=kFALSE); // info file is for nSm=1 to 12 SuperModules
+  void WriteRootInfo(const TString &rootFileName, Bool_t swapSides=kFALSE); // info file is for nSm=1 to 12 SuperModules
 
   virtual ~AliEMCALCalibTimeDepCorrection();
 
-  struct AliEMCALSuperModuleCalibTimeDepCorrection {
-    Int_t fSuperModuleNum;
-    TArrayF fCorrection[AliEMCALGeoParams::fgkEMCALCols][AliEMCALGeoParams::fgkEMCALRows]; 
-  };
-
   // pointer to stored info.
   Int_t GetNSuperModule() const { return fNSuperModule; }; 
   AliEMCALSuperModuleCalibTimeDepCorrection * GetSuperModuleData() const { return fSuperModuleData; };
@@ -58,6 +76,8 @@ public:
   Int_t GetNTimeBins() const { return fNTimeBins; } // 
   Int_t GetTimeBinSize() const { return fTimeBinSize; } // 
 
+  static Int_t GetMaxTimeBins() { return fgkMaxTimeBins; }
+
 protected:
 
   Int_t          fNSuperModule; // Number of supermodules.
@@ -72,6 +92,8 @@ private:
   Int_t fNTimeBins; // how many timestamp bins do we have
   Int_t fTimeBinSize; // seconds per time-bin
 
+  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) //
 };