// //
///////////////////////////////////////////////////////////////////////////////
+#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);
+ }
+ }
+ }
}
/* $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
};
/* 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)
*
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
// 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)
{
--- /dev/null
+/**************************************************************************
+ * 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;
+}
--- /dev/null
+#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
/* 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
*
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);
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 ;
}
--- /dev/null
+/**************************************************************************
+ * 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;
+}
--- /dev/null
+#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
#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
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)