Calibration objects for EMC and CPV
authorkharlov <kharlov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 13 Mar 2006 14:05:43 +0000 (14:05 +0000)
committerkharlov <kharlov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 13 Mar 2006 14:05:43 +0000 (14:05 +0000)
PHOS/AliPHOSCalibData.cxx
PHOS/AliPHOSCalibData.h
PHOS/AliPHOSClusterizerv1.cxx
PHOS/AliPHOSCpvCalibData.cxx [new file with mode: 0644]
PHOS/AliPHOSCpvCalibData.h [new file with mode: 0644]
PHOS/AliPHOSDigitizer.cxx
PHOS/AliPHOSEmcCalibData.cxx [new file with mode: 0644]
PHOS/AliPHOSEmcCalibData.h [new file with mode: 0644]
PHOS/PHOSbaseLinkDef.h
PHOS/libPHOSbase.pkg

index 6a937b9..af018f3 100644 (file)
 //                                                                           //
 ///////////////////////////////////////////////////////////////////////////////
 
+#include "TMath.h"
+#include "TRandom.h"
 #include "AliPHOSCalibData.h"
+#include "AliCDBManager.h"
+#include "AliCDBStorage.h"
+#include "AliCDBId.h"
+#include "AliCDBEntry.h"
 
 ClassImp(AliPHOSCalibData)
 
 //________________________________________________________________
-AliPHOSCalibData::AliPHOSCalibData()
+  AliPHOSCalibData::AliPHOSCalibData(): 
+    TNamed(), fCalibDataEmc(0x0), fCalibDataCpv(0x0)
 {
-  // Default constructor
-  Reset();
+  // Default constructor  
+
+  fEmcDataPath="PHOS/Emc/GainFactors_and_Pedestals";
+  fCpvDataPath="PHOS/Cpv/GainFactors_and_Pedestals";
+
 }
 
 //________________________________________________________________
-AliPHOSCalibData::AliPHOSCalibData(const char* name)
+AliPHOSCalibData::AliPHOSCalibData(Int_t runNumber) :
+  TNamed("phosCalib","PHOS Calibration Data Manager"),
+  fCalibDataEmc(0x0), fCalibDataCpv(0x0)
 {
   // Constructor
-  TString namst = "Calib_";
-  namst += name;
-  SetName(namst.Data());
-  SetTitle(namst.Data());
-  Reset();
-}
+  
+  fEmcDataPath="PHOS/Emc/GainFactors_and_Pedestals";
+  fCpvDataPath="PHOS/Cpv/GainFactors_and_Pedestals";
+
+  AliCDBEntry* entryEmc = AliCDBManager::Instance()->Get(fEmcDataPath.Data(),runNumber);
+  if(entryEmc)
+    fCalibDataEmc = (AliPHOSEmcCalibData*)entryEmc->GetObject();
+  
+  AliCDBEntry* entryCpv = AliCDBManager::Instance()->Get(fCpvDataPath.Data(),runNumber);
+  if(entryCpv)
+    fCalibDataCpv = (AliPHOSCpvCalibData*)entryCpv->GetObject();
 
-//________________________________________________________________
-AliPHOSCalibData::AliPHOSCalibData(const AliPHOSCalibData& calibda) :
-  TNamed(calibda)
-{
-  // copy constructor
-  SetName(calibda.GetName());
-  SetTitle(calibda.GetName());
-  Reset();
-  for(Int_t module=0; module<5; module++) {
-    for(Int_t column=0; column<56; column++) {
-      for(Int_t row=0; row<64; row++) {
-       fADCchannelEmc[module][column][row] = calibda.GetADCchannelEmc(module,column,row);
-       fADCpedestalEmc[module][column][row] = calibda.GetADCpedestalEmc(module,column,row);
-      }
-    }
-  }
-}
-
-//________________________________________________________________
-AliPHOSCalibData &AliPHOSCalibData::operator =(const AliPHOSCalibData& calibda)
-{
-  // assignment operator
-  SetName(calibda.GetName());
-  SetTitle(calibda.GetName());
-  Reset();
-  for(Int_t module=0; module<5; module++) {
-    for(Int_t column=0; column<56; column++) {
-      for(Int_t row=0; row<64; row++) {
-       fADCchannelEmc[module][column][row] = calibda.GetADCchannelEmc(module,column,row);
-       fADCpedestalEmc[module][column][row] = calibda.GetADCpedestalEmc(module,column,row);
-      }
-    }
-  }
-  return *this;
 }
 
 //________________________________________________________________
 AliPHOSCalibData::~AliPHOSCalibData()
 {
   // Destructor
+
+  if(fCalibDataEmc) delete fCalibDataEmc;
+  if(fCalibDataCpv) delete fCalibDataCpv;
 }
 
 //________________________________________________________________
 void AliPHOSCalibData::Reset()
 {
   // Set all pedestals to 0 and all ADC channels to 1
-  memset(fADCchannelEmc ,1,5*64*56*sizeof(Float_t));
-  memset(fADCpedestalEmc,0,5*64*56*sizeof(Float_t));
+
+  fCalibDataEmc->Reset();
+  fCalibDataCpv->Reset();
 }
 
 //________________________________________________________________
 void  AliPHOSCalibData::Print(Option_t *option) const
 {
-  // Print tables of pedestals and ADC channels
-
-  if (strstr(option,"ped")) {
-    printf("\n ----    Pedestal values ----\n\n");
-    for (Int_t module=0; module<5; module++){
-      printf("============== Module %d\n",module+1);
-      for (Int_t column=0; column<56; column++){
-       for (Int_t row=0; row<64; row++){
-         printf("%4.1f",fADCpedestalEmc[module][column][row]);
-       }
-       printf("\n");
-      }
-    }
+
+}
+
+//________________________________________________________________
+void AliPHOSCalibData::CreateNew()
+{
+  if(fCalibDataEmc) delete fCalibDataEmc;
+  fCalibDataEmc = new AliPHOSEmcCalibData("PHOS-EMC");
+
+  if(fCalibDataCpv) delete fCalibDataCpv;
+  fCalibDataCpv = new AliPHOSCpvCalibData("PHOS-CPV");
+
+}
+
+//________________________________________________________________
+Bool_t AliPHOSCalibData::WriteEmc(Int_t firstRun, Int_t lastRun, AliCDBMetaData *md)
+{
+
+  if(!fCalibDataEmc) return kFALSE;
+
+  AliCDBStorage* storage = AliCDBManager::Instance()->GetSpecificStorage("PHOS");
+  if(storage) { 
+    AliCDBId id(fEmcDataPath.Data(),firstRun,lastRun);
+    storage->Put(fCalibDataEmc,id, md);
+    return kTRUE;
   }
+  else
+    return kFALSE;
 
-  if (strstr(option,"gain")) {
-    printf("\n ----    ADC channel values      ----\n\n");
-    for (Int_t module=0; module<5; module++){
-      printf("============== Module %d\n",module+1);
-      for (Int_t column=0; column<56; column++){
-       for (Int_t row=0; row<64; row++){
-         printf("%4.1f",fADCchannelEmc[module][column][row]);
-       }
-       printf("\n");
-      }
-    }
+}
+
+//________________________________________________________________
+Bool_t AliPHOSCalibData::WriteCpv(Int_t firstRun, Int_t lastRun, AliCDBMetaData *md)
+{
+
+  if(!fCalibDataCpv) return kFALSE;
+  
+  AliCDBStorage* storage = AliCDBManager::Instance()->GetSpecificStorage("PHOS");
+  if(storage) { 
+    AliCDBId id(fCpvDataPath.Data(),firstRun,lastRun);
+    storage->Put(fCalibDataCpv,id, md);
+    return kTRUE;
   }
+  else
+    return kFALSE;
+
 }
 
+//________________________________________________________________
 Float_t AliPHOSCalibData::GetADCchannelEmc(Int_t module, Int_t column, Int_t row) const
 {
   //module, column,raw should follow the internal PHOS convention:
   //module 1:5, column 1:56, row 1:64
 
-  return fADCchannelEmc[module-1][column-1][row-1];
+  if(fCalibDataEmc) 
+    return fCalibDataEmc->GetADCchannelEmc(module,column,row);
+  else
+    return 0.0015; // default width of one EMC ADC channel in GeV
 }
 
 Float_t AliPHOSCalibData::GetADCpedestalEmc(Int_t module, Int_t column, Int_t row) const
 {
-  return fADCpedestalEmc[module-1][column-1][row-1];
+  if(fCalibDataEmc) 
+    return fCalibDataEmc->GetADCpedestalEmc(module,column,row);
+  else
+    return 0.005; // default EMC ADC pedestal
 }
 
 void AliPHOSCalibData::SetADCchannelEmc(Int_t module, Int_t column, Int_t row, Float_t value)
 {
-  fADCchannelEmc[module-1][column-1][row-1] = value;
+  if(!fCalibDataEmc)
+    fCalibDataEmc = new AliPHOSEmcCalibData("PHOS-EMC");
+
+  fCalibDataEmc->SetADCchannelEmc(module,column,row,value);
 }
 
 void AliPHOSCalibData::SetADCpedestalEmc(Int_t module, Int_t column, Int_t row, Float_t value)
 {
-  fADCpedestalEmc[module-1][column-1][row-1] = value;
+  if(!fCalibDataEmc)
+    fCalibDataEmc = new AliPHOSEmcCalibData("PHOS-EMC");
+
+  fCalibDataEmc->SetADCpedestalEmc(module,column,row,value);
+}
+
+//________________________________________________________________
+Float_t AliPHOSCalibData::GetADCchannelCpv(Int_t module, Int_t column, Int_t row) const
+{
+  //module, column,raw should follow the internal CPV convention:
+  //module 1:5, column 1:64, row 1:128
+
+  if(fCalibDataCpv) 
+    return fCalibDataCpv->GetADCchannelCpv(module,column,row);
+  else
+    return 0.0012; // default width of one ADC channel in CPV 'popugais'
+}
+
+Float_t AliPHOSCalibData::GetADCpedestalCpv(Int_t module, Int_t column, Int_t row) const
+{
+  if(fCalibDataCpv) 
+    return fCalibDataCpv->GetADCpedestalCpv(module,column,row);
+  else
+    return 0.012; // default CPV ADC pedestal
+}
+
+void AliPHOSCalibData::SetADCchannelCpv(Int_t module, Int_t column, Int_t row, Float_t value)
+{
+  if(!fCalibDataCpv)
+    fCalibDataCpv = new AliPHOSCpvCalibData("PHOS-CPV");
+
+  fCalibDataCpv->SetADCchannelCpv(module,column,row,value);
+}
+
+void AliPHOSCalibData::SetADCpedestalCpv(Int_t module, Int_t column, Int_t row, Float_t value)
+{
+  if(!fCalibDataCpv)
+    fCalibDataCpv = new AliPHOSCpvCalibData("PHOS-CPV");
+
+  fCalibDataCpv->SetADCpedestalCpv(module,column,row,value);
+}
+
+//________________________________________________________________
+void AliPHOSCalibData::RandomEmc()
+{
+
+  if(fCalibDataEmc) delete fCalibDataEmc;
+  fCalibDataEmc = new AliPHOSEmcCalibData("PHOS-EMC");
+
+  TRandom rn;
+  rn.SetSeed(0); //the seed is set to the current  machine clock
+  
+  Float_t ADCchanelEmc,ADCpedestalEmc;
+
+  for(Int_t module=1; module<6; module++) {
+    for(Int_t column=1; column<57; column++) {
+      for(Int_t row=1; row<65; row++) {
+        ADCchanelEmc=rn.Uniform(0.00075,0.00375); // Cmax/Cmin = 5, (Cmax-Cmin)/2 = 0.0015
+        ADCpedestalEmc=rn.Uniform(0.0045,0.0055); //+-10% spread of pedestals from 0.005
+        fCalibDataEmc->SetADCchannelEmc(module,column,row,ADCchanelEmc);
+        fCalibDataEmc->SetADCpedestalEmc(module,column,row,ADCpedestalEmc);
+      }
+    }
+  }
+
+}
+
+//________________________________________________________________
+void AliPHOSCalibData::RandomCpv()
+{
+
+  if(fCalibDataCpv) delete fCalibDataCpv;
+  fCalibDataCpv = new AliPHOSCpvCalibData("PHOS-CPV");
+
+  TRandom rn;
+  rn.SetSeed(0); //the seed is set to the current  machine clock
+  
+  Float_t ADCchanelCpv,ADCpedestalCpv;
+
+  for(Int_t module=1; module<6; module++) {
+    for(Int_t column=1; column<65; column++) {
+      for(Int_t row=1; row<129; row++) {
+       ADCchanelCpv=TMath::Abs(rn.Uniform(0.0009,0.0015)); // 0.0012 +- 25%
+        ADCpedestalCpv=rn.Uniform(0.0048,0.0192); // Ped[max]/Ped[min] = 4, <Ped> = 0.012
+        fCalibDataCpv->SetADCchannelCpv(module,column,row,ADCchanelCpv);
+        fCalibDataCpv->SetADCpedestalCpv(module,column,row,ADCpedestalCpv);
+      }
+    }
+  }
 }
index 05c0384..5844012 100644 (file)
@@ -7,32 +7,56 @@
 /* $Id$ */
 
 ////////////////////////////////////////////////
-//  class for PHOS calibration                 //
+//  class for PHOS calibration                //
 ////////////////////////////////////////////////
 
 #include "TNamed.h"
-#include "AliPHOS.h"
+#include "TString.h"
+#include "AliPHOSEmcCalibData.h"
+#include "AliPHOSCpvCalibData.h"
+#include "AliCDBMetaData.h"
 
 class AliPHOSCalibData: public TNamed {
 
  public:
   AliPHOSCalibData();
-  AliPHOSCalibData(const char* name);
-  AliPHOSCalibData(const AliPHOSCalibData &calibda);
-  AliPHOSCalibData& operator= (const AliPHOSCalibData &calibda);
+  AliPHOSCalibData(Int_t runNumber);
   virtual ~AliPHOSCalibData();
   void Reset();
   virtual void Print(Option_t *option = "") const; 
-  //
+  
+  void CreateNew();
+  void RandomEmc();
+  void RandomCpv();
+
   Float_t GetADCchannelEmc(Int_t module, Int_t column, Int_t row) const;
   Float_t GetADCpedestalEmc(Int_t module, Int_t column, Int_t row) const;
-  //
+  
   void SetADCchannelEmc(Int_t module, Int_t column, Int_t row, Float_t value);
   void SetADCpedestalEmc(Int_t module, Int_t column, Int_t row, Float_t value);
 
- protected:
-  Float_t  fADCchannelEmc[5][56][64] ;  // width of one ADC channel in GeV ([mod][col][row])
-  Float_t  fADCpedestalEmc[5][56][64] ; // value of the EMC ADC pedestal ([mod][col][row])
+  Float_t GetADCchannelCpv(Int_t module, Int_t column, Int_t row) const;
+  Float_t GetADCpedestalCpv(Int_t module, Int_t column, Int_t row) const;
+  
+  void SetADCchannelCpv(Int_t module, Int_t column, Int_t row, Float_t value);
+  void SetADCpedestalCpv(Int_t module, Int_t column, Int_t row, Float_t value);
+
+  void SetDB(const char* db) {fDB=db;}
+  void SetEmcDataPath(const char* emcPath) {fEmcDataPath=emcPath;}
+  void SetCpvDataPath(const char* cpvPath) {fCpvDataPath=cpvPath;}
+
+  Bool_t WriteEmc(Int_t firstRun, Int_t lastRun, AliCDBMetaData *md);
+  Bool_t WriteCpv(Int_t firstRun, Int_t lastRun, AliCDBMetaData *md);
+
+ private:
+
+  AliPHOSEmcCalibData* fCalibDataEmc; // EMC calibration data
+  AliPHOSCpvCalibData* fCalibDataCpv; // CPV calibration data
+  
+  TString fDB;
+  TString fEmcDataPath; // path to EMC calibration data
+  TString fCpvDataPath; // path to CPV calibration data
+
   //
   ClassDef(AliPHOSCalibData,1)    // PHOS Calibration data
 };
index c090fcb..5a9d3e7 100644 (file)
@@ -18,6 +18,9 @@
 /* History of cvs commits:
  *
  * $Log$
+ * Revision 1.88  2006/01/11 08:54:52  hristov
+ * Additional protection in case no calibration entry was found
+ *
  * Revision 1.87  2005/11/22 08:46:43  kharlov
  * Updated to new CDB (Boris Polichtchouk)
  *
@@ -151,8 +154,11 @@ Float_t  AliPHOSClusterizerv1::Calibrate(Int_t amp, Int_t absId)
       fADCpedestalEmc = fCalibData->GetADCpedestalEmc(module,column,row);
       return fADCpedestalEmc + amp*fADCchanelEmc ;        
     }
-    else //calibrate as CPV, not implemented yet
-      return 0;
+    else { //calibrate as CPV
+      fADCchanelCpv   = fCalibData->GetADCchannelCpv (module,column,row);
+      fADCpedestalCpv = fCalibData->GetADCpedestalCpv(module,column,row);
+      return fADCpedestalCpv + amp*fADCchanelCpv ;              
+    }     
   }
   else{ //simulation
     if(absId <= fEmcCrystals) //calibrate as EMC 
@@ -332,13 +338,7 @@ void AliPHOSClusterizerv1::GetCalibrationParameters()
   // AliCDBStorage* storage = AliCDBManager::Instance()->GetStorage("local://CalibDB");
 
   AliPHOSGetter * gime = AliPHOSGetter::Instance();
-
-  if(AliCDBManager::Instance()->IsDefaultStorageSet()){
-    AliCDBEntry *entry = (AliCDBEntry*) AliCDBManager::Instance()->GetDefaultStorage()
-      ->Get("PHOS/GainFactors_and_Pedestals/Calibration",gAlice->GetRunNumber());
-    if (entry) fCalibData = (AliPHOSCalibData*) entry->GetObject();
-  }
-  
+  fCalibData = new AliPHOSCalibData(gAlice->GetRunNumber()); 
   
   if(!fCalibData)
     {
diff --git a/PHOS/AliPHOSCpvCalibData.cxx b/PHOS/AliPHOSCpvCalibData.cxx
new file mode 100644 (file)
index 0000000..73bd283
--- /dev/null
@@ -0,0 +1,158 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+
+///////////////////////////////////////////////////////////////////////////////
+//                                                                           //
+// class for CPV calibration.                                                //
+// Author: Boris Polichtchouk (Boris.Polichtchouk@cern.ch).                  //
+//                                                                           //
+///////////////////////////////////////////////////////////////////////////////
+
+#include "AliPHOSCpvCalibData.h"
+
+ClassImp(AliPHOSCpvCalibData)
+
+//________________________________________________________________
+  AliPHOSCpvCalibData::AliPHOSCpvCalibData() : TNamed()
+{
+  // Default constructor
+  Reset();
+}
+
+//________________________________________________________________
+AliPHOSCpvCalibData::AliPHOSCpvCalibData(const char* name)
+{
+  // Constructor
+  TString namst = "CalibCPV_";
+  namst += name;
+  SetName(namst.Data());
+  SetTitle(namst.Data());
+  Reset();
+}
+
+//________________________________________________________________
+AliPHOSCpvCalibData::AliPHOSCpvCalibData(const AliPHOSCpvCalibData& calibda) :
+  TNamed(calibda)
+{
+  // copy constructor
+  SetName(calibda.GetName());
+  SetTitle(calibda.GetName());
+  Reset();
+  for(Int_t module=0; module<5; module++) {
+    for(Int_t column=0; column<64; column++) {
+      for(Int_t row=0; row<128; row++) {
+       fADCchannelCpv[module][column][row] = calibda.GetADCchannelCpv(module,column,row);
+       fADCpedestalCpv[module][column][row] = calibda.GetADCpedestalCpv(module,column,row);
+      }
+    }
+  }
+}
+
+//________________________________________________________________
+AliPHOSCpvCalibData &AliPHOSCpvCalibData::operator =(const AliPHOSCpvCalibData& calibda)
+{
+  // assignment operator
+  SetName(calibda.GetName());
+  SetTitle(calibda.GetName());
+  Reset();
+  for(Int_t module=0; module<5; module++) {
+    for(Int_t column=0; column<64; column++) {
+      for(Int_t row=0; row<128; row++) {
+       fADCchannelCpv[module][column][row] = calibda.GetADCchannelCpv(module,column,row);
+       fADCpedestalCpv[module][column][row] = calibda.GetADCpedestalCpv(module,column,row);
+      }
+    }
+  }
+  return *this;
+}
+
+//________________________________________________________________
+AliPHOSCpvCalibData::~AliPHOSCpvCalibData()
+{
+  // Destructor
+}
+
+//________________________________________________________________
+void AliPHOSCpvCalibData::Reset()
+{
+  // Set all pedestals and all ADC channels to its default values.
+
+  for (Int_t module=0; module<5; module++){
+    for (Int_t column=0; column<64; column++){
+      for (Int_t row=0; row<128; row++){
+       fADCpedestalCpv[module][column][row] = 0.012;
+       fADCchannelCpv[module][column][row] = 0.0012;
+      }
+    }
+  }
+
+}
+
+//________________________________________________________________
+void  AliPHOSCpvCalibData::Print(Option_t *option) const
+{
+  // Print tables of pedestals and ADC channels
+
+  if (strstr(option,"ped")) {
+    printf("\n ----    Pedestal values ----\n\n");
+    for (Int_t module=0; module<5; module++){
+      printf("============== Module %d\n",module+1);
+      for (Int_t column=0; column<64; column++){
+       for (Int_t row=0; row<128; row++){
+         printf("%4.1f",fADCpedestalCpv[module][column][row]);
+       }
+       printf("\n");
+      }
+    }
+  }
+
+  if (strstr(option,"gain")) {
+    printf("\n ----    ADC channel values      ----\n\n");
+    for (Int_t module=0; module<5; module++){
+      printf("============== Module %d\n",module+1);
+      for (Int_t column=0; column<64; column++){
+       for (Int_t row=0; row<128; row++){
+         printf("%4.1f",fADCchannelCpv[module][column][row]);
+       }
+       printf("\n");
+      }
+    }
+  }
+}
+
+Float_t AliPHOSCpvCalibData::GetADCchannelCpv(Int_t module, Int_t column, Int_t row) const
+{
+  //CPV pads
+  //module, column,raw should follow the internal PHOS convention:
+  //module 1:5, column 1:64, row 1:128.
+
+  return fADCchannelCpv[module-1][column-1][row-1];
+}
+
+Float_t AliPHOSCpvCalibData::GetADCpedestalCpv(Int_t module, Int_t column, Int_t row) const
+{
+  return fADCpedestalCpv[module-1][column-1][row-1];
+}
+
+void AliPHOSCpvCalibData::SetADCchannelCpv(Int_t module, Int_t column, Int_t row, Float_t value)
+{
+  fADCchannelCpv[module-1][column-1][row-1] = value;
+}
+
+void AliPHOSCpvCalibData::SetADCpedestalCpv(Int_t module, Int_t column, Int_t row, Float_t value)
+{
+  fADCpedestalCpv[module-1][column-1][row-1] = value;
+}
diff --git a/PHOS/AliPHOSCpvCalibData.h b/PHOS/AliPHOSCpvCalibData.h
new file mode 100644 (file)
index 0000000..01e2f5a
--- /dev/null
@@ -0,0 +1,38 @@
+#ifndef ALIPHOSCPVCALIBDATA_H
+#define ALIPHOSCPVCALIBDATA_H
+
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+////////////////////////////////////////////////
+//  class for CPV calibration                 //
+////////////////////////////////////////////////
+
+#include "TNamed.h"
+
+class AliPHOSCpvCalibData: public TNamed {
+
+ public:
+  AliPHOSCpvCalibData();
+  AliPHOSCpvCalibData(const char* name);
+  AliPHOSCpvCalibData(const AliPHOSCpvCalibData &calibda);
+  AliPHOSCpvCalibData& operator= (const AliPHOSCpvCalibData &calibda);
+  virtual ~AliPHOSCpvCalibData();
+  void Reset();
+  virtual void Print(Option_t *option = "") const; 
+  //
+  Float_t GetADCchannelCpv(Int_t module, Int_t column, Int_t row) const;
+  Float_t GetADCpedestalCpv(Int_t module, Int_t column, Int_t row) const;
+  //
+  void SetADCchannelCpv(Int_t module, Int_t column, Int_t row, Float_t value);
+  void SetADCpedestalCpv(Int_t module, Int_t column, Int_t row, Float_t value);
+
+ protected:
+  Float_t  fADCchannelCpv[5][64][128];  // width of one CPV ADC channel ([mod][col][row])
+  Float_t  fADCpedestalCpv[5][64][128]; // value of the CPV ADC pedestal ([mod][col][row])
+  //
+  ClassDef(AliPHOSCpvCalibData,1)    // CPV Calibration data
+
+};
+
+#endif
index dd1e865..a1899f5 100644 (file)
@@ -18,6 +18,9 @@
 /* History of cvs commits:
  *
  * $Log$
+ * Revision 1.87  2005/08/24 15:33:49  kharlov
+ * Calibration data for raw digits
+ *
  * Revision 1.86  2005/07/12 20:07:35  hristov
  * Changes needed to run simulation and reconstrruction in the same AliRoot session
  *
@@ -393,6 +396,11 @@ Int_t AliPHOSDigitizer::DigitizeEnergy(Float_t energy, Int_t absId)
 
   AliPHOSGetter* gime = AliPHOSGetter::Instance();
 
+  if(!gime->CalibData()) {
+    AliPHOSCalibData* cdb = new AliPHOSCalibData(gAlice->GetRunNumber());
+    gime->SetCalibData(cdb);
+  }
+
   //Determine rel.position of the cell absId
   Int_t relId[4];
   gime->PHOSGeometry()->AbsToRelNumbering(absId,relId);
@@ -418,6 +426,11 @@ Int_t AliPHOSDigitizer::DigitizeEnergy(Float_t energy, Int_t absId)
     if(chanel > fNADCemc ) chanel =  fNADCemc ;
   }
   else{ //Digitize as CPV
+    if(gime->CalibData()) {
+      fADCpedestalCpv = gime->CalibData()->GetADCpedestalCpv(module,column,raw);
+      fADCchanelCpv = gime->CalibData()->GetADCchannelCpv(module,column,raw);
+    }
+
     chanel = (Int_t) TMath::Ceil((energy - fADCpedestalCpv)/fADCchanelCpv) ;       
     if(chanel > fNADCcpv ) chanel =  fNADCcpv ;
   }
diff --git a/PHOS/AliPHOSEmcCalibData.cxx b/PHOS/AliPHOSEmcCalibData.cxx
new file mode 100644 (file)
index 0000000..9f5fb6d
--- /dev/null
@@ -0,0 +1,155 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+///////////////////////////////////////////////////////////////////////////////
+//                                                                           //
+// class for PHOS EmCal calibration                                          //
+//                                                                           //
+///////////////////////////////////////////////////////////////////////////////
+
+#include "AliPHOSEmcCalibData.h"
+
+ClassImp(AliPHOSEmcCalibData)
+
+//________________________________________________________________
+AliPHOSEmcCalibData::AliPHOSEmcCalibData()
+{
+  // Default constructor
+  Reset();
+}
+
+//________________________________________________________________
+AliPHOSEmcCalibData::AliPHOSEmcCalibData(const char* name)
+{
+  // Constructor
+  TString namst = "Calib_";
+  namst += name;
+  SetName(namst.Data());
+  SetTitle(namst.Data());
+  Reset();
+}
+
+//________________________________________________________________
+AliPHOSEmcCalibData::AliPHOSEmcCalibData(const AliPHOSEmcCalibData& calibda) :
+  TNamed(calibda)
+{
+  // copy constructor
+  SetName(calibda.GetName());
+  SetTitle(calibda.GetName());
+  Reset();
+  for(Int_t module=0; module<5; module++) {
+    for(Int_t column=0; column<56; column++) {
+      for(Int_t row=0; row<64; row++) {
+       fADCchannelEmc[module][column][row] = calibda.GetADCchannelEmc(module,column,row);
+       fADCpedestalEmc[module][column][row] = calibda.GetADCpedestalEmc(module,column,row);
+      }
+    }
+  }
+}
+
+//________________________________________________________________
+AliPHOSEmcCalibData &AliPHOSEmcCalibData::operator =(const AliPHOSEmcCalibData& calibda)
+{
+  // assignment operator
+  SetName(calibda.GetName());
+  SetTitle(calibda.GetName());
+  Reset();
+  for(Int_t module=0; module<5; module++) {
+    for(Int_t column=0; column<56; column++) {
+      for(Int_t row=0; row<64; row++) {
+       fADCchannelEmc[module][column][row] = calibda.GetADCchannelEmc(module,column,row);
+       fADCpedestalEmc[module][column][row] = calibda.GetADCpedestalEmc(module,column,row);
+      }
+    }
+  }
+  return *this;
+}
+
+//________________________________________________________________
+AliPHOSEmcCalibData::~AliPHOSEmcCalibData()
+{
+  // Destructor
+}
+
+//________________________________________________________________
+void AliPHOSEmcCalibData::Reset()
+{
+  // Set all pedestals and all ADC channels to its default values.
+
+  for (Int_t module=0; module<5; module++){
+    for (Int_t column=0; column<56; column++){
+      for (Int_t row=0; row<64; row++){
+       fADCpedestalEmc[module][column][row] = 0.005;
+       fADCchannelEmc[module][column][row] = 0.0015;
+      }
+    }
+  }
+
+}
+
+//________________________________________________________________
+void  AliPHOSEmcCalibData::Print(Option_t *option) const
+{
+  // Print tables of pedestals and ADC channels
+
+  if (strstr(option,"ped")) {
+    printf("\n ----    EMC Pedestal values     ----\n\n");
+    for (Int_t module=0; module<5; module++){
+      printf("============== Module %d\n",module+1);
+      for (Int_t column=0; column<56; column++){
+       for (Int_t row=0; row<64; row++){
+         printf("%4.1f",fADCpedestalEmc[module][column][row]);
+       }
+       printf("\n");
+      }
+    }
+  }
+
+  if (strstr(option,"gain")) {
+    printf("\n ----    EMC ADC channel values  ----\n\n");
+    for (Int_t module=0; module<5; module++){
+      printf("============== Module %d\n",module+1);
+      for (Int_t column=0; column<56; column++){
+       for (Int_t row=0; row<64; row++){
+         printf("%4.1f",fADCchannelEmc[module][column][row]);
+       }
+       printf("\n");
+      }
+    }
+  }
+}
+
+Float_t AliPHOSEmcCalibData::GetADCchannelEmc(Int_t module, Int_t column, Int_t row) const
+{
+  //module, column,raw should follow the internal PHOS convention:
+  //module 1:5, column 1:56, row 1:64
+
+  return fADCchannelEmc[module-1][column-1][row-1];
+}
+
+Float_t AliPHOSEmcCalibData::GetADCpedestalEmc(Int_t module, Int_t column, Int_t row) const
+{
+  return fADCpedestalEmc[module-1][column-1][row-1];
+}
+
+void AliPHOSEmcCalibData::SetADCchannelEmc(Int_t module, Int_t column, Int_t row, Float_t value)
+{
+  fADCchannelEmc[module-1][column-1][row-1] = value;
+}
+
+void AliPHOSEmcCalibData::SetADCpedestalEmc(Int_t module, Int_t column, Int_t row, Float_t value)
+{
+  fADCpedestalEmc[module-1][column-1][row-1] = value;
+}
diff --git a/PHOS/AliPHOSEmcCalibData.h b/PHOS/AliPHOSEmcCalibData.h
new file mode 100644 (file)
index 0000000..1c9814a
--- /dev/null
@@ -0,0 +1,37 @@
+#ifndef ALIPHOSEMCCALIBDATA_H
+#define ALIPHOSEMCCALIBDATA_H
+
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+////////////////////////////////////////////////
+//  class for EMC calibration                 //
+////////////////////////////////////////////////
+
+#include "TNamed.h"
+
+class AliPHOSEmcCalibData: public TNamed {
+
+ public:
+  AliPHOSEmcCalibData();
+  AliPHOSEmcCalibData(const char* name);
+  AliPHOSEmcCalibData(const AliPHOSEmcCalibData &calibda);
+  AliPHOSEmcCalibData& operator= (const AliPHOSEmcCalibData &calibda);
+  virtual ~AliPHOSEmcCalibData();
+  void Reset();
+  virtual void Print(Option_t *option = "") const; 
+  //
+  Float_t GetADCchannelEmc(Int_t module, Int_t column, Int_t row) const;
+  Float_t GetADCpedestalEmc(Int_t module, Int_t column, Int_t row) const;
+  //
+  void SetADCchannelEmc(Int_t module, Int_t column, Int_t row, Float_t value);
+  void SetADCpedestalEmc(Int_t module, Int_t column, Int_t row, Float_t value);
+
+ protected:
+  Float_t  fADCchannelEmc[5][56][64] ;  // width of one EMC ADC channel in GeV ([mod][col][row])
+  Float_t  fADCpedestalEmc[5][56][64] ; // value of the EMC ADC pedestal ([mod][col][row])
+  //
+  ClassDef(AliPHOSEmcCalibData,1)    // PHOS EMC calibration data
+};
+
+#endif
index d71ebb6..63623d6 100644 (file)
@@ -26,6 +26,7 @@
 #pragma link C++ class AliPHOSRawStream2004+;
 #pragma link C++ class AliPHOSCalibData+;
 #pragma link C++ class AliPHOSAlignData+;
-
+#pragma link C++ class AliPHOSCpvCalibData+;
+#pragma link C++ class AliPHOSEmcCalibData+;
 
 #endif
index 2b47d4f..2375317 100644 (file)
@@ -10,7 +10,10 @@ SRCS          =  AliPHOS.cxx \
                 AliPHOSCalibrationDB.cxx AliPHOSDigitizer.cxx \
                 AliPHOSSDigitizer.cxx AliPHOSDigit.cxx \
                 AliPHOSFastRecParticle.cxx AliPHOSRawStream2004.cxx \
-                AliPHOSCalibData.cxx AliPHOSAlignData.cxx
+                AliPHOSCalibData.cxx AliPHOSAlignData.cxx \
+                 AliPHOSCpvCalibData.cxx \
+                 AliPHOSEmcCalibData.cxx
+
 
 HDRS:= $(SRCS:.cxx=.h)