Coding conventions
[u/mrichter/AliRoot.git] / ZDC / AliZDCReconstructor.cxx
CommitLineData
8309c1ab 1/**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
6 * *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
f5d41205 13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
15
16/* $Id$ */
17
18///////////////////////////////////////////////////////////////////////////////
19// //
73bc3a3f 20// ************** Class for ZDC reconstruction ************** //
21// Author: Chiara.Oppedisano@to.infn.it //
22// //
23// NOTATIONS ADOPTED TO IDENTIFY DETECTORS (used in different ages!): //
24// (ZN1,ZP1) or (ZNC, ZPC) or RIGHT refers to side C (RB26) //
25// (ZN2,ZP2) or (ZNA, ZPA) or LEFT refers to side A (RB24) //
f5d41205 26// //
27///////////////////////////////////////////////////////////////////////////////
28
29
73bc3a3f 30#include <TH2F.h>
31#include <TH1D.h>
32#include <TAxis.h>
fd9afd60 33#include <TMap.h>
f5d41205 34
f5d41205 35#include "AliRawReader.h"
fd9afd60 36#include "AliGRPObject.h"
f5d41205 37#include "AliESDEvent.h"
a85132e7 38#include "AliESDZDC.h"
f5d41205 39#include "AliZDCDigit.h"
40#include "AliZDCRawStream.h"
41#include "AliZDCReco.h"
42#include "AliZDCReconstructor.h"
6024ec85 43#include "AliZDCPedestals.h"
73bc3a3f 44#include "AliZDCEnCalib.h"
45#include "AliZDCTowerCalib.h"
7bff3766 46#include "AliZDCRecoParam.h"
47#include "AliZDCRecoParampp.h"
48#include "AliZDCRecoParamPbPb.h"
4a72fbdb 49#include "AliRunInfo.h"
f5d41205 50
51
52ClassImp(AliZDCReconstructor)
7bff3766 53AliZDCRecoParam *AliZDCReconstructor::fRecoParam=0; //reconstruction parameters
f5d41205 54
55//_____________________________________________________________________________
56AliZDCReconstructor:: AliZDCReconstructor() :
1e319f71 57 fPedData(GetPedestalData()),
58 fEnCalibData(GetEnergyCalibData()),
59 fTowCalibData(GetTowerCalibData()),
fd9afd60 60 fRecoMode(0),
42d8b8d5 61 fBeamEnergy(0.),
73bc3a3f 62 fNRun(0),
63 fIsCalibrationMB(kFALSE),
64 fPedSubMode(0),
12434381 65 fSignalThreshold(7)
f5d41205 66{
67 // **** Default constructor
68
69}
70
71
72//_____________________________________________________________________________
73AliZDCReconstructor::~AliZDCReconstructor()
74{
75// destructor
4a72fbdb 76// if(fRecoParam) delete fRecoParam;
73bc3a3f 77 if(fPedData) delete fPedData;
78 if(fEnCalibData) delete fEnCalibData;
79 if(fTowCalibData) delete fTowCalibData;
f5d41205 80}
81
fd9afd60 82//____________________________________________________________________________
73bc3a3f 83void AliZDCReconstructor::Init()
fd9afd60 84{
85 // Setting reconstruction mode
73bc3a3f 86 // Getting beam type and beam energy from GRP calibration object
87
4a72fbdb 88 TString runType = GetRunInfo()->GetRunType();
89
90 if((runType.CompareTo("CALIBRATION_MB")) == 0){
91 fIsCalibrationMB = kTRUE;
92 }
73bc3a3f 93
4a72fbdb 94 TString beamType = GetRunInfo()->GetBeamType();
95 // This is a temporary solution to allow reconstruction in tests without beam
96 if(((beamType.CompareTo("UNKNOWN"))==0) && ((runType.CompareTo("PHYSICS")) == 0)){
97 fRecoMode=1;
98 }
99 else if(beamType==AliGRPObject::GetInvalidString()){
100 AliWarning("GRP/GRP/Data entry: missing value for the beam type !");
101 AliError("\t ZDC does not reconstruct event 4 UNKNOWN beam type\n");
102 return;
103 }
104
105 if(((beamType.CompareTo("pp"))==0) || ((beamType.CompareTo("p-p"))==0)
45c8ebf5 106 ||((beamType.CompareTo("PP"))==0) || ((beamType.CompareTo("P-P"))==0)) fRecoMode=1;
4a72fbdb 107 else if((beamType.CompareTo("A-A")) == 0){
108 fRecoMode=2;
109 if(fIsCalibrationMB == kTRUE){
110 fRecoParam = new AliZDCRecoParamPbPb();
111 //
112 TH2F* hZDCvsZEM = new TH2F("hZDCvsZEM","hZDCvsZEM",100,0.,10.,100,0.,1000.);
113 hZDCvsZEM->SetXTitle("E_{ZEM} (TeV)"); hZDCvsZEM->SetYTitle("E_{ZDC} (TeV)");
114 fRecoParam->SetZDCvsZEM(hZDCvsZEM);
115 //
116 TH2F* hZDCCvsZEM = new TH2F("hZDCCvsZEM","hZDCCvsZEM",100,0.,10.,100,0.,500.);
117 hZDCCvsZEM->SetXTitle("E_{ZEM} (TeV)"); hZDCCvsZEM->SetYTitle("E_{ZDCC} (TeV)");
118 fRecoParam->SetZDCCvsZEM(hZDCCvsZEM);
119 //
120 TH2F* hZDCAvsZEM = new TH2F("hZDCAvsZEM","hZDCAvsZEM",100,0.,10.,100,0.,500.);
121 hZDCAvsZEM->SetXTitle("E_{ZEM} (TeV)"); hZDCAvsZEM->SetYTitle("E_{ZDCA} (TeV)");
122 fRecoParam->SetZDCAvsZEM(hZDCAvsZEM);
123 //
124 AliInfo("\n ***** CALIBRATION_MB data -> building AliZDCRecoParamPbPb object *****");
73bc3a3f 125 }
fd9afd60 126 }
4a72fbdb 127
128 fBeamEnergy = GetRunInfo()->GetBeamEnergy();
129 if(fBeamEnergy==AliGRPObject::GetInvalidFloat()){
130 AliWarning("GRP/GRP/Data entry: missing value for the beam energy ! Using 0.");
131 fBeamEnergy = 0.;
fd9afd60 132 }
4a72fbdb 133
134 if(fIsCalibrationMB==kFALSE)
135 printf("\n\n ***** ZDC reconstruction initialized for %s @ %1.0f GeV *****\n\n",beamType.Data(), fBeamEnergy);
fd9afd60 136
fd9afd60 137}
138
f5d41205 139//_____________________________________________________________________________
1e319f71 140void AliZDCReconstructor::Reconstruct(TTree* digitsTree, TTree* clustersTree) const
f5d41205 141{
142 // *** Local ZDC reconstruction for digits
143 // Works on the current event
144
145 // Retrieving calibration data
42d8b8d5 146 // Parameters for mean value pedestal subtraction
73bc3a3f 147 int const kNch = 24;
148 Float_t meanPed[2*kNch];
149 for(Int_t jj=0; jj<2*kNch; jj++) meanPed[jj] = fPedData->GetMeanPed(jj);
42d8b8d5 150 // Parameters pedestal subtraction through correlation with out-of-time signals
73bc3a3f 151 Float_t corrCoeff0[2*kNch], corrCoeff1[2*kNch];
152 for(Int_t jj=0; jj<2*kNch; jj++){
42d8b8d5 153 corrCoeff0[jj] = fPedData->GetPedCorrCoeff0(jj);
154 corrCoeff1[jj] = fPedData->GetPedCorrCoeff1(jj);
155 }
f5d41205 156
157 // get digits
158 AliZDCDigit digit;
159 AliZDCDigit* pdigit = &digit;
160 digitsTree->SetBranchAddress("ZDC", &pdigit);
c35ed519 161 //printf("\n\t # of digits in tree: %d\n",(Int_t) digitsTree->GetEntries());
f5d41205 162
163 // loop over digits
c35ed519 164 Float_t tZN1Corr[10], tZP1Corr[10], tZN2Corr[10], tZP2Corr[10];
73bc3a3f 165 Float_t dZEM1Corr[2], dZEM2Corr[2], sPMRef1[2], sPMRef2[2];
c35ed519 166 for(Int_t i=0; i<10; i++){
167 tZN1Corr[i] = tZP1Corr[i] = tZN2Corr[i] = tZP2Corr[i] = 0.;
73bc3a3f 168 if(i<2) dZEM1Corr[i] = dZEM2Corr[i] = sPMRef1[i] = sPMRef2[i] = 0.;
c35ed519 169 }
42d8b8d5 170
171 Int_t digNentries = digitsTree->GetEntries();
42d8b8d5 172 Float_t ootDigi[kNch];
173 // -- Reading out-of-time signals (last kNch entries) for current event
174 if(fPedSubMode==1){
175 for(Int_t iDigit=kNch; iDigit<digNentries; iDigit++){
176 ootDigi[iDigit] = digitsTree->GetEntry(iDigit);
177 }
178 }
179
180 for(Int_t iDigit=0; iDigit<(digNentries/2); iDigit++) {
a85132e7 181 digitsTree->GetEntry(iDigit);
182 if (!pdigit) continue;
a85132e7 183 //
184 Int_t det = digit.GetSector(0);
185 Int_t quad = digit.GetSector(1);
42d8b8d5 186 Int_t pedindex = -1;
187 Float_t ped2SubHg=0., ped2SubLg=0.;
188 if(quad!=5){
189 if(det==1) pedindex = quad;
190 else if(det==2) pedindex = quad+5;
191 else if(det==3) pedindex = quad+9;
192 else if(det==4) pedindex = quad+12;
193 else if(det==5) pedindex = quad+17;
194 }
195 else pedindex = (det-1)/3+22;
a85132e7 196 //
42d8b8d5 197 if(fPedSubMode==0){
198 ped2SubHg = meanPed[pedindex];
199 ped2SubLg = meanPed[pedindex+kNch];
200 }
201 else if(fPedSubMode==1){
202 ped2SubHg = corrCoeff1[pedindex]*ootDigi[pedindex]+corrCoeff0[pedindex];
203 ped2SubLg = corrCoeff1[pedindex+kNch]*ootDigi[pedindex+kNch]+corrCoeff0[pedindex+kNch];
204 }
42d8b8d5 205
a85132e7 206 if(quad != 5){ // ZDC (not reference PTMs!)
c35ed519 207 if(det == 1){ // *** ZNC
42d8b8d5 208 tZN1Corr[quad] = (Float_t) (digit.GetADCValue(0)-ped2SubHg);
209 tZN1Corr[quad+5] = (Float_t) (digit.GetADCValue(1)-ped2SubLg);
c35ed519 210 if(tZN1Corr[quad]<0.) tZN1Corr[quad] = 0.;
58dd32ca 211 if(tZN1Corr[quad+5]<0.) tZN1Corr[quad+5] = 0.;
73bc3a3f 212 // Ch. debug
c35ed519 213 //printf("\t pedindex %d tZN1Corr[%d] = %1.0f tZN1Corr[%d] = %1.0f",
214 // pedindex, quad, tZN1Corr[quad], quad+5, tZN1Corr[quad+5]);
f5d41205 215 }
216 else if(det == 2){ // *** ZP1
42d8b8d5 217 tZP1Corr[quad] = (Float_t) (digit.GetADCValue(0)-ped2SubHg);
42d8b8d5 218 tZP1Corr[quad+5] = (Float_t) (digit.GetADCValue(1)-ped2SubLg);
73bc3a3f 219 if(tZP1Corr[quad]<0.) tZP1Corr[quad] = 0.;
58dd32ca 220 if(tZP1Corr[quad+5]<0.) tZP1Corr[quad+5] = 0.;
73bc3a3f 221 // Ch. debug
c35ed519 222 //printf("\t pedindex %d tZP1Corr[%d] = %1.0f tZP1Corr[%d] = %1.0f",
223 // pedindex, quad, tZP1Corr[quad], quad+5, tZP1Corr[quad+5]);
f5d41205 224 }
225 else if(det == 3){
226 if(quad == 1){ // *** ZEM1
42d8b8d5 227 dZEM1Corr[0] += (Float_t) (digit.GetADCValue(0)-ped2SubHg);
42d8b8d5 228 dZEM1Corr[1] += (Float_t) (digit.GetADCValue(1)-ped2SubLg);
73bc3a3f 229 if(dZEM1Corr[0]<0.) dZEM1Corr[0] = 0.;
c35ed519 230 if(dZEM1Corr[1]<0.) dZEM1Corr[1] = 0.;
73bc3a3f 231 // Ch. debug
c35ed519 232 //printf("\t pedindex %d tZEM1Corr[%d] = %1.0f tZEM1Corr[%d] = %1.0f",
233 // pedindex, quad, tZEM1Corr[quad], quad+1, tZEM1Corr[quad+1]);
f5d41205 234 }
a85132e7 235 else if(quad == 2){ // *** ZEM2
42d8b8d5 236 dZEM2Corr[0] += (Float_t) (digit.GetADCValue(0)-ped2SubHg);
42d8b8d5 237 dZEM2Corr[1] += (Float_t) (digit.GetADCValue(1)-ped2SubLg);
73bc3a3f 238 if(dZEM2Corr[0]<0.) dZEM2Corr[0] = 0.;
c35ed519 239 if(dZEM2Corr[1]<0.) dZEM2Corr[1] = 0.;
73bc3a3f 240 // Ch. debug
c35ed519 241 //printf("\t pedindex %d tZEM2Corr[%d] = %1.0f tZEM2Corr[%d] = %1.0f",
242 // pedindex, quad, tZEM2Corr[quad], quad+1, tZEM2Corr[quad+1]);
f5d41205 243 }
244 }
245 else if(det == 4){ // *** ZN2
42d8b8d5 246 tZN2Corr[quad] = (Float_t) (digit.GetADCValue(0)-ped2SubHg);
42d8b8d5 247 tZN2Corr[quad+5] = (Float_t) (digit.GetADCValue(1)-ped2SubLg);
73bc3a3f 248 if(tZN2Corr[quad]<0.) tZN2Corr[quad] = 0.;
c35ed519 249 if(tZN2Corr[quad+5]<0.) tZN2Corr[quad+5] = 0.;
73bc3a3f 250 // Ch. debug
c35ed519 251 //printf("\t pedindex %d tZN2Corr[%d] = %1.0f tZN2Corr[%d] = %1.0f\n",
252 // pedindex, quad, tZN2Corr[quad], quad+5, tZN2Corr[quad+5]);
f5d41205 253 }
254 else if(det == 5){ // *** ZP2
42d8b8d5 255 tZP2Corr[quad] = (Float_t) (digit.GetADCValue(0)-ped2SubHg);
42d8b8d5 256 tZP2Corr[quad+5] = (Float_t) (digit.GetADCValue(1)-ped2SubLg);
73bc3a3f 257 if(tZP2Corr[quad]<0.) tZP2Corr[quad] = 0.;
c35ed519 258 if(tZP2Corr[quad+5]<0.) tZP2Corr[quad+5] = 0.;
73bc3a3f 259 // Ch. debug
c35ed519 260 //printf("\t pedindex %d tZP2Corr[%d] = %1.0f tZP2Corr[%d] = %1.0f\n",
261 // pedindex, quad, tZP2Corr[quad], quad+5, tZP2Corr[quad+5]);
f5d41205 262 }
a85132e7 263 }
c35ed519 264 else{ // Reference PMs
c35ed519 265 if(det == 1){
73bc3a3f 266 sPMRef1[0] = (Float_t) (digit.GetADCValue(0)-ped2SubHg);
267 sPMRef1[1] = (Float_t) (digit.GetADCValue(1)-ped2SubLg);
268 // Ch. debug
269 if(sPMRef1[0]<0.) sPMRef1[0] = 0.;
270 if(sPMRef2[1]<0.) sPMRef1[1] = 0.;
c35ed519 271 }
272 else if(det == 4){
73bc3a3f 273 sPMRef2[0] = (Float_t) (digit.GetADCValue(0)-ped2SubHg);
274 sPMRef2[1] = (Float_t) (digit.GetADCValue(1)-ped2SubLg);
275 // Ch. debug
276 if(sPMRef2[0]<0.) sPMRef2[0] = 0.;
277 if(sPMRef2[1]<0.) sPMRef2[1] = 0.;
c35ed519 278 }
279 }
f5d41205 280
73bc3a3f 281 // Ch. debug
282 /*printf(" - AliZDCReconstructor -> digit #%d det %d quad %d pedHG %1.0f pedLG %1.0f\n",
283 iDigit, det, quad, ped2SubHg, ped2SubLg);
284 printf(" HGChain -> RawDig %d DigCorr %1.2f\n", digit.GetADCValue(0), digit.GetADCValue(0)-ped2SubHg);
285 printf(" LGChain -> RawDig %d DigCorr %1.2f\n", digit.GetADCValue(1), digit.GetADCValue(1)-ped2SubLg);
286 */
287 }//digits loop
58671297 288
73bc3a3f 289
290 // If CALIBRATION_MB run build the RecoParam object
291 if(fIsCalibrationMB){
292 Float_t ZDCC=0., ZDCA=0., ZEM=0;
293 ZEM += dZEM1Corr[0] + dZEM2Corr[0];
294 for(Int_t jkl=0; jkl<5; jkl++){
295 ZDCC += tZN1Corr[jkl] + tZP1Corr[jkl];
296 ZDCA += tZN2Corr[jkl] + tZP2Corr[jkl];
297 }
298 // Using energies in TeV in fRecoParam object
1e319f71 299 BuildRecoParam(ZDCC/1000., ZDCA/1000., ZEM/1000.);
73bc3a3f 300 }
1e319f71 301 Bool_t recFlag1 = kFALSE, recFlag2 = kFALSE, recFlag3 = kFALSE;
69550cf5 302 // reconstruct the event
73bc3a3f 303 if(fRecoMode==1)
fd9afd60 304 ReconstructEventpp(clustersTree, tZN1Corr, tZP1Corr, tZN2Corr, tZP2Corr,
1e319f71 305 dZEM1Corr, dZEM2Corr, sPMRef1, sPMRef2, recFlag1, recFlag2, recFlag3);
73bc3a3f 306 else if(fRecoMode==2)
fd9afd60 307 ReconstructEventPbPb(clustersTree, tZN1Corr, tZP1Corr, tZN2Corr, tZP2Corr,
1e319f71 308 dZEM1Corr, dZEM2Corr, sPMRef1, sPMRef2, recFlag1, recFlag2, recFlag3);
f5d41205 309}
310
311//_____________________________________________________________________________
1e319f71 312void AliZDCReconstructor::Reconstruct(AliRawReader* rawReader, TTree* clustersTree) const
f5d41205 313{
314 // *** ZDC raw data reconstruction
315 // Works on the current event
316
317 // Retrieving calibration data
73bc3a3f 318 // Parameters for pedestal subtraction
319 int const kNch = 24;
320 Float_t meanPed[2*kNch];
321 for(Int_t jj=0; jj<2*kNch; jj++) meanPed[jj] = fPedData->GetMeanPed(jj);
42d8b8d5 322 // Parameters pedestal subtraction through correlation with out-of-time signals
73bc3a3f 323 Float_t corrCoeff0[2*kNch], corrCoeff1[2*kNch];
324 for(Int_t jj=0; jj<2*kNch; jj++){
42d8b8d5 325 corrCoeff0[jj] = fPedData->GetPedCorrCoeff0(jj);
326 corrCoeff1[jj] = fPedData->GetPedCorrCoeff1(jj);
327 }
f5d41205 328
73bc3a3f 329 Int_t adcZN1[5], adcZN1oot[5], adcZN1lg[5], adcZN1ootlg[5];
330 Int_t adcZP1[5], adcZP1oot[5], adcZP1lg[5], adcZP1ootlg[5];
331 Int_t adcZN2[5], adcZN2oot[5], adcZN2lg[5], adcZN2ootlg[5];
332 Int_t adcZP2[5], adcZP2oot[5], adcZP2lg[5], adcZP2ootlg[5];
333 Int_t adcZEM[2], adcZEMoot[2], adcZEMlg[2], adcZEMootlg[2];
334 Int_t pmRef[2], pmRefoot[2], pmReflg[2], pmRefootlg[2];
335 for(Int_t ich=0; ich<5; ich++){
336 adcZN1[ich] = adcZN1oot[ich] = adcZN1lg[ich] = adcZN1ootlg[ich] = 0;
337 adcZP1[ich] = adcZP1oot[ich] = adcZP1lg[ich] = adcZP1ootlg[ich] = 0;
338 adcZN2[ich] = adcZN2oot[ich] = adcZN2lg[ich] = adcZN2ootlg[ich] = 0;
339 adcZP2[ich] = adcZP2oot[ich] = adcZP2lg[ich] = adcZP2ootlg[ich] = 0;
340 if(ich<2){
341 adcZEM[ich] = adcZEMoot[ich] = adcZEMlg[ich] = adcZEMootlg[ich] = 0;
342 pmRef[ich] = pmRefoot[ich] = pmReflg[ich] = pmRefootlg[ich] = 0;
343 }
344 }
7bff3766 345
c35ed519 346 // loop over raw data
347 Float_t tZN1Corr[10], tZP1Corr[10], tZN2Corr[10], tZP2Corr[10];
73bc3a3f 348 Float_t dZEM1Corr[2], dZEM2Corr[2], sPMRef1[2], sPMRef2[2];
c35ed519 349 for(Int_t i=0; i<10; i++){
350 tZN1Corr[i] = tZP1Corr[i] = tZN2Corr[i] = tZP2Corr[i] = 0.;
73bc3a3f 351 if(i<2) dZEM1Corr[i] = dZEM2Corr[i] = sPMRef1[i] = sPMRef2[i] = 0.;
c35ed519 352 }
1e319f71 353
354 //fNRun = (Int_t) rawReader->GetRunNumber();
f70a5526 355 Bool_t chOff=kFALSE, isUndflw=kFALSE, isOvflw=kFALSE, isADCEvGood=kFALSE;
356 Int_t kFirstADCGeo=0, kLastADCGeo=3, kScalerGeo=8, kPUGeo=29, kTrigScales=30, kTrigHistory=31;
f5d41205 357 //
73bc3a3f 358 rawReader->Reset();
f5d41205 359 AliZDCRawStream rawData(rawReader);
73bc3a3f 360 while(rawData.Next()){
f70a5526 361 //if(rawData.IsCalibration() == kFALSE){ // Reading ADCs
362 if((rawData.GetADCModule()>=kFirstADCGeo) && (rawData.GetADCModule()<=kLastADCGeo)){
363 //printf(" **** Reading ADC raw data from module %d **** \n",rawData.GetADCModule());
58671297 364 //
f70a5526 365 if((rawData.IsADCDataWord()) && (rawData.GetNChannelsOn()<48)) chOff = kTRUE;
366 if((rawData.IsADCDataWord()) && (rawData.IsOverflow() == kTRUE)) isUndflw = kTRUE;
367 if((rawData.IsADCDataWord()) && (rawData.IsUnderflow() == kTRUE)) isOvflw = kTRUE;
368 if((rawData.IsADCDataWord()) && (rawData.IsADCEventGood() == kTRUE)) isADCEvGood = kTRUE;
369
370 if((rawData.IsADCDataWord()) && (isUndflw==kFALSE)
371 && (isOvflw==kFALSE) && (isADCEvGood==kTRUE)){
73bc3a3f 372
58671297 373 Int_t adcMod = rawData.GetADCModule();
374 Int_t det = rawData.GetSector(0);
375 Int_t quad = rawData.GetSector(1);
376 Int_t gain = rawData.GetADCGain();
377 Int_t pedindex=0;
378 //
379 // Mean pedestal value subtraction -------------------------------------------------------
380 if(fPedSubMode == 0){
73bc3a3f 381 // Not interested in o.o.t. signals (ADC modules 2, 3)
1e319f71 382 if(adcMod == 2 || adcMod == 3) continue;
73bc3a3f 383 //
384 if(quad != 5){ // ZDCs (not reference PTMs)
385 if(det == 1){
386 pedindex = quad;
387 if(gain == 0) tZN1Corr[quad] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]);
388 else tZN1Corr[quad+5] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex+kNch]);
f5d41205 389 }
73bc3a3f 390 else if(det == 2){
391 pedindex = quad+5;
392 if(gain == 0) tZP1Corr[quad] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]);
393 else tZP1Corr[quad+5] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex+kNch]);
394 }
395 else if(det == 3){
396 pedindex = quad+9;
397 if(quad==1){
398 if(gain == 0) dZEM1Corr[0] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]);
399 else dZEM1Corr[1] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex+kNch]);
400 }
401 else if(quad==2){
402 if(gain == 0) dZEM2Corr[0] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]);
403 else dZEM2Corr[1] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex+kNch]);
404 }
405 }
406 else if(det == 4){
407 pedindex = quad+12;
408 if(gain == 0) tZN2Corr[quad] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]);
409 else tZN2Corr[quad+5] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex+kNch]);
410 }
411 else if(det == 5){
412 pedindex = quad+17;
413 if(gain == 0) tZP2Corr[quad] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]);
414 else tZP2Corr[quad+5] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex+kNch]);
f5d41205 415 }
c35ed519 416 }
73bc3a3f 417 else{ // reference PM
418 pedindex = (det-1)/3 + 22;
419 if(det == 1){
420 if(gain==0) sPMRef1[0] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]);
421 else sPMRef1[1] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]);
422 }
423 else if(det == 4){
424 if(gain==0) sPMRef2[0] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]);
425 else sPMRef2[1] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]);
426 }
c35ed519 427 }
73bc3a3f 428 // Ch. debug
429 /*printf(" -> AliZDCReconstructor: det %d quad %d res %d -> Pedestal[%d] %1.0f\n",
430 det,quad,gain, pedindex, meanPed[pedindex]);
431 printf(" -> AliZDCReconstructor: RawADC %1.0f ADCCorr %1.0f\n",
432 rawData.GetADCValue(), rawData.GetADCValue()-meanPed[pedindex]);*/
433
58671297 434 }// mean pedestal subtraction
435 // Pedestal subtraction from correlation ------------------------------------------------
436 else if(fPedSubMode == 1){
73bc3a3f 437 // In time signals
438 if(adcMod==0 || adcMod==1){
439 if(quad != 5){ // signals from ZDCs
440 if(det == 1){
441 if(gain==0) adcZN1[quad] = rawData.GetADCValue();
442 else adcZN1lg[quad] = rawData.GetADCValue();
443 }
444 else if(det == 2){
445 if(gain==0) adcZP1[quad] = rawData.GetADCValue();
446 else adcZP1lg[quad] = rawData.GetADCValue();
447 }
448 else if(det == 3){
449 if(gain==0) adcZEM[quad-1] = rawData.GetADCValue();
450 else adcZEMlg[quad-1] = rawData.GetADCValue();
451 }
452 else if(det == 4){
453 if(gain==0) adcZN2[quad] = rawData.GetADCValue();
454 else adcZN2lg[quad] = rawData.GetADCValue();
455 }
456 else if(det == 5){
457 if(gain==0) adcZP2[quad] = rawData.GetADCValue();
458 else adcZP2lg[quad] = rawData.GetADCValue();
459 }
460 }
461 else{ // signals from reference PM
462 if(gain==0) pmRef[quad-1] = rawData.GetADCValue();
463 else pmReflg[quad-1] = rawData.GetADCValue();
464 }
465 }
466 // Out-of-time pedestals
467 else if(adcMod==2 || adcMod==3){
468 if(quad != 5){ // signals from ZDCs
469 if(det == 1){
470 if(gain==0) adcZN1oot[quad] = rawData.GetADCValue();
471 else adcZN1ootlg[quad] = rawData.GetADCValue();
472 }
473 else if(det == 2){
474 if(gain==0) adcZP1oot[quad] = rawData.GetADCValue();
475 else adcZP1ootlg[quad] = rawData.GetADCValue();
476 }
477 else if(det == 3){
478 if(gain==0) adcZEMoot[quad-1] = rawData.GetADCValue();
479 else adcZEMootlg[quad-1] = rawData.GetADCValue();
480 }
481 else if(det == 4){
482 if(gain==0) adcZN2oot[quad] = rawData.GetADCValue();
483 else adcZN2ootlg[quad] = rawData.GetADCValue();
484 }
485 else if(det == 5){
486 if(gain==0) adcZP2oot[quad] = rawData.GetADCValue();
487 else adcZP2ootlg[quad] = rawData.GetADCValue();
488 }
489 }
490 else{ // signals from reference PM
491 if(gain==0) pmRefoot[quad-1] = rawData.GetADCValue();
492 else pmRefootlg[quad-1] = rawData.GetADCValue();
493 }
494 }
58671297 495 } // pedestal subtraction from correlation
496 // Ch. debug
497 //printf("\t AliZDCReconstructor - det %d quad %d res %d -> Ped[%d] = %1.0f\n",
498 // det,quad,gain, pedindex, meanPed[pedindex]);
499 }//IsADCDataWord
500 }// Not raw data from calibration run!
501 else{
502 }
73bc3a3f 503 }//loop on raw data
504
505 if(fPedSubMode==1){
506 for(Int_t t=0; t<5; t++){
507 tZN1Corr[t] = adcZN1[t] - (corrCoeff1[t]*adcZN1oot[t]+corrCoeff0[t]);
508 tZN1Corr[t+5] = adcZN1lg[t] - (corrCoeff1[t+kNch]*adcZN1ootlg[t]+corrCoeff0[t+kNch]);
509 //
510 tZP1Corr[t] = adcZP1[t] - (corrCoeff1[t+5]*adcZP1oot[t]+corrCoeff0[t+5]);
511 tZP1Corr[t+5] = adcZP1lg[t] - (corrCoeff1[t+5+kNch]*adcZP1ootlg[t]+corrCoeff0[t+5+kNch]);
512 //
513 tZN2Corr[t] = adcZN2[t] - (corrCoeff1[t+12]*adcZN2oot[t]+corrCoeff0[t+12]);
514 tZN2Corr[t+5] = adcZN2lg[t] - (corrCoeff1[t+12+kNch]*adcZN2ootlg[t]+corrCoeff0[t+12+kNch]);
515 //
516 tZP2Corr[t] = adcZP2[t] - (corrCoeff1[t+17]*adcZP2oot[t]+corrCoeff0[t+17]);
517 tZP2Corr[t+5] = adcZP2lg[t] - (corrCoeff1[t+17+kNch]*adcZP2ootlg[t]+corrCoeff0[t+17+kNch]);
518 // 0---------0 Ch. debug 0---------0
519/* printf("\n\n ---------- Debug of pedestal subtraction from correlation ----------\n");
520 printf("\tCorrCoeff0\tCorrCoeff1\n");
521 printf(" ZN1 %d\t%1.0f\t%1.0f\n",t,corrCoeff0[t],corrCoeff1[t]);
522 printf(" ZN1lg %d\t%1.0f\t%1.0f\n",t+kNch,corrCoeff0[t+kNch],corrCoeff1[t+kNch]);
523 printf(" ZP1 %d\t%1.0f\t%1.0f\n",t+5,corrCoeff0[t+5],corrCoeff1[t+5]);
524 printf(" ZP1lg %d\t%1.0f\t%1.0f\n",t+5+kNch,corrCoeff0[t+5+kNch],corrCoeff1[t+5+kNch]);
525 printf(" ZN2 %d\t%1.0f\t%1.0f\n",t+12,corrCoeff0[t+12],corrCoeff1[t+12]);
526 printf(" ZN2lg %d\t%1.0f\t%1.0f\n",t+12+kNch,corrCoeff0[t+12+kNch],corrCoeff1[t+12+kNch]);
527 printf(" ZP2 %d\t%1.0f\t%1.0f\n",t+17,corrCoeff0[t+17],corrCoeff1[t+17]);
528 printf(" ZP2lg %d\t%1.0f\t%1.0f\n",t+17+kNch,corrCoeff0[t+17+kNch],corrCoeff1[t+17+kNch]);
529
530 printf("ZN1 -> rawADC %d\tpedestal%1.2f\tcorrADC%1.2f\n",
531 adcZN1[t],(corrCoeff1[t]*adcZN1oot[t]+corrCoeff0[t]),tZN1Corr[t]);
532 printf(" lg -> rawADC %d\tpedestal%1.2f\tcorrADC%1.2f\n",
533 adcZN1lg[t],(corrCoeff1[t+kNch]*adcZN1ootlg[t]+corrCoeff0[t+kNch]),tZN1Corr[t+5]);
534 //
535 printf("ZP1 -> rawADC %d\tpedestal%1.2f\tcorrADC%1.2f\n",
536 adcZP1[t],(corrCoeff1[t+5]*adcZP1oot[t]+corrCoeff0[t+5]),tZP1Corr[t]);
537 printf(" lg -> rawADC %d\tpedestal%1.2f\tcorrADC%1.2f\n",
538 adcZP1lg[t],(corrCoeff1[t+5+kNch]*adcZP1ootlg[t]+corrCoeff0[t+5+kNch]),tZP1Corr[t+5]);
539 //
540 printf("ZN2 -> rawADC %d\tpedestal%1.2f\tcorrADC%1.2f\n",
541 adcZN2[t],(corrCoeff1[t+12]*adcZN2oot[t]+corrCoeff0[t+12]),tZN2Corr[t]);
542 printf(" lg -> rawADC %d\tpedestal%1.2f\tcorrADC%1.2f\n",
543 adcZN2lg[t],(corrCoeff1[t+12+kNch]*adcZN2ootlg[t]+corrCoeff0[t+12+kNch]),tZN2Corr[t+5]);
544 //
545 printf("ZP2 -> rawADC %d\tpedestal%1.2f\tcorrADC%1.2f\n",
546 adcZP2[t],(corrCoeff1[t+17]*adcZP2oot[t]+corrCoeff0[t+17]),tZP2Corr[t]);
547 printf(" lg -> rawADC %d\tpedestal%1.2f\tcorrADC%1.2f\n",
548 adcZP2lg[t],(corrCoeff1[t+17+kNch]*adcZP2ootlg[t]+corrCoeff0[t+17+kNch]),tZP2Corr[t+5]);
549*/
550 }
551 dZEM1Corr[0] = adcZEM[0] - (corrCoeff1[9]*adcZEMoot[0]+corrCoeff0[9]);
552 dZEM1Corr[1] = adcZEMlg[0] - (corrCoeff1[9+kNch]*adcZEMootlg[0]+corrCoeff0[9+kNch]);
553 dZEM2Corr[0] = adcZEM[1] - (corrCoeff1[10]*adcZEMoot[1]+corrCoeff0[10]);
554 dZEM2Corr[1] = adcZEMlg[1] - (corrCoeff1[10+kNch]*adcZEMootlg[1]+corrCoeff0[10+kNch]);
555 //
556 sPMRef1[0] = pmRef[0] - (corrCoeff1[22]*pmRefoot[0]+corrCoeff0[22]);
557 sPMRef1[1] = pmReflg[0] - (corrCoeff1[22+kNch]*pmRefootlg[0]+corrCoeff0[22+kNch]);
558 sPMRef2[0] = pmRef[0] - (corrCoeff1[23]*pmRefoot[1]+corrCoeff0[23]);
559 sPMRef2[1] = pmReflg[0] - (corrCoeff1[23+kNch]*pmRefootlg[1]+corrCoeff0[23+kNch]);
f5d41205 560 }
561
73bc3a3f 562 // If CALIBRATION_MB run build the RecoParam object
563 if(fIsCalibrationMB){
564 Float_t ZDCC=0., ZDCA=0., ZEM=0;
565 ZEM += dZEM1Corr[0] + dZEM2Corr[0];
566 for(Int_t jkl=0; jkl<5; jkl++){
567 ZDCC += tZN1Corr[jkl] + tZP1Corr[jkl];
568 ZDCA += tZN2Corr[jkl] + tZP2Corr[jkl];
569 }
1e319f71 570 BuildRecoParam(ZDCC/100., ZDCA/100., ZEM/100.);
73bc3a3f 571 }
69550cf5 572 // reconstruct the event
73bc3a3f 573 else{
574 if(fRecoMode==1) // p-p data
575 ReconstructEventpp(clustersTree, tZN1Corr, tZP1Corr, tZN2Corr, tZP2Corr,
1e319f71 576 dZEM1Corr, dZEM2Corr, sPMRef1, sPMRef2, chOff, isUndflw, isOvflw);
73bc3a3f 577 else if(fRecoMode==2) // Pb-Pb data
578 ReconstructEventPbPb(clustersTree, tZN1Corr, tZP1Corr, tZN2Corr, tZP2Corr,
1e319f71 579 dZEM1Corr, dZEM2Corr, sPMRef1, sPMRef2, chOff, isUndflw, isOvflw);
73bc3a3f 580 }
f5d41205 581}
582
583//_____________________________________________________________________________
73bc3a3f 584void AliZDCReconstructor::ReconstructEventpp(TTree *clustersTree, Float_t* corrADCZN1,
585 Float_t* corrADCZP1, Float_t* corrADCZN2, Float_t* corrADCZP2,
1e319f71 586 Float_t* corrADCZEM1, Float_t* corrADCZEM2, Float_t* sPMRef1, Float_t* sPMRef2,
587 Bool_t channelsOff, Bool_t chUnderflow, Bool_t chOverflow) const
f5d41205 588{
73bc3a3f 589 // ****************** Reconstruct one event ******************
1e319f71 590
591 // ---- Setting reco flags
6b793021 592 UInt_t recoFlag=0;
593 UInt_t rFlags[32];
594 for(Int_t ifl=0; ifl<32; ifl++) rFlags[ifl]=0;
12434381 595
596 if(corrADCZN2[0]>fSignalThreshold) rFlags[0] = 0x1;
597 if(corrADCZP2[0]>fSignalThreshold) rFlags[1] = 0x1;
6b793021 598 if(corrADCZEM1[0]>fSignalThreshold) rFlags[2] = 0x1;
599 if(corrADCZEM2[0]>fSignalThreshold) rFlags[3] = 0x1;
12434381 600 if(corrADCZN1[0]>fSignalThreshold) rFlags[4] = 0x1;
601 if(corrADCZP1[0]>fSignalThreshold) rFlags[5] = 0x1;
1e319f71 602 //
6b793021 603 if(channelsOff==kTRUE) rFlags[8] = 0x1;
604 if(chUnderflow == kTRUE) rFlags[9] = 0x1;
605 if(chOverflow==kTRUE) rFlags[10] = 0x1;
606 recoFlag = rFlags[10] << 10 | rFlags[9] << 9 | rFlags[8] << 8 |
607 rFlags[5] << 5 | rFlags[4] << 4 | rFlags[3] << 3 |
608 rFlags[2] << 2 | rFlags[1] << 1 | rFlags[0];
1e319f71 609
73bc3a3f 610 // ****** Retrieving calibration data
84d6255e 611 // --- Equalization coefficients ---------------------------------------------
f5d41205 612 Float_t equalCoeffZN1[5], equalCoeffZP1[5], equalCoeffZN2[5], equalCoeffZP2[5];
613 for(Int_t ji=0; ji<5; ji++){
73bc3a3f 614 equalCoeffZN1[ji] = fTowCalibData->GetZN1EqualCoeff(ji);
615 equalCoeffZP1[ji] = fTowCalibData->GetZP1EqualCoeff(ji);
616 equalCoeffZN2[ji] = fTowCalibData->GetZN2EqualCoeff(ji);
617 equalCoeffZP2[ji] = fTowCalibData->GetZP2EqualCoeff(ji);
f5d41205 618 }
84d6255e 619 // --- Energy calibration factors ------------------------------------
f5d41205 620 Float_t calibEne[4];
42d8b8d5 621 // **** Energy calibration coefficient set to 1
622 // **** (no trivial way to calibrate in p-p runs)
73bc3a3f 623 for(Int_t ij=0; ij<4; ij++) calibEne[ij] = fEnCalibData->GetEnCalib(ij);
7bff3766 624
73bc3a3f 625 // ****** Equalization of detector responses
7bff3766 626 Float_t equalTowZN1[10], equalTowZN2[10], equalTowZP1[10], equalTowZP2[10];
73bc3a3f 627 for(Int_t gi=0; gi<10; gi++){
31474197 628 if(gi<5){
629 equalTowZN1[gi] = corrADCZN1[gi]*equalCoeffZN1[gi];
630 equalTowZP1[gi] = corrADCZP1[gi]*equalCoeffZP1[gi];
631 equalTowZN2[gi] = corrADCZN2[gi]*equalCoeffZN2[gi];
632 equalTowZP2[gi] = corrADCZP2[gi]*equalCoeffZP2[gi];
633 }
634 else{
635 equalTowZN1[gi] = corrADCZN1[gi]*equalCoeffZN1[gi-5];
636 equalTowZP1[gi] = corrADCZP1[gi]*equalCoeffZP1[gi-5];
637 equalTowZN2[gi] = corrADCZN2[gi]*equalCoeffZN2[gi-5];
638 equalTowZP2[gi] = corrADCZP2[gi]*equalCoeffZP2[gi-5];
639 }
73bc3a3f 640 }
641
642 // ****** Summed response for hadronic calorimeter (SUMMED and then CALIBRATED!)
643 Float_t calibSumZN1[]={0,0}, calibSumZN2[]={0,0}, calibSumZP1[]={0,0}, calibSumZP2[]={0,0};
7bff3766 644 for(Int_t gi=0; gi<5; gi++){
73bc3a3f 645 calibSumZN1[0] += equalTowZN1[gi];
646 calibSumZP1[0] += equalTowZP1[gi];
647 calibSumZN2[0] += equalTowZN2[gi];
648 calibSumZP2[0] += equalTowZP2[gi];
649 //
650 calibSumZN1[1] += equalTowZN1[gi+5];
651 calibSumZP1[1] += equalTowZP1[gi+5];
652 calibSumZN2[1] += equalTowZN2[gi+5];
653 calibSumZP2[1] += equalTowZP2[gi+5];
7bff3766 654 }
73bc3a3f 655 // High gain chain
656 calibSumZN1[0] = calibSumZN1[0]*calibEne[0]/8.;
657 calibSumZP1[0] = calibSumZP1[0]*calibEne[1]/8.;
658 calibSumZN2[0] = calibSumZN2[0]*calibEne[2]/8.;
659 calibSumZP2[0] = calibSumZP2[0]*calibEne[3]/8.;
660 // Low gain chain
661 calibSumZN1[1] = calibSumZN1[1]*calibEne[0];
662 calibSumZP1[1] = calibSumZP1[1]*calibEne[1];
663 calibSumZN2[1] = calibSumZN2[1]*calibEne[2];
664 calibSumZP2[1] = calibSumZP2[1]*calibEne[3];
7bff3766 665
73bc3a3f 666 // ****** Energy calibration of detector responses
7bff3766 667 Float_t calibTowZN1[10], calibTowZN2[10], calibTowZP1[10], calibTowZP2[10];
73bc3a3f 668 for(Int_t gi=0; gi<5; gi++){
669 // High gain chain
670 calibTowZN1[gi] = equalTowZN1[gi]*calibEne[0]/8.;
671 calibTowZP1[gi] = equalTowZP1[gi]*calibEne[1]/8.;
672 calibTowZN2[gi] = equalTowZN2[gi]*calibEne[2]/8.;
673 calibTowZP2[gi] = equalTowZP2[gi]*calibEne[3]/8.;
674 // Low gain chain
675 calibTowZN1[gi+5] = equalTowZN1[gi+5]*calibEne[0];
676 calibTowZP1[gi+5] = equalTowZP1[gi+5]*calibEne[1];
677 calibTowZN2[gi+5] = equalTowZN2[gi+5]*calibEne[2];
678 calibTowZP2[gi+5] = equalTowZP2[gi+5]*calibEne[3];
7bff3766 679 }
73bc3a3f 680 //
681 Float_t sumZEM[]={0,0}, calibZEM1[]={0,0}, calibZEM2[]={0,0};
682 calibZEM1[0] = corrADCZEM1[0]*calibEne[5]/8.;
683 calibZEM1[1] = corrADCZEM1[1]*calibEne[5];
684 calibZEM2[0] = corrADCZEM2[0]*calibEne[5]/8.;
685 calibZEM2[1] = corrADCZEM2[1]*calibEne[5];
686 for(Int_t k=0; k<2; k++) sumZEM[k] = calibZEM1[k] + calibZEM2[k];
7bff3766 687
73bc3a3f 688 // ****** No. of spectator and participants nucleons
42d8b8d5 689 // Variables calculated to comply with ESD structure
73bc3a3f 690 // *** N.B. -> They have a meaning only in Pb-Pb!!!!!!!!!!!!
d9ec113e 691 Int_t nDetSpecNLeft=0, nDetSpecPLeft=0, nDetSpecNRight=0, nDetSpecPRight=0;
73bc3a3f 692 Int_t nGenSpec=0, nGenSpecLeft=0, nGenSpecRight=0;
693 Int_t nPart=0, nPartTotLeft=0, nPartTotRight=0;
694 Double_t impPar=0., impPar1=0., impPar2=0.;
7bff3766 695
696 // create the output tree
1e319f71 697 AliZDCReco* reco = new AliZDCReco(calibSumZN1, calibSumZP1, calibSumZN2, calibSumZP2,
698 calibTowZN1, calibTowZP1, calibTowZN2, calibTowZP2,
699 calibZEM1, calibZEM2, sPMRef1, sPMRef2,
700 nDetSpecNLeft, nDetSpecPLeft, nDetSpecNRight, nDetSpecPRight,
701 nGenSpec, nGenSpecLeft, nGenSpecRight,
702 nPart, nPartTotLeft, nPartTotRight,
703 impPar, impPar1, impPar2,
704 recoFlag);
7bff3766 705
1b467dea 706 const Int_t kBufferSize = 4000;
1e319f71 707 clustersTree->Branch("ZDC", "AliZDCReco", &reco, kBufferSize);
7bff3766 708 // write the output tree
709 clustersTree->Fill();
710}
711
712//_____________________________________________________________________________
73bc3a3f 713void AliZDCReconstructor::ReconstructEventPbPb(TTree *clustersTree,
714 Float_t* corrADCZN1, Float_t* corrADCZP1, Float_t* corrADCZN2, Float_t* corrADCZP2,
1e319f71 715 Float_t* corrADCZEM1, Float_t* corrADCZEM2, Float_t* sPMRef1, Float_t* sPMRef2,
716 Bool_t channelsOff, Bool_t chUnderflow, Bool_t chOverflow) const
7bff3766 717{
73bc3a3f 718 // ****************** Reconstruct one event ******************
1e319f71 719
6b793021 720 // ---- Setting reco flags
721 UInt_t recoFlag=0;
722 UInt_t rFlags[32];
723 for(Int_t ifl=0; ifl<32; ifl++) rFlags[ifl]=0;
12434381 724
725 if(corrADCZN2[0]>fSignalThreshold) rFlags[0] = 0x1;
726 if(corrADCZP2[0]>fSignalThreshold) rFlags[1] = 0x1;
6b793021 727 if(corrADCZEM1[0]>fSignalThreshold) rFlags[2] = 0x1;
728 if(corrADCZEM2[0]>fSignalThreshold) rFlags[3] = 0x1;
12434381 729 if(corrADCZN1[0]>fSignalThreshold) rFlags[4] = 0x1;
730 if(corrADCZP1[0]>fSignalThreshold) rFlags[5] = 0x1;
1e319f71 731 //
6b793021 732 if(channelsOff==kTRUE) rFlags[8] = 0x1;
733 if(chUnderflow == kTRUE) rFlags[9] = 0x1;
734 if(chOverflow==kTRUE) rFlags[10] = 0x1;
735 recoFlag = rFlags[10] << 10 | rFlags[9] << 9 | rFlags[8] << 8 |
736 rFlags[5] << 5 | rFlags[4] << 4 | rFlags[3] << 3 |
737 rFlags[2] << 2 | rFlags[1] << 1 | rFlags[0];
73bc3a3f 738
739 // ****** Retrieving calibration data
7bff3766 740 // --- Equalization coefficients ---------------------------------------------
741 Float_t equalCoeffZN1[5], equalCoeffZP1[5], equalCoeffZN2[5], equalCoeffZP2[5];
742 for(Int_t ji=0; ji<5; ji++){
73bc3a3f 743 equalCoeffZN1[ji] = fTowCalibData->GetZN1EqualCoeff(ji);
744 equalCoeffZP1[ji] = fTowCalibData->GetZP1EqualCoeff(ji);
745 equalCoeffZN2[ji] = fTowCalibData->GetZN2EqualCoeff(ji);
746 equalCoeffZP2[ji] = fTowCalibData->GetZP2EqualCoeff(ji);
7bff3766 747 }
748 // --- Energy calibration factors ------------------------------------
73bc3a3f 749 Float_t valFromOCDB[6], calibEne[6];
750 for(Int_t ij=0; ij<6; ij++){
751 valFromOCDB[ij] = fEnCalibData->GetEnCalib(ij);
752 if(ij<4){
753 if(valFromOCDB[ij]!=0) calibEne[ij] = fBeamEnergy/valFromOCDB[ij];
754 else AliWarning(" Value from OCDB for E calibration = 0 !!!\n");
755 }
756 else calibEne[ij] = valFromOCDB[ij];
757 }
f5d41205 758
73bc3a3f 759 // ****** Equalization of detector responses
c35ed519 760 Float_t equalTowZN1[10], equalTowZN2[10], equalTowZP1[10], equalTowZP2[10];
73bc3a3f 761 for(Int_t gi=0; gi<10; gi++){
31474197 762 if(gi<5){
763 equalTowZN1[gi] = corrADCZN1[gi]*equalCoeffZN1[gi];
764 equalTowZP1[gi] = corrADCZP1[gi]*equalCoeffZP1[gi];
765 equalTowZN2[gi] = corrADCZN2[gi]*equalCoeffZN2[gi];
766 equalTowZP2[gi] = corrADCZP2[gi]*equalCoeffZP2[gi];
767 }
768 else{
769 equalTowZN1[gi] = corrADCZN1[gi]*equalCoeffZN1[gi-5];
770 equalTowZP1[gi] = corrADCZP1[gi]*equalCoeffZP1[gi-5];
771 equalTowZN2[gi] = corrADCZN2[gi]*equalCoeffZN2[gi-5];
772 equalTowZP2[gi] = corrADCZP2[gi]*equalCoeffZP2[gi-5];
773 }
f5d41205 774 }
775
73bc3a3f 776 // ****** Summed response for hadronic calorimeter (SUMMED and then CALIBRATED!)
c9102a72 777 Float_t calibSumZN1[]={0,0}, calibSumZN2[]={0,0}, calibSumZP1[]={0,0}, calibSumZP2[]={0,0};
73bc3a3f 778 for(Int_t gi=0; gi<5; gi++){
779 calibSumZN1[0] += equalTowZN1[gi];
780 calibSumZP1[0] += equalTowZP1[gi];
781 calibSumZN2[0] += equalTowZN2[gi];
782 calibSumZP2[0] += equalTowZP2[gi];
783 //
784 calibSumZN1[1] += equalTowZN1[gi+5];
785 calibSumZP1[1] += equalTowZP1[gi+5];
786 calibSumZN2[1] += equalTowZN2[gi+5];
787 calibSumZP2[1] += equalTowZP2[gi+5];
f5d41205 788 }
73bc3a3f 789 // High gain chain
790 calibSumZN1[0] = calibSumZN1[0]*calibEne[0]/8.;
791 calibSumZP1[0] = calibSumZP1[0]*calibEne[1]/8.;
792 calibSumZN2[0] = calibSumZN2[0]*calibEne[2]/8.;
793 calibSumZP2[0] = calibSumZP2[0]*calibEne[3]/8.;
794 // Low gain chain
795 calibSumZN1[1] = calibSumZN1[1]*calibEne[0];
796 calibSumZP1[1] = calibSumZP1[1]*calibEne[1];
797 calibSumZN2[1] = calibSumZN2[1]*calibEne[2];
798 calibSumZP2[1] = calibSumZP2[1]*calibEne[3];
7bff3766 799 //
73bc3a3f 800 Float_t sumZEM[]={0,0}, calibZEM1[]={0,0}, calibZEM2[]={0,0};
801 calibZEM1[0] = corrADCZEM1[0]*calibEne[5]/8.;
802 calibZEM1[1] = corrADCZEM1[1]*calibEne[5];
803 calibZEM2[0] = corrADCZEM2[0]*calibEne[5]/8.;
804 calibZEM2[1] = corrADCZEM2[1]*calibEne[5];
805 for(Int_t k=0; k<2; k++) sumZEM[k] = calibZEM1[k] + calibZEM2[k];
806
807 // ****** Energy calibration of detector responses
808 Float_t calibTowZN1[10], calibTowZN2[10], calibTowZP1[10], calibTowZP2[10];
809 for(Int_t gi=0; gi<5; gi++){
810 // High gain chain
811 calibTowZN1[gi] = equalTowZN1[gi]*calibEne[0]/8.;
812 calibTowZP1[gi] = equalTowZP1[gi]*calibEne[1]/8.;
813 calibTowZN2[gi] = equalTowZN2[gi]*calibEne[2]/8.;
814 calibTowZP2[gi] = equalTowZP2[gi]*calibEne[3]/8.;
815 // Low gain chain
816 calibTowZN1[gi+5] = equalTowZN1[gi+5]*calibEne[0];
817 calibTowZP1[gi+5] = equalTowZP1[gi+5]*calibEne[1];
818 calibTowZN2[gi+5] = equalTowZN2[gi+5]*calibEne[2];
819 calibTowZP2[gi+5] = equalTowZP2[gi+5]*calibEne[3];
820 }
f5d41205 821
73bc3a3f 822 // ****** Number of detected spectator nucleons
d9ec113e 823 Int_t nDetSpecNLeft=0, nDetSpecPLeft=0, nDetSpecNRight=0, nDetSpecPRight=0;
fd9afd60 824 if(fBeamEnergy!=0){
825 nDetSpecNLeft = (Int_t) (calibSumZN1[0]/fBeamEnergy);
826 nDetSpecPLeft = (Int_t) (calibSumZP1[0]/fBeamEnergy);
827 nDetSpecNRight = (Int_t) (calibSumZN2[0]/fBeamEnergy);
828 nDetSpecPRight = (Int_t) (calibSumZP2[0]/fBeamEnergy);
829 }
73bc3a3f 830 else AliWarning(" ATTENTION!!! fBeamEnergy=0 -> N_spec will be ZERO!!! \n");
f5d41205 831 /*printf("\n\t AliZDCReconstructor -> nDetSpecNLeft %d, nDetSpecPLeft %d,"
832 " nDetSpecNRight %d, nDetSpecPRight %d\n",nDetSpecNLeft, nDetSpecPLeft,
833 nDetSpecNRight, nDetSpecPRight);*/
73bc3a3f 834
1e319f71 835 Int_t nGenSpec=0, nGenSpecA=0, nGenSpecC=0;
836 Int_t nPart=0, nPartA=0, nPartC=0;
837 Double_t b=0., bA=0., bC=0.;
838
73bc3a3f 839 if(fIsCalibrationMB == kFALSE){
840 // ****** Reconstruction parameters ------------------
841 // Ch. debug
842 //fRecoParam->Print("");
843 //
4a72fbdb 844
845 if (!fRecoParam) fRecoParam = const_cast<AliZDCRecoParam*>(GetRecoParam());
846
73bc3a3f 847 TH2F *hZDCvsZEM = fRecoParam->GethZDCvsZEM();
848 TH2F *hZDCCvsZEM = fRecoParam->GethZDCCvsZEM();
849 TH2F *hZDCAvsZEM = fRecoParam->GethZDCAvsZEM();
850 TH1D *hNpartDist = fRecoParam->GethNpartDist();
851 TH1D *hbDist = fRecoParam->GethbDist();
852 Float_t ClkCenter = fRecoParam->GetClkCenter();
853 //
854 Double_t xHighEdge = hZDCvsZEM->GetXaxis()->GetXmax();
855 Double_t origin = xHighEdge*ClkCenter;
856 // Ch. debug
1e319f71 857 //printf("\n\n xHighEdge %1.2f, origin %1.4f \n", xHighEdge, origin);
73bc3a3f 858 //
859 // ====> Summed ZDC info (sideA+side C)
860 TF1 *line = new TF1("line","[0]*x+[1]",0.,xHighEdge);
861 Float_t y = (calibSumZN1[0]+calibSumZP1[0]+calibSumZN2[0]+calibSumZP2[0])/1000.;
862 Float_t x = (calibZEM1[0]+calibZEM2[0])/1000.;
863 line->SetParameter(0, y/(x-origin));
864 line->SetParameter(1, -origin*y/(x-origin));
865 // Ch. debug
1e319f71 866 //printf(" ***************** Summed ZDC info (sideA+side C) \n");
867 //printf(" E_{ZEM} %1.4f, E_{ZDC} %1.2f, TF1: %1.2f*x + %1.2f ", x, y,y/(x-origin),-origin*y/(x-origin));
73bc3a3f 868 //
869 Double_t countPerc=0;
870 Double_t xBinCenter=0, yBinCenter=0;
871 for(Int_t nbinx=1; nbinx<=hZDCvsZEM->GetNbinsX(); nbinx++){
872 for(Int_t nbiny=1; nbiny<=hZDCvsZEM->GetNbinsY(); nbiny++){
873 xBinCenter = hZDCvsZEM->GetXaxis()->GetBinCenter(nbinx);
874 yBinCenter = hZDCvsZEM->GetYaxis()->GetBinCenter(nbiny);
875 //
876 if(line->GetParameter(0)>0){
877 if(yBinCenter < (line->GetParameter(0)*xBinCenter + line->GetParameter(1))){
878 countPerc += hZDCvsZEM->GetBinContent(nbinx,nbiny);
879 // Ch. debug
880 /*printf(" xBinCenter %1.3f, yBinCenter %1.0f, countPerc %1.0f\n",
881 xBinCenter, yBinCenter, countPerc);*/
882 }
883 }
884 else{
885 if(yBinCenter > (line->GetParameter(0)*xBinCenter + line->GetParameter(1))){
886 countPerc += hZDCvsZEM->GetBinContent(nbinx,nbiny);
887 // Ch. debug
888 /*printf(" xBinCenter %1.3f, yBinCenter %1.0f, countPerc %1.0f\n",
889 xBinCenter, yBinCenter, countPerc);*/
890 }
891 }
892 }
893 }
894 //
895 Double_t xSecPerc = 0.;
896 if(hZDCvsZEM->GetEntries()!=0){
897 xSecPerc = countPerc/hZDCvsZEM->GetEntries();
898 }
899 else{
900 AliWarning(" Histogram hZDCvsZEM from OCDB has no entries!!!");
901 }
902 // Ch. debug
903 //printf(" xSecPerc %1.4f \n", xSecPerc);
f5d41205 904
73bc3a3f 905 // ====> side C
906 TF1 *lineC = new TF1("lineC","[0]*x+[1]",0.,xHighEdge);
907 Float_t yC = (calibSumZN1[0]+calibSumZP1[0])/1000.;
908 lineC->SetParameter(0, yC/(x-origin));
909 lineC->SetParameter(1, -origin*yC/(x-origin));
910 // Ch. debug
911 //printf(" ***************** Side C \n");
912 //printf(" E_{ZEM} %1.4f, E_{ZDCC} %1.2f, TF1: %1.2f*x + %1.2f ", x, yC,yC/(x-origin),-origin*yC/(x-origin));
913 //
914 Double_t countPercC=0;
915 Double_t xBinCenterC=0, yBinCenterC=0;
916 for(Int_t nbinx=1; nbinx<=hZDCCvsZEM->GetNbinsX(); nbinx++){
917 for(Int_t nbiny=1; nbiny<=hZDCCvsZEM->GetNbinsY(); nbiny++){
918 xBinCenterC = hZDCCvsZEM->GetXaxis()->GetBinCenter(nbinx);
919 yBinCenterC = hZDCCvsZEM->GetYaxis()->GetBinCenter(nbiny);
920 if(lineC->GetParameter(0)>0){
921 if(yBinCenterC < (lineC->GetParameter(0)*xBinCenterC + lineC->GetParameter(1))){
922 countPercC += hZDCCvsZEM->GetBinContent(nbinx,nbiny);
923 }
924 }
925 else{
926 if(yBinCenterC > (lineC->GetParameter(0)*xBinCenterC + lineC->GetParameter(1))){
927 countPercC += hZDCCvsZEM->GetBinContent(nbinx,nbiny);
928 }
929 }
930 }
931 }
932 //
933 Double_t xSecPercC = 0.;
934 if(hZDCCvsZEM->GetEntries()!=0){
935 xSecPercC = countPercC/hZDCCvsZEM->GetEntries();
936 }
937 else{
938 AliWarning(" Histogram hZDCCvsZEM from OCDB has no entries!!!");
939 }
940 // Ch. debug
941 //printf(" xSecPercC %1.4f \n", xSecPercC);
942
943 // ====> side A
944 TF1 *lineA = new TF1("lineA","[0]*x+[1]",0.,xHighEdge);
945 Float_t yA = (calibSumZN2[0]+calibSumZP2[0])/1000.;
946 lineA->SetParameter(0, yA/(x-origin));
947 lineA->SetParameter(1, -origin*yA/(x-origin));
948 //
949 // Ch. debug
950 //printf(" ***************** Side A \n");
951 //printf(" E_{ZEM} %1.4f, E_{ZDCA} %1.2f, TF1: %1.2f*x + %1.2f ", x, yA,yA/(x-origin),-origin*yA/(x-origin));
952 //
953 Double_t countPercA=0;
954 Double_t xBinCenterA=0, yBinCenterA=0;
955 for(Int_t nbinx=1; nbinx<=hZDCAvsZEM->GetNbinsX(); nbinx++){
956 for(Int_t nbiny=1; nbiny<=hZDCAvsZEM->GetNbinsY(); nbiny++){
957 xBinCenterA = hZDCAvsZEM->GetXaxis()->GetBinCenter(nbinx);
958 yBinCenterA = hZDCAvsZEM->GetYaxis()->GetBinCenter(nbiny);
959 if(lineA->GetParameter(0)>0){
960 if(yBinCenterA < (lineA->GetParameter(0)*xBinCenterA + lineA->GetParameter(1))){
961 countPercA += hZDCAvsZEM->GetBinContent(nbinx,nbiny);
962 }
963 }
964 else{
965 if(yBinCenterA > (lineA->GetParameter(0)*xBinCenterA + lineA->GetParameter(1))){
966 countPercA += hZDCAvsZEM->GetBinContent(nbinx,nbiny);
967 }
968 }
969 }
970 }
971 //
972 Double_t xSecPercA = 0.;
973 if(hZDCAvsZEM->GetEntries()!=0){
974 xSecPercA = countPercA/hZDCAvsZEM->GetEntries();
975 }
976 else{
977 AliWarning(" Histogram hZDCAvsZEM from OCDB has no entries!!!");
978 }
979 // Ch. debug
980 //printf(" xSecPercA %1.4f \n", xSecPercA);
981
982 // ****** Number of participants (from E_ZDC vs. E_ZEM correlation)
983 Int_t nPart=0, nPartC=0, nPartA=0;
984 Double_t nPartFrac=0., nPartFracC=0., nPartFracA=0.;
985 for(Int_t npbin=1; npbin<hNpartDist->GetNbinsX(); npbin++){
986 nPartFrac += (hNpartDist->GetBinContent(npbin))/(hNpartDist->GetEntries());
987 if((1.-nPartFrac) < xSecPerc){
988 nPart = (Int_t) hNpartDist->GetBinLowEdge(npbin);
989 // Ch. debug
990 //printf(" ***************** Summed ZDC info (sideA+side C) \n");
991 //printf(" nPartFrac %1.4f, nPart %d\n", nPartFrac, nPart);
992 break;
993 }
994 }
995 if(nPart<0) nPart=0;
996 //
997 for(Int_t npbin=1; npbin<hNpartDist->GetNbinsX(); npbin++){
998 nPartFracC += (hNpartDist->GetBinContent(npbin))/(hNpartDist->GetEntries());
999 if((1.-nPartFracC) < xSecPercC){
1000 nPartC = (Int_t) hNpartDist->GetBinLowEdge(npbin);
1001 // Ch. debug
1002 //printf(" ***************** Side C \n");
1003 //printf(" nPartFracC %1.4f, nPartC %d\n", nPartFracC, nPartC);
1004 break;
1005 }
1006 }
1007 if(nPartC<0) nPartC=0;
1008 //
1009 for(Int_t npbin=1; npbin<hNpartDist->GetNbinsX(); npbin++){
1010 nPartFracA += (hNpartDist->GetBinContent(npbin))/(hNpartDist->GetEntries());
1011 if((1.-nPartFracA) < xSecPercA){
1012 nPartA = (Int_t) hNpartDist->GetBinLowEdge(npbin);
1013 // Ch. debug
1014 //printf(" ***************** Side A \n");
1015 //printf(" nPartFracA %1.4f, nPartA %d\n\n", nPartFracA, nPartA);
1016 break;
1017 }
1018 }
1019 if(nPartA<0) nPartA=0;
1020
1021 // ****** Impact parameter (from E_ZDC vs. E_ZEM correlation)
1022 Float_t b=0, bC=0, bA=0;
1023 Double_t bFrac=0., bFracC=0., bFracA=0.;
1024 for(Int_t ibbin=1; ibbin<hbDist->GetNbinsX(); ibbin++){
1025 bFrac += (hbDist->GetBinContent(ibbin))/(hbDist->GetEntries());
1026 if((1.-bFrac) < xSecPerc){
1027 b = hbDist->GetBinLowEdge(ibbin);
1028 break;
1029 }
1030 }
1031 //
1032 for(Int_t ibbin=1; ibbin<hbDist->GetNbinsX(); ibbin++){
1033 bFracC += (hbDist->GetBinContent(ibbin))/(hbDist->GetEntries());
1034 if((1.-bFracC) < xSecPercC){
1035 bC = hbDist->GetBinLowEdge(ibbin);
1036 break;
1037 }
1038 }
1039 //
1040 for(Int_t ibbin=1; ibbin<hbDist->GetNbinsX(); ibbin++){
1041 bFracA += (hbDist->GetBinContent(ibbin))/(hNpartDist->GetEntries());
1042 if((1.-bFracA) < xSecPercA){
1043 bA = hbDist->GetBinLowEdge(ibbin);
1044 break;
1045 }
1046 }
1047
1048 // ****** Number of spectator nucleons
1049 Int_t nGenSpec=0, nGenSpecC=0, nGenSpecA=0;
1050 //
1051 nGenSpec = 416 - nPart;
1052 nGenSpecC = 416 - nPartC;
1053 nGenSpecA = 416 - nPartA;
1054 if(nGenSpec>416) nGenSpec=416; if(nGenSpec<0) nGenSpec=0;
1055 if(nGenSpecC>416) nGenSpecC=416; if(nGenSpecC<0) nGenSpecC=0;
1056 if(nGenSpecA>416) nGenSpecA=416; if(nGenSpecA<0) nGenSpecA=0;
8309c1ab 1057
73bc3a3f 1058 // Ch. debug
1059 /*printf("\n\t AliZDCReconstructor -> calibSumZN1[0] %1.0f, calibSumZP1[0] %1.0f,"
1060 " calibSumZN2[0] %1.0f, calibSumZP2[0] %1.0f, corrADCZEMHG %1.0f\n",
1061 calibSumZN1[0],calibSumZP1[0],calibSumZN2[0],calibSumZP2[0],corrADCZEMHG);
1062 printf("\t AliZDCReconstructor -> nGenSpecLeft %d nGenSpecRight %d\n",
1063 nGenSpecLeft, nGenSpecRight);
1064 printf("\t AliZDCReconstructor -> NpartL %d, NpartR %d, b %1.2f fm\n\n",nPartTotLeft, nPartTotRight, impPar);
1065 */
c35ed519 1066
73bc3a3f 1067 delete lineC; delete lineA;
1e319f71 1068
73bc3a3f 1069 } // ONLY IF fIsCalibrationMB==kFALSE
1e319f71 1070
1071 AliZDCReco* reco = new AliZDCReco(calibSumZN1, calibSumZP1, calibSumZN2, calibSumZP2,
1072 calibTowZN1, calibTowZP1, calibTowZN2, calibTowZP2,
1073 calibZEM1, calibZEM2, sPMRef1, sPMRef2,
1074 nDetSpecNLeft, nDetSpecPLeft, nDetSpecNRight, nDetSpecPRight,
1075 nGenSpec, nGenSpecA, nGenSpecC,
1076 nPart, nPartA, nPartC, b, bA, bC,
1077 recoFlag);
1078
1079 const Int_t kBufferSize = 4000;
1080 clustersTree->Branch("ZDC", "AliZDCReco", &reco, kBufferSize);
1b467dea 1081 reco->Print("");
1e319f71 1082 // write the output tree
1083 clustersTree->Fill();
73bc3a3f 1084}
8309c1ab 1085
73bc3a3f 1086//_____________________________________________________________________________
1e319f71 1087void AliZDCReconstructor::BuildRecoParam(Float_t ZDCC, Float_t ZDCA, Float_t ZEM) const
73bc3a3f 1088{
1089 // Calculate RecoParam object for Pb-Pb data
1e319f71 1090 (fRecoParam->GethZDCvsZEM())->Fill(ZDCC+ZDCA, ZEM);
1091 (fRecoParam->GethZDCCvsZEM())->Fill(ZDCC, ZEM);
1092 (fRecoParam->GethZDCAvsZEM())->Fill(ZDCA, ZEM);
73bc3a3f 1093
8309c1ab 1094}
1095
1096//_____________________________________________________________________________
70f04f6d 1097void AliZDCReconstructor::FillZDCintoESD(TTree *clustersTree, AliESDEvent* esd) const
8309c1ab 1098{
70f04f6d 1099 // fill energies and number of participants to the ESD
8309c1ab 1100
73bc3a3f 1101 if(fIsCalibrationMB==kTRUE) WritePbPbRecoParamInOCDB();
1102
8309c1ab 1103 AliZDCReco reco;
1104 AliZDCReco* preco = &reco;
70f04f6d 1105 clustersTree->SetBranchAddress("ZDC", &preco);
8309c1ab 1106
70f04f6d 1107 clustersTree->GetEntry(0);
84d6255e 1108 //
a85132e7 1109 AliESDZDC * esdzdc = esd->GetESDZDC();
1110 Float_t tZN1Ene[5], tZN2Ene[5], tZP1Ene[5], tZP2Ene[5];
1111 Float_t tZN1EneLR[5], tZN2EneLR[5], tZP1EneLR[5], tZP2EneLR[5];
1112 for(Int_t i=0; i<5; i++){
c35ed519 1113 tZN1Ene[i] = reco.GetZN1HREnTow(i);
1114 tZN2Ene[i] = reco.GetZN2HREnTow(i);
1115 tZP1Ene[i] = reco.GetZP1HREnTow(i);
1116 tZP2Ene[i] = reco.GetZP2HREnTow(i);
1117 //
1118 tZN1EneLR[i] = reco.GetZN1LREnTow(i);
1119 tZN2EneLR[i] = reco.GetZN2LREnTow(i);
1120 tZP1EneLR[i] = reco.GetZP1LREnTow(i);
1121 tZP2EneLR[i] = reco.GetZP2LREnTow(i);
e90a5fef 1122 }
73bc3a3f 1123 //
a85132e7 1124 esdzdc->SetZN1TowerEnergy(tZN1Ene);
1125 esdzdc->SetZN2TowerEnergy(tZN2Ene);
1126 esdzdc->SetZP1TowerEnergy(tZP1Ene);
1127 esdzdc->SetZP2TowerEnergy(tZP2Ene);
73bc3a3f 1128 //
a85132e7 1129 esdzdc->SetZN1TowerEnergyLR(tZN1EneLR);
1130 esdzdc->SetZN2TowerEnergyLR(tZN2EneLR);
1131 esdzdc->SetZP1TowerEnergyLR(tZP1EneLR);
1132 esdzdc->SetZP2TowerEnergyLR(tZP2EneLR);
1133 //
73bc3a3f 1134 Int_t nPart = reco.GetNParticipants();
1135 Int_t nPartA = reco.GetNPartSideA();
1136 Int_t nPartC = reco.GetNPartSideC();
1137 Double_t b = reco.GetImpParameter();
1138 Double_t bA = reco.GetImpParSideA();
1139 Double_t bC = reco.GetImpParSideC();
1e319f71 1140 UInt_t recoFlag = reco.GetRecoFlag();
1141 //
c35ed519 1142 esd->SetZDC(reco.GetZN1HREnergy(), reco.GetZP1HREnergy(), reco.GetZEM1HRsignal(),
1143 reco.GetZEM2HRsignal(), reco.GetZN2HREnergy(), reco.GetZP2HREnergy(),
1e319f71 1144 nPart, nPartA, nPartC, b, bA, bC, recoFlag);
a4cab348 1145
8309c1ab 1146}
48642b09 1147
1148//_____________________________________________________________________________
78d18275 1149AliCDBStorage* AliZDCReconstructor::SetStorage(const char *uri)
48642b09 1150{
cc2abffd 1151 // Setting the storage
48642b09 1152
78d18275 1153 Bool_t deleteManager = kFALSE;
48642b09 1154
78d18275 1155 AliCDBManager *manager = AliCDBManager::Instance();
1156 AliCDBStorage *defstorage = manager->GetDefaultStorage();
48642b09 1157
78d18275 1158 if(!defstorage || !(defstorage->Contains("ZDC"))){
1159 AliWarning("No default storage set or default storage doesn't contain ZDC!");
1160 manager->SetDefaultStorage(uri);
1161 deleteManager = kTRUE;
1162 }
1163
1164 AliCDBStorage *storage = manager->GetDefaultStorage();
1165
1166 if(deleteManager){
1167 AliCDBManager::Instance()->UnsetDefaultStorage();
1168 defstorage = 0; // the storage is killed by AliCDBManager::Instance()->Destroy()
1169 }
1170
1171 return storage;
1172}
48642b09 1173
78d18275 1174//_____________________________________________________________________________
1e319f71 1175AliZDCPedestals* AliZDCReconstructor::GetPedestalData() const
6024ec85 1176{
1177
1178 // Getting pedestal calibration object for ZDC set
1179
1180 AliCDBEntry *entry = AliCDBManager::Instance()->Get("ZDC/Calib/Pedestals");
1181 if(!entry) AliFatal("No calibration data loaded!");
1182
1183 AliZDCPedestals *calibdata = dynamic_cast<AliZDCPedestals*> (entry->GetObject());
1184 if(!calibdata) AliFatal("Wrong calibration object in calibration file!");
1185
1186 return calibdata;
1187}
1188
1189//_____________________________________________________________________________
1e319f71 1190AliZDCEnCalib* AliZDCReconstructor::GetEnergyCalibData() const
6024ec85 1191{
1192
1193 // Getting energy and equalization calibration object for ZDC set
1194
dd98e862 1195 AliCDBEntry *entry = AliCDBManager::Instance()->Get("ZDC/Calib/EnergyCalib");
6024ec85 1196 if(!entry) AliFatal("No calibration data loaded!");
1197
73bc3a3f 1198 AliZDCEnCalib *calibdata = dynamic_cast<AliZDCEnCalib*> (entry->GetObject());
6024ec85 1199 if(!calibdata) AliFatal("Wrong calibration object in calibration file!");
1200
1201 return calibdata;
1202}
1203
73bc3a3f 1204//_____________________________________________________________________________
1e319f71 1205AliZDCTowerCalib* AliZDCReconstructor::GetTowerCalibData() const
73bc3a3f 1206{
1207
1208 // Getting energy and equalization calibration object for ZDC set
1209
dd98e862 1210 AliCDBEntry *entry = AliCDBManager::Instance()->Get("ZDC/Calib/TowerCalib");
73bc3a3f 1211 if(!entry) AliFatal("No calibration data loaded!");
1212
1213 AliZDCTowerCalib *calibdata = dynamic_cast<AliZDCTowerCalib*> (entry->GetObject());
1214 if(!calibdata) AliFatal("Wrong calibration object in calibration file!");
1215
1216 return calibdata;
1217}
1218
1219//_____________________________________________________________________________
1220AliZDCRecoParampp* AliZDCReconstructor::GetppRecoParamFromOCDB() const
1221{
1222
1223 // Getting reconstruction parameters from OCDB
1224
1225 AliCDBEntry *entry = AliCDBManager::Instance()->Get("ZDC/Calib/RecoParampp");
1226 if(!entry) AliFatal("No RecoParam data found in OCDB!");
1227
1228 AliZDCRecoParampp *param = dynamic_cast<AliZDCRecoParampp*> (entry->GetObject());
1229 if(!param) AliFatal("No RecoParam object in OCDB entry!");
1230
1231 return param;
1232
1233}
1234
1235//_____________________________________________________________________________
1236AliZDCRecoParamPbPb* AliZDCReconstructor::GetPbPbRecoParamFromOCDB() const
1237{
1238
1239 // Getting reconstruction parameters from OCDB
1240
1241 AliCDBEntry *entry = AliCDBManager::Instance()->Get("ZDC/Calib/RecoParamPbPb");
1242 if(!entry) AliFatal("No RecoParam data found in OCDB!");
1243
1244 AliZDCRecoParamPbPb *param = dynamic_cast<AliZDCRecoParamPbPb*> (entry->GetObject());
1245 if(!param) AliFatal("No RecoParam object in OCDB entry!");
1246
1247 return param;
1248
1249}
1250
1251//_____________________________________________________________________________
1252void AliZDCReconstructor::WritePbPbRecoParamInOCDB() const
1253{
1254
1255 // Writing Pb-Pb reconstruction parameters from OCDB
1256
1257 AliCDBManager *man = AliCDBManager::Instance();
1258 AliCDBMetaData *md= new AliCDBMetaData();
1259 md->SetResponsible("Chiara Oppedisano");
1260 md->SetComment("ZDC Pb-Pb reconstruction parameters");
1261 md->SetObjectClassName("AliZDCRecoParamPbPb");
1262 AliCDBId id("ZDC/Calib/RecoParamPbPb",fNRun,AliCDBRunRange::Infinity());
1263 man->Put(fRecoParam, id, md);
1264
1265}
1266