{
printf("\n ---- Mean pedestal values ----\n\n");
for(int t=0; t<47; t++){
- printf(" MeanPed Value[ADC%d] = %f\n",t,fMeanPedestal[t]);
+ if(t==0 || t==24) printf("\t ZN HighRes -------- ");
+ else if(t==5 || t==29) printf("\t ZN LowRes -------- ");
+ else if(t==10 || t==34) printf("\t ZP HighRes -------- ");
+ else if(t==15 || t==39) printf("\t ZP LowRes -------- ");
+ else if(t==20) printf("\t ZEM1 HighRes -------- ");
+ else if(t==21) printf("\t ZEM1 LowRes -------- ");
+ else if(t==22) printf("\t ZEM2 HighRes -------- ");
+ else if(t==23) printf("\t ZEM2 LowRes -------- ");
+ printf("\t MeanPed[ADC%d] = %.1f\n",t,fMeanPedestal[t]);
}
printf("\n ---- Energy calibration coefficients ----\n\n");
#include "TNamed.h"
#include "TH1.h"
#include "AliZDC.h"
+#include "AliCDBEntry.h"
class AliZDCCalibData: public TNamed {
#include "AliGenHijingEventHeader.h"
#include "AliRunDigitizer.h"
#include "AliRunLoader.h"
+#include "AliCDBStorage.h"
+#include "AliCDBEntry.h"
#include "AliZDCSDigit.h"
#include "AliZDCDigit.h"
#include "AliZDCFragment.h"
#include "AliZDCDigitizer.h"
+#include "AliZDCCalibData.h"
ClassImp(AliZDCDigitizer)
AliZDCDigitizer::AliZDCDigitizer(AliRunDigitizer* manager):
AliDigitizer(manager)
{
-// Constructor
-
+ // Constructor
+ // if(!fStorage) fStorage = AliCDBManager::Instance()->GetStorage("local://DBlocal");
}
//____________________________________________________________________________
//____________________________________________________________________________
Bool_t AliZDCDigitizer::Init()
{
-// Initialize the digitizer
-
+ // Initialize the digitizer
+ // NB -> PM gain vs. HV & ADC resolutions will move to DCDB ***************
for (Int_t i = 0; i < 3; i++) {
for(Int_t j = 0; j < 5; j++) {
fPMGain[i][j] = 100000.;
}
}
-
-// ADC Caen V965
+ // ADC Caen V965
fADCRes[0] = 0.0000008; // ADC Resolution high gain: 200 fC/adcCh
fADCRes[1] = 0.0000064; // ADC Resolution low gain: 25 fC/adcCh
//____________________________________________________________________________
void AliZDCDigitizer::Exec(Option_t* /*option*/)
{
-// Execute digitization
+ // Execute digitization
Float_t pm[3][5];
+ // --- pm[0][...] = light in ZN [C, Q1, Q2, Q3, Q4]
+ // --- pm[1][...] = light in ZP [C, Q1, Q2, Q3, Q4]
+ // --- pm[2][...] = light in ZEM [x, 1, 2, x, x]
for (Int_t iSector1 = 0; iSector1 < 3; iSector1++)
for (Int_t iSector2 = 0; iSector2 < 5; iSector2++) {
pm[iSector1][iSector2] = 0;
}
- // pm[0][...] = light in ZN [C, Q1, Q2, Q3, Q4]
- // pm[1][...] = light in ZP [C, Q1, Q2, Q3, Q4]
- // pm[2][...] = light in ZEM [x, 1, 2, x, x]
// impact parameter and number of spectators
Float_t impPar = -1;
sdigit.GetSector(0), sdigit.GetSector(1)));
continue;
}
- pm[sdigit.GetSector(0)-1][sdigit.GetSector(1)] += sdigit.GetLightPM();
- //printf("\n\t sector[0] = %d, sector[1] = %d, pm[%d][%d] = %f \n",
- // sdigit.GetSector(0), sdigit.GetSector(1),sdigit.GetSector(0)-1,
- // sdigit.GetSector(1), pm[sdigit.GetSector(0)-1][sdigit.GetSector(1)]); // Chiara debugging!
+ pm[(sdigit.GetSector(0))-1][sdigit.GetSector(1)] += sdigit.GetLightPM();
+ printf("\n\t Detector (%d, %d), pm[%d][%d] = %.0f \n",
+ sdigit.GetSector(0), sdigit.GetSector(1),sdigit.GetSector(0)-1,
+ sdigit.GetSector(1), pm[sdigit.GetSector(0)-1][sdigit.GetSector(1)]); // Chiara debugging!
}
// unload sdigits
specP = ((AliGenHijingEventHeader*) genHeader)->ProjSpectatorsp();
AliDebug(2, Form("\n b = %f fm, Nspecn = %d, Nspecp = %d\n",
impPar, specN, specP));
+ printf("\n\t **** b = %f fm, Nspecn = %d, Nspecp = %d\n",
+ impPar, specN, specP);
}
// add spectators
if (impPar >= 0) {
Int_t freeSpecN, freeSpecP;
Fragmentation(impPar, specN, specP, freeSpecN, freeSpecP);
+ printf("\n\t ---- Adding signal for %d free spectator n\n",freeSpecN);
SpectatorSignal(1, freeSpecN, pm);
+ printf("\t ---- Adding signal for %d free spectator p\n\n",freeSpecP);
SpectatorSignal(2, freeSpecP, pm);
}
for (sector[1] = 0; sector[1] < 5; sector[1]++) {
if ((sector[0] == 3) && ((sector[1] < 1) || (sector[1] > 2))) continue;
for (Int_t res = 0; res < 2; res++){
- digi[res] = Phe2ADCch(1, 0, pm[sector[0]-1][sector[1]], res)
- + Pedestal();
- //printf("\n\t sector[0] = %d, sector[1] = %d, digi[%d] = %d\n",
- // sector[0], sector[1], res, digi[res]); // Chiara debugging!
+ digi[res] = Phe2ADCch(sector[0], sector[1], pm[sector[0]-1][sector[1]], res)
+ + Pedestal(sector[0], sector[1], res);
+ printf("\t DIGIT added -> det = %d, quad = %d - digi[%d] = %d\n\n",
+ sector[0], sector[1], res, digi[res]); // Chiara debugging!
}
new(pdigit) AliZDCDigit(sector, digi);
treeD->Fill();
Float_t *entry, hitsSpec[7];
Int_t pl, i, j, k, iev=0, rnd[125], volume[2];
- for(pl=0;pl<125;pl++){
- rnd[pl] = 0;
- }
+ for(pl=0;pl<125;pl++) rnd[pl] = 0;
if (numEvents > 125) {
AliWarning(Form("numEvents (%d) is larger than 125", numEvents));
numEvents = 125;
if(entry[0] == rnd[iev]){
for(k=0; k<2; k++) volume[k] = (Int_t) entry[k+1];
for(j=0; j<7; j++) hitsSpec[j] = entry[j+3];
-
+ //
Float_t lightQ = hitsSpec[4];
Float_t lightC = hitsSpec[5];
- AliDebug(3, Form("volume = (%d, %d), lightQ = %.3f, lightC = %.3f",
+ AliDebug(3, Form("Volume = (%d, %d), lightQ = %.0f, lightC = %.0f",
volume[0], volume[1], lightQ, lightC));
+ //printf("\n Volume = (%d, %d), lightQ = %.0f, lightC = %.0f",
+ // volume[0], volume[1], lightQ, lightC);
if (volume[0] < 3) { // ZN or ZP
pm[volume[0]-1][0] += lightC;
pm[volume[0]-1][volume[1]] += lightQ;
- } else {
- if (volume[1] == 1) pm[2][1] += lightC;
- else pm[2][2] += lightQ;
- }
-
-
+ //printf("\n pm[%d][0] = %.0f, pm[%d][%d] = %.0f\n",(volume[0]-1),pm[volume[0]-1][0],
+ // (volume[0]-1),volume[1],pm[volume[0]-1][volume[1]]);
+ }
+ else {
+ if (volume[1] == 1) pm[2][1] += lightC; // ZEM 1
+ else pm[2][2] += lightQ; // ZEM 2
+ //printf("\n pm[2][1] = %.0f, pm[2][2] = %.0f\n",pm[2][1],pm[2][2]);
+ }
}
else if(entry[0] > rnd[iev]){
iev++;
Int_t AliZDCDigitizer::Phe2ADCch(Int_t Det, Int_t Quad, Float_t Light,
Int_t Res) const
{
-// Evaluation of the ADC channel corresponding to the light yield Light
+ // Evaluation of the ADC channel corresponding to the light yield Light
+ Int_t ADCch = (Int_t) (Light * fPMGain[Det-1][Quad] * fADCRes[Res]);
+ printf("\t Phe2ADCch -> det %d quad %d - phe %.0f ADC %d\n", Det,Quad,Light,ADCch);
+ return ADCch;
+}
- return (Int_t) (Light * fPMGain[Det-1][Quad] * fADCRes[Res]);
+//_____________________________________________________________________________
+Int_t AliZDCDigitizer::Pedestal(Int_t Det, Int_t Quad, Int_t Res) const
+{
+ // Get calibration data
+ int runNumber = 0;
+ AliZDCCalibData *calibda = GetCalibData(runNumber);
+ //calibda->Print("");
+
+ Float_t meanPed;
+ if(Det != 3) meanPed = calibda->GetMeanPed(10*(Det-1)+Quad+5*Res);
+ else meanPed = calibda->GetMeanPed(10*(Det-1)+Quad+1*Res);
+
+ printf("\t Pedestal -> det = %d, quad = %d, res = %d - Ped[%d] = %d\n",
+ Det, Quad, Res,10*(Det-1)+Quad+5*Res,(Int_t) meanPed); // Chiara debugging!
+
+ return (Int_t) meanPed;
}
//_____________________________________________________________________________
-Int_t AliZDCDigitizer::Pedestal() const
+AliZDCCalibData* AliZDCDigitizer::GetCalibData(int runNumber) const
{
- // --- Pedestal value -> extracted from a gaussian distribution
- // obtained from the beam test on the ZEM prototype (Aug. 2000)
- Float_t pedMean = 50.;
- Float_t pedWidth = 5.;
+ printf("\t AliZDCReconstructor::GetCalibData for RUN #%d\n",runNumber);
+ //fStorage->PrintSelectionList();
+ //AliCDBEntry *entry = fStorage->Get("ZDC/Calib/Data",runNumber);
+
+ AliCDBStorage *fStorage = AliCDBManager::Instance()->GetStorage("local://DBlocal");
+ AliCDBEntry *entry = fStorage->Get("ZDC/Calib/Data",1);
+
+ AliZDCCalibData *calibda = (AliZDCCalibData*) entry->GetObject();
+ //calibda->Print("");
+
+ AliCDBManager::Instance()->Destroy();
+
+ return calibda;
- return (Int_t) gRandom->Gaus(pedMean, pedWidth);
}
////////////////////////////////////////////////
#include "AliDigitizer.h"
+#include "AliCDBManager.h"
+#include "AliCDBStorage.h"
+#include "AliZDCCalibData.h"
class AliRunDigitizer;
// Two conversion factor are needed for ADC CAEN V965
{for (Int_t i=0;i<2;i++) fADCRes[i] = adcRes[i];}
Float_t GetADCRes(Int_t i) const {return fADCRes[i];}
+
+ void GetStorage(const char* uri) {fStorage = AliCDBManager::Instance()->GetStorage(uri);}
+ AliZDCCalibData *GetCalibData(int runNumber) const;
private:
void Fragmentation(Float_t impPar, Int_t specN, Int_t specP,
Int_t Phe2ADCch(Int_t Detector, Int_t Quadrant, Float_t Light,
Int_t Res) const;
- Int_t Pedestal() const;
+ Int_t Pedestal(Int_t Detector, Int_t Quadrant, Int_t Res) const;
Float_t fPMGain[3][5]; // PM gain
Float_t fADCRes[2]; // ADC conversion factors
+
+ AliCDBStorage *fStorage; //! storage
- ClassDef(AliZDCDigitizer, 2) // digitizer for ZDC
+ ClassDef(AliZDCDigitizer, 3) // digitizer for ZDC
};
#endif
//ADC Header
if (fRawADC & 0x2000000) {
- printf("This is the ADC Header\n");
- printf("%d data words will follow \n",2*((fRawADC & 0x3f00) >> 8));
+ //printf("This is the ADC Header\n");
+ //printf("%d data words will follow \n",2*((fRawADC & 0x3f00) >> 8));
}
//ADC EOB
else if (fRawADC & 0x4000000) {
- printf("This is the ADC End Of Block\n");
- printf("This was event number %d\n",(fRawADC & 0xffffff));
- } else
+ //printf("This is the ADC End Of Block\n");
+ //printf("This was event number %d\n",(fRawADC & 0xffffff));
+ }
+ else
//ADC Data Words
{
- printf("This is an ADC Data Word\n");
- printf("Channel %d range %d\n",
- (fRawADC & 0x1e0000) >> 17, (fRawADC & 0x10000) >> 16);
- if(fRawADC & 0x1000) printf("Data = overflow\n");
+ //printf("This is an ADC Data Word\n");
+ //printf("Channel %d range %d\n",(fRawADC & 0x1e0000) >> 17, (fRawADC & 0x10000) >> 16);
+ //if(fRawADC & 0x1000) printf("Data = overflow\n");
fADCGain = (fRawADC & 0x10000) >> 16;
fADCValue = (fRawADC & 0xfff);
fIsADCDataWord = kTRUE;
#include "AliZDCRawStream.h"
#include "AliZDCReco.h"
#include "AliZDCReconstructor.h"
+#include "AliZDCCalibData.h"
ClassImp(AliZDCReconstructor)
//_____________________________________________________________________________
AliZDCReconstructor:: AliZDCReconstructor()
{
-// default constructor
+ // **** Default constructor
+ // if(!fStorage) fStorage = AliCDBManager::Instance()->GetStorage("local://DBlocal");
// --- Number of generated spectator nucleons and impact parameter
// --------------------------------------------------------------------------------------------------
- // [1] ### Results in Chiara's PhD thesis -> 0<b<15 fm (Dec 2001)
- /*// Fit results for neutrons (Nspectator n true vs. EZN)
- fZNCen = new TF1("fZNCen",
- "(-2.116909+sqrt(2.116909*2.116909-4*(-0.00651)*(14.556798-x)))/(2*(-0.00651))",0.,158.5);
- fZNPer = new TF1("fZNPer",
- "(-34.695134-sqrt(34.695134*34.695134-4*(-0.174780)*(-1562.283443-x)))/(2*(-0.174780))",0.,158.5);
- // Fit results for protons (Nspectator p true vs. EZP)
- fZPCen = new TF1("fZPCen",
- "(-1.3217+sqrt(1.3217*1.3217-4*(-0.007934)*(4.742873-x)))/(2*(-0.007934))",0.,58.91);
- fZPPer = new TF1("fZPPer",
- "(-15.788267-sqrt(15.788267*15.788267-4*(-0.133359)*(-383.800673-x)))/(2*(-0.133359))",0.,58.91);
- // Fit results for total number of spectators (Nspectators true vs. EZDC)
- fZDCCen = new TF1("fZDCCen",
- "(-1.867335+sqrt(1.867335*1.867335-4*(-0.004119)*(19.100289-x)))/(2*(-0.004119))",0.,220.4);
- fZDCPer = new TF1("fZDCPer",
- "(-22.429097-sqrt(22.429097*22.429097-4*(-0.072435)*(-1482.034526-x)))/(2*(-0.072435))",0.,220.4);*/
- // --------------------------------------------------------------------------------------------------
// [1] ### Results from a new production -> 0<b<18 fm (Apr 2002)
// Fit results for neutrons (Nspectator n true vs. EZN)
fZNCen = new TF1("fZNCen",
fZDCPer = new TF1("fZDCPer",
"(-34.380639-sqrt(34.380639*34.380639-4*(-0.104251)*(-2612.189017-x)))/(2*(-0.104251))",0.,225.);
// --------------------------------------------------------------------------------------------------
- // [1] ### Results in Chiara's PhD thesis -> 0<b<15 fm (Dec 2001)
- /*// Fit results for b (b vs. EZDC)
- //fbCen = new TF1("fbCen","0.611543+0.052231*x-0.000112*x*x+0.000000374*x*x*x",0.,222.);
- //fbPer = new TF1("fbPer","16.552010-0.023866*x-0.00001*x*x",0.,222.);
- fbCen = new TF1("fbCen","0.612769+0.051929*x-0.0001074*x*x+0.0000003724*x*x*x",0.,225.);
- fbPer = new TF1("fbPer","16.6131016-0.026053*x+0.000006893*x*x",0.,225.);*/
- // --------------------------------------------------------------------------------------------------
+ // Fit results for b (b vs. EZDC)
// [2] ### Results from a new production -> 0<b<18 fm (Apr 2002)
fbCen = new TF1("fbCen","-0.056923+0.079703*x-0.0004301*x*x+0.000001366*x*x*x",0.,220.);
fbPer = new TF1("fbPer","17.943998-0.046846*x+0.000074*x*x",0.,220.);
// --------------------------------------------------------------------------------------------------
// Evaluating Nspectators and b from ZEM energy
- // [1] ### Results in Chiara's PhD thesis -> 0<b<15 fm (Dec 2001)
- /*fZEMn = new TF1("fZEMn","124.2-0.0566*x+0.000006014*x*x",0.,3500.);
- fZEMp = new TF1("fZEMp","81.3-0.03834*x+0.000004359*x*x",0.,3500.);
- fZEMsp = new TF1("fZEMsp","205.6-0.09567*x+0.00001056*x*x",0.,3500.);
- fZEMb = new TF1("fZEMb","15.8-0.02084*x+2.802e-5*x*x-2.007e-8*x*x*x+6.586e-12*x*x*x*x-8.042e-16*x*x*x*x*x",0.,3500.);*/
- // --------------------------------------------------------------------------------------------------
// [2] ### Results from a new production -> 0<b<18 fm (Apr 2002)
fZEMn = new TF1("fZEMn","126.2-0.05399*x+0.000005679*x*x",0.,4000.);
fZEMp = new TF1("fZEMp","82.49-0.03611*x+0.00000385*x*x",0.,4000.);
//_____________________________________________________________________________
void AliZDCReconstructor::Reconstruct(AliRunLoader* runLoader) const
{
-// local ZDC reconstruction
+ // *** Local ZDC reconstruction for digits
+
+ // Get calibration data
+ int runNumber = 0;
+ AliZDCCalibData *calibda = GetCalibData(runNumber);
+
+ Float_t meanPed[47];
+ for(Int_t jj=0; jj<47; jj++) meanPed[jj] = calibda->GetMeanPed(jj);
AliLoader* loader = runLoader->GetLoader("ZDCLoader");
if (!loader) return;
treeD->SetBranchAddress("ZDC", &pdigit);
// loop over digits
- Int_t znraw=0, zpraw=0, zemraw=0;
+ Float_t zncorr=0, zpcorr=0, zemcorr=0;
for (Int_t iDigit = 0; iDigit < treeD->GetEntries(); iDigit++) {
treeD->GetEntry(iDigit);
if (!pdigit) continue;
- if(digit.GetSector(0) == 1) znraw += digit.GetADCValue(0);
- else if(digit.GetSector(0) == 2) zpraw += digit.GetADCValue(0);
- else if(digit.GetSector(0) == 3) zemraw += digit.GetADCValue(0);
+ if(digit.GetSector(0) == 1)
+ zncorr += (Float_t) (digit.GetADCValue(0)-meanPed[digit.GetSector(1)]); // ped 4 high gain ZN ADCs
+ else if(digit.GetSector(0) == 2)
+ zpcorr += (Float_t) (digit.GetADCValue(0)-meanPed[digit.GetSector(1)+10]); // ped 4 high gain ZP ADCs
+ else if(digit.GetSector(0) == 3){
+ if(digit.GetSector(1)==1) zemcorr += (Float_t) (digit.GetADCValue(0)-meanPed[digit.GetSector(1)+20]); // ped 4 high gain ZEM1 ADCs
+ else if(digit.GetSector(1)==2) zemcorr += (Float_t) (digit.GetADCValue(0)-meanPed[digit.GetSector(1)+22]); // ped 4 high gain ZEM2 ADCs
+ }
}
+ if(zncorr<0) zncorr=0;
+ if(zpcorr<0) zpcorr=0;
+ if(zemcorr<0) zemcorr=0;
// reconstruct the event
- ReconstructEvent(loader, znraw, zpraw, zemraw);
+ printf("\n \t ZDCReco from digits-> Ev.#%d ZN = %.0f, ZP = %.0f, ZEM = %.0f\n",iEvent,zncorr,zpcorr,zemcorr);
+ ReconstructEvent(loader, zncorr, zpcorr, zemcorr);
}
loader->UnloadDigits();
void AliZDCReconstructor::Reconstruct(AliRunLoader* runLoader,
AliRawReader* rawReader) const
{
-// local ZDC reconstruction for raw data
+ // *** Local ZDC reconstruction for raw data
+
+ // Calibration data
+ int runNumber = 0;
+ AliZDCCalibData *calibda = GetCalibData(runNumber);
+
+ Float_t meanPed[47];
+ for(Int_t jj=0; jj<47; jj++) meanPed[jj] = calibda->GetMeanPed(jj);
AliLoader* loader = runLoader->GetLoader("ZDCLoader");
if (!loader) return;
runLoader->GetEvent(iEvent++);
// loop over raw data digits
- Int_t znraw=0, zpraw=0, zemraw=0;
+ Float_t zncorr=0, zpcorr=0, zemcorr=0;
AliZDCRawStream digit(rawReader);
while (digit.Next()) {
if(digit.IsADCDataWord()){
if(digit.GetADCGain() == 0){
- printf("ADC value = %d\n",digit.GetADCValue());
- if(digit.GetSector(0) == 1) znraw += digit.GetADCValue();
- else if(digit.GetSector(0) == 2) zpraw += digit.GetADCValue();
- else if(digit.GetSector(0) == 3) zemraw += digit.GetADCValue();
- }
+ if(digit.GetSector(0) == 1) zncorr += (Float_t) (digit.GetADCValue()-meanPed[digit.GetSector(1)]); // pedestals for high gain ZN ADCs;
+ else if(digit.GetSector(0) == 2) zpcorr += (Float_t) (digit.GetADCValue()-meanPed[digit.GetSector(1)+10]); // pedestals for high gain ZP ADCs;
+ else if(digit.GetSector(0) == 3) zemcorr += (Float_t) (digit.GetADCValue()-meanPed[digit.GetSector(1)+20]); // pedestals for high gain ZEM ADCs;
+ }
}
}
+ if(zncorr<0) zncorr=0;
+ if(zpcorr<0) zpcorr=0;
+ if(zemcorr<0) zemcorr=0;
+
// reconstruct the event
- ReconstructEvent(loader, znraw, zpraw, zemraw);
+ printf("\n\t ZDCReco from raw-> Ev.#%d ZN = %.0f, ZP = %.0f, ZEM = %.0f\n",iEvent,zncorr,zpcorr,zemcorr);
+ ReconstructEvent(loader, zncorr, zpcorr, zemcorr);
}
loader->UnloadRecPoints();
}
//_____________________________________________________________________________
-void AliZDCReconstructor::ReconstructEvent(AliLoader* loader, Int_t znraw,
- Int_t zpraw, Int_t zemraw) const
+void AliZDCReconstructor::ReconstructEvent(AliLoader* loader, Float_t zncorr,
+ Float_t zpcorr, Float_t zemcorr) const
{
-// reconstruct one event
-
-// if AliDebug(1,Form("\n --- znraw = %d, zpraw = %d, zemraw = %d\n",znraw, zpraw, zemraw);
-
- // --- Pedestal subtraction
- Int_t zncorr, zpcorr, zemcorr, meanPed=50;
- zncorr = znraw - 5*meanPed;
- zpcorr = zpraw - 5*meanPed;
- zemcorr = zemraw - 2*meanPed;
- if(zncorr<0) zncorr=0;
- if(zpcorr<0) zpcorr=0;
- if(zemcorr<0) zemcorr=0;
-// if AliDebug(1,Form("\n zncorr = %d, zpcorr = %d, zemcorr = %d\n",zncorr,zpcorr,zemcorr);
+ // ***** Reconstruct one event
// --- ADCchannel -> photoelectrons
// NB-> PM gain = 10^(5), ADC resolution = 6.4*10^(-7)
znphe = zncorr/convFactor;
zpphe = zpcorr/convFactor;
zemphe = zemcorr/convFactor;
-// if AliDebug(1,Form("\n znphe = %f, zpphe = %f, zemphe = %f\n",znphe, zpphe, zemphe);
+ //if AliDebug(1,Form("\n znphe = %f, zpphe = %f, zemphe = %f\n",znphe, zpphe, zemphe);
// --- Energy calibration
// Conversion factors for hadronic ZDCs goes from phe yield to TRUE
zdcenergy = znenergy+zpenergy;
zemenergy = -4.81+0.3238*zemphe;
if(zemenergy<0) zemenergy=0;
-// if AliDebug(1,Form(" znenergy = %f TeV, zpenergy = %f TeV, zdcenergy = %f GeV, "
-// "\n zemenergy = %f TeV\n", znenergy, zpenergy,
-// zdcenergy, zemenergy);
+ // if AliDebug(1,Form(" znenergy = %f TeV, zpenergy = %f TeV, zdcenergy = %f GeV, "
+ // "\n zemenergy = %f TeV\n", znenergy, zpenergy,
+ // zdcenergy, zemenergy);
-// if(zdcenergy==0)
-// if AliDebug(1,Form("\n\n ### ATTENZIONE!!! -> ev# %d: znenergy = %f TeV, zpenergy = %f TeV, zdcenergy = %f GeV, "
-// " zemenergy = %f TeV\n\n", fMerger->EvNum(), znenergy, zpenergy, zdcenergy, zemenergy);
+ // if(zdcenergy==0)
+ // if AliDebug(1,Form("\n\n ### ATTENZIONE!!! -> ev# %d: znenergy = %f TeV, zpenergy = %f TeV, zdcenergy = %f GeV, "
+ // " zemenergy = %f TeV\n\n", fMerger->EvNum(), znenergy, zpenergy, zdcenergy, zemenergy);
// --- Number of incident spectator nucleons
Int_t nDetSpecN, nDetSpecP;
Int_t nGenSpecN=0, nGenSpecP=0, nGenSpec=0;
Double_t impPar=0;
// Cut value for Ezem (GeV)
- // [1] ### Results in Chiara's PhD thesis -> 0<b<15 fm (Dec 2001)
- //Float_t eZEMCut = 360.;
// [2] ### Results from a new production -> 0<b<18 fm (Apr 2002)
Float_t eZEMCut = 420.;
Float_t deltaEZEMSup = 690.;
nGenSpecP = (Int_t) (fZPCen->Eval(zpenergy));
nGenSpec = (Int_t) (fZDCCen->Eval(zdcenergy));
impPar = fbCen->Eval(zdcenergy);
- //printf(" fZNCen = %f, fZPCen = %f, fZDCCen = %f\n",fZNCen->Eval(znenergy),
- // fZPCen->Eval(zpenergy),fZDCCen->Eval(zdcenergy));
}
else if(zemenergy < (eZEMCut-deltaEZEMInf)){
nGenSpecN = (Int_t) (fZNPer->Eval(znenergy));
nGenSpecP = (Int_t) (fZPPer->Eval(zpenergy));
nGenSpec = (Int_t) (fZDCPer->Eval(zdcenergy));
impPar = fbPer->Eval(zdcenergy);
- //printf(" fZNPer = %f, fZPPer = %f, fZDCPer = %f\n",fZNPer->Eval(znenergy),
- // fZPPer->Eval(zpenergy),fZDCPer->Eval(zdcenergy));
}
else if(zemenergy >= (eZEMCut-deltaEZEMInf) && zemenergy <= (eZEMCut+deltaEZEMSup)){
nGenSpecN = (Int_t) (fZEMn->Eval(zemenergy));
nGenSpecP = (Int_t) (fZEMp->Eval(zemenergy));
nGenSpec = (Int_t)(fZEMsp->Eval(zemenergy));
impPar = fZEMb->Eval(zemenergy);
- //printf(" Nspec ZEM = %f, Nspec ZDC = %f\n",fZEMsp->Eval(znenergy),fZDCPer->Eval(zdcenergy));
}
- // [1] ### Results in Chiara's PhD thesis -> 0<b<15 fm (Dec 2001)
- /*if(znenergy>158.5) nGenSpecN = (Int_t) (fZEMn->Eval(zemenergy));
- if(zpenergy>58.91) nGenSpecP = (Int_t) (fZEMp->Eval(zemenergy));
- if(zdcenergy>220.4) nGenSpec = (Int_t)(fZEMsp->Eval(zemenergy));
- if(zdcenergy>225.) impPar = fZEMb->Eval(zemenergy);*/
// [2] ### Results from a new production -> 0<b<18 fm (Apr 2002)
if(znenergy>162.) nGenSpecN = (Int_t) (fZEMn->Eval(zemenergy));
if(zpenergy>59.75) nGenSpecP = (Int_t) (fZEMp->Eval(zemenergy));
else if(nGenSpecP<0) nGenSpecP=0;
if(nGenSpec>207) nGenSpec=207;
else if(nGenSpec<0) nGenSpec=0;
- //printf(" NRecSpecN = %d, NRecSpecP = %d, NRecSpec = %d\n",nGenSpecN,nGenSpecP,nGenSpec);
// --- Number of participants
Int_t nPart, nPartTot;
nPart = 207-nGenSpecN-nGenSpecP;
nPartTot = 207-nGenSpec;
- //printf(" ### nPart(ZP+ZN) = %d, nPart(ZDC) = %d, b = %f fm\n",nPart,nPartTot,impPar);
-// if AliDebug(1,Form(" ### nPart = %d, b = %f fm\n",nPartTot,impPar);
+ printf("\t ZDCeventReco-> ZNEn = %.0f GeV, ZPEn = %.0f GeV, ZEMEn = %.0f GeV\n",
+ znenergy, zpenergy, zemenergy);
// create the output tree
loader->MakeTree("R");
loader->UnloadRecPoints();
}
+
+//_____________________________________________________________________________
+AliZDCCalibData* AliZDCReconstructor::GetCalibData(int runNumber) const
+{
+
+ //printf("\n\t AliZDCReconstructor::GetCalibData \n");
+ //fStorage->PrintSelectionList();
+ //AliCDBEntry *entry = fStorage->Get("DBlocal/ZDC/Calib/Data",runNumber);
+
+
+ AliCDBStorage *fStorage = AliCDBManager::Instance()->GetStorage("local://DBlocal");
+ AliCDBEntry *entry = fStorage->Get("ZDC/Calib/Data",1);
+
+ AliZDCCalibData *calibda = (AliZDCCalibData*) entry->GetObject();
+
+ AliCDBManager::Instance()->Destroy();
+
+ return calibda;
+
+}
///////////////////////////////////////////////////////////////////////////////
#include "AliReconstructor.h"
+#include "AliCDBManager.h"
+#include "AliCDBStorage.h"
+#include "AliZDCCalibData.h"
class TF1;
class AliLoader;
-
class AliZDCReconstructor: public AliReconstructor {
public:
AliZDCReconstructor();
virtual ~AliZDCReconstructor();
- virtual void Reconstruct(AliRunLoader* runLoader) const;
- virtual void Reconstruct(AliRunLoader* runLoader,
- AliRawReader* rawReader) const;
- virtual void Reconstruct(TTree* digitsTree, TTree* clustersTree) const { AliReconstructor::Reconstruct(digitsTree,clustersTree);}
- virtual void Reconstruct(AliRawReader* rawReader, TTree* clustersTree) const {AliReconstructor::Reconstruct(rawReader,clustersTree);}
- virtual void FillESD(AliRunLoader* runLoader, AliESD* esd) const;
- virtual void FillESD(TTree* digitsTree, TTree* clustersTree,
- AliESD* esd) const {
- AliReconstructor::FillESD(digitsTree,clustersTree,esd);
- }
- virtual void FillESD(AliRawReader* rawReader, TTree* clustersTree,
- AliESD* esd) const {
- AliReconstructor::FillESD(rawReader,clustersTree,esd);
- }
- virtual void FillESD(AliRunLoader* runLoader,
- AliRawReader* rawReader, AliESD* esd) const {
- AliReconstructor::FillESD(runLoader,rawReader,esd);
- }
+ virtual void Reconstruct(AliRunLoader* runLoader) const;
+ virtual void Reconstruct(AliRunLoader* runLoader,
+ AliRawReader* rawReader) const;
+ virtual void Reconstruct(TTree* digitsTree, TTree* clustersTree) const
+ {AliReconstructor::Reconstruct(digitsTree,clustersTree);}
+ virtual void Reconstruct(AliRawReader* rawReader, TTree* clustersTree) const
+ {AliReconstructor::Reconstruct(rawReader,clustersTree);}
+ virtual void FillESD(AliRunLoader* runLoader, AliESD* esd) const;
+ virtual void FillESD(TTree* digitsTree, TTree* clustersTree, AliESD* esd) const
+ {AliReconstructor::FillESD(digitsTree,clustersTree,esd);}
+ virtual void FillESD(AliRawReader* rawReader, TTree* clustersTree, AliESD* esd) const
+ {AliReconstructor::FillESD(rawReader,clustersTree,esd);}
+ virtual void FillESD(AliRunLoader* runLoader, AliRawReader* rawReader, AliESD* esd) const
+ {AliReconstructor::FillESD(runLoader,rawReader,esd);}
+
+ void GetStorage(const char* uri) {fStorage = AliCDBManager::Instance()->GetStorage(uri);}
+ AliZDCCalibData *GetCalibData(int runNumber) const;
private:
AliZDCReconstructor(const AliZDCReconstructor& reconstructor);
AliZDCReconstructor& operator = (const AliZDCReconstructor& reconstructor);
- void ReconstructEvent(AliLoader* loader, Int_t znraw,
- Int_t zpraw, Int_t zemraw) const;
+ void ReconstructEvent(AliLoader* loader, Float_t zncorr, Float_t zpcorr, Float_t zemcorr) const;
TF1* fZNCen; //! Nspectator n true vs. EZN
TF1* fZNPer; //! Nspectator n true vs. EZN
TF1* fZEMp; //! Nspectators p from ZEM energy
TF1* fZEMsp; //! Nspectators from ZEM energy
TF1* fZEMb; //! b from ZEM energy
+
+ AliCDBStorage *fStorage; //! storage
- ClassDef(AliZDCReconstructor, 0) // class for the ZDC reconstruction
+ ClassDef(AliZDCReconstructor, 1) // class for the ZDC reconstruction
};
#endif
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff