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