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