]> git.uio.no Git - u/mrichter/AliRoot.git/blame - ZDC/AliZDCReconstructor.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Ignoring smell subdet
[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// //
20// class for ZDC reconstruction //
21// //
22///////////////////////////////////////////////////////////////////////////////
23
24
25#include <TF1.h>
26
27#include "AliRunLoader.h"
28#include "AliRawReader.h"
29#include "AliESDEvent.h"
30#include "AliZDCDigit.h"
31#include "AliZDCRawStream.h"
32#include "AliZDCReco.h"
33#include "AliZDCReconstructor.h"
34#include "AliZDCCalibData.h"
35
36
37ClassImp(AliZDCReconstructor)
38
39
40//_____________________________________________________________________________
41AliZDCReconstructor:: AliZDCReconstructor() :
42
43 fZNCen(new TF1("fZNCen",
44 "(-2.287920+sqrt(2.287920*2.287920-4*(-0.007629)*(11.921710-x)))/(2*(-0.007629))",0.,164.)),
45 fZNPer(new TF1("fZNPer",
46 "(-37.812280-sqrt(37.812280*37.812280-4*(-0.190932)*(-1709.249672-x)))/(2*(-0.190932))",0.,164.)),
47 fZPCen(new TF1("fZPCen",
48 "(-1.321353+sqrt(1.321353*1.321353-4*(-0.007283)*(3.550697-x)))/(2*(-0.007283))",0.,60.)),
49 fZPPer(new TF1("fZPPer",
50 "(-42.643308-sqrt(42.643308*42.643308-4*(-0.310786)*(-1402.945615-x)))/(2*(-0.310786))",0.,60.)),
51 fZDCCen(new TF1("fZDCCen",
52 "(-1.934991+sqrt(1.934991*1.934991-4*(-0.004080)*(15.111124-x)))/(2*(-0.004080))",0.,225.)),
53 fZDCPer(new TF1("fZDCPer",
54 "(-34.380639-sqrt(34.380639*34.380639-4*(-0.104251)*(-2612.189017-x)))/(2*(-0.104251))",0.,225.)),
55 fbCen(new TF1("fbCen","-0.056923+0.079703*x-0.0004301*x*x+0.000001366*x*x*x",0.,220.)),
56 fbPer(new TF1("fbPer","17.943998-0.046846*x+0.000074*x*x",0.,220.)),
57 //
58 fZEMn(new TF1("fZEMn","121.7-0.1934*x+0.00007565*x*x",0.,1200.)),
59 fZEMp(new TF1("fZEMp","80.05-0.1315*x+0.00005327*x*x",0.,1200.)),
60 fZEMsp(new TF1("fZEMsp","201.7-0.325*x+0.0001292*x*x",0.,1200.)),
61 fZEMb(new TF1("fZEMb",
62 "13.83-0.02851*x+5.101e-5*x*x-7.305e-8*x*x*x+5.101e-11*x*x*x*x-1.25e-14*x*x*x*x*x",0.,1200.)),
63 //
64 fCalibData(GetCalibData())
65
66{
67 // **** Default constructor
68
69}
70
71
72//_____________________________________________________________________________
73AliZDCReconstructor::~AliZDCReconstructor()
74{
75// destructor
76
77 delete fZNCen;
78 delete fZNPer;
79 delete fZPCen;
80 delete fZPPer;
81 delete fZDCCen;
82 delete fZDCPer;
83 delete fbCen;
84 delete fbPer;
85 delete fZEMn;
86 delete fZEMp;
87 delete fZEMsp;
88 delete fZEMb;
89
90}
91
92
93//_____________________________________________________________________________
94void AliZDCReconstructor::Reconstruct(TTree* digitsTree, TTree* clustersTree) const
95{
96 // *** Local ZDC reconstruction for digits
97 // Works on the current event
98
99 // Retrieving calibration data
100 Float_t meanPed[47];
101 for(Int_t jj=0; jj<47; jj++) meanPed[jj] = fCalibData->GetMeanPed(jj);
102
103 // get digits
104 AliZDCDigit digit;
105 AliZDCDigit* pdigit = &digit;
106 digitsTree->SetBranchAddress("ZDC", &pdigit);
107
108 // loop over digits
109 Float_t tZN1CorrHG[]={0.,0.,0.,0.,0.}, tZP1CorrHG[]={0.,0.,0.,0.,0.};
110 Float_t dZEMCorrHG=0.;
111 Float_t tZN2CorrHG[]={0.,0.,0.,0.,0.}, tZP2CorrHG[]={0.,0.,0.,0.,0.};
112 Float_t tZN1CorrLG[]={0.,0.,0.,0.,0.}, tZP1CorrLG[]={0.,0.,0.,0.,0.};
113 Float_t dZEMCorrLG=0.;
114 Float_t tZN2CorrLG[]={0.,0.,0.,0.,0.}, tZP2CorrLG[]={0.,0.,0.,0.,0.};
115
116 //printf("\n\t # of digits in tree: %d\n",(Int_t) digitsTree->GetEntries());
117 for (Int_t iDigit = 0; iDigit < (digitsTree->GetEntries()/2); iDigit++) {
118 digitsTree->GetEntry(iDigit);
119 if (!pdigit) continue;
120 //pdigit->Print("");
121 //
122 Int_t det = digit.GetSector(0);
123 Int_t quad = digit.GetSector(1);
124 Int_t pedindex = -1;
125 //printf("\n\t #%d det %d quad %d", iDigit, det, quad);
126 //
127 if(det == 1){ // *** ZN1
128 pedindex = quad;
129 tZN1CorrHG[quad] = (Float_t) (digit.GetADCValue(0)-meanPed[pedindex]);
130 if(tZN1CorrHG[quad]<0.) tZN1CorrHG[quad] = 0.;
131 tZN1CorrLG[quad] = (Float_t) (digit.GetADCValue(1)-meanPed[pedindex+5]);
132 if(tZN1CorrLG[quad]<0.) tZN1CorrLG[quad] = 0.;
133 //printf("\t pedindex %d tZN1CorrHG[%d] = %1.0f tZN1CorrLG[%d] = %1.0f",
134 // pedindex, quad, tZN1CorrHG[quad], quad, tZN1CorrLG[quad]);
135 }
136 else if(det == 2){ // *** ZP1
137 pedindex = quad+10;
138 tZP1CorrHG[quad] = (Float_t) (digit.GetADCValue(0)-meanPed[pedindex]);
139 if(tZP1CorrLG[quad]<0.) tZP1CorrLG[quad] = 0.;
140 tZP1CorrLG[quad] = (Float_t) (digit.GetADCValue(1)-meanPed[pedindex+5]);
141 if(tZP1CorrHG[quad]<0.) tZP1CorrHG[quad] = 0.;
142 //printf("\t pedindex %d tZP1CorrHG[%d] = %1.0f tZP1CorrLG[%d] = %1.0f",
143 // pedindex, quad, tZP1CorrHG[quad], quad, tZP1CorrLG[quad]);
144 }
145 else if(det == 3){
146 if(quad == 1){ // *** ZEM1
147 pedindex = quad+19;
148 dZEMCorrHG += (Float_t) (digit.GetADCValue(0)-meanPed[pedindex]);
149 if(dZEMCorrHG<0.) dZEMCorrHG = 0.;
150 dZEMCorrLG += (Float_t) (digit.GetADCValue(1)-meanPed[pedindex+2]);
151 if(dZEMCorrLG<0.) dZEMCorrLG = 0.;
152 //printf("\t pedindex %d ADC(0) = %d ped = %1.0f ADCCorr = %1.0f\n",
153 // pedindex, digit.GetADCValue(0), meanPed[pedindex], dZEMCorrHG);
154 //printf("\t pedindex %d ADC(1) = %d ped = %1.0f ADCCorr = %1.0f\n",
155 // pedindex+2, digit.GetADCValue(1), meanPed[pedindex+2], dZEMCorrLG);
156 ////printf("\t pedindex %d dZEMCorrHG = %1.0f dZEMCorrLG = %1.0f\n", pedindex, dZEMCorrHG, dZEMCorrLG);
157 }
158 else if(quad == 2){ // *** ZEM1
159 pedindex = quad+19;
160 dZEMCorrHG += (Float_t) (digit.GetADCValue(0)-meanPed[pedindex]);
161 if(dZEMCorrHG<0.) dZEMCorrHG = 0.;
162 dZEMCorrLG += (Float_t) (digit.GetADCValue(1)-meanPed[pedindex+2]);
163 if(dZEMCorrLG<0.) dZEMCorrLG = 0.;
164 //printf("\t pedindex %d ADC(0) = %d ped = %1.0f ADCCorr = %1.0f\n",
165 // pedindex, digit.GetADCValue(0), meanPed[pedindex], dZEMCorrHG);
166 //printf("\t pedindex %d ADC(1) = %d ped = %1.0f ADCCorr = %1.0f\n",
167 // pedindex+2, digit.GetADCValue(1),meanPed[pedindex+2], dZEMCorrLG);
168 ////printf("\t pedindex %d dZEMCorrHG = %1.0f dZEMCorrLG = %1.0f\n", pedindex, dZEMCorrHG, dZEMCorrLG);
169 }
170 }
171 else if(det == 4){ // *** ZN2
172 pedindex = quad+24;
173 tZN2CorrHG[quad] = (Float_t) (digit.GetADCValue(0)-meanPed[pedindex]);
174 if(tZN2CorrHG[quad]<0.) tZN2CorrHG[quad] = 0.;
175 tZN2CorrLG[quad] = (Float_t) (digit.GetADCValue(1)-meanPed[pedindex+5]);
176 if(tZN2CorrLG[quad]<0.) tZN2CorrLG[quad] = 0.;
177 //printf("\t pedindex %d tZN2CorrHG[%d] = %1.0f tZN2CorrLG[%d] = %1.0f\n",
178 // pedindex, quad, tZN2CorrHG[quad], quad, tZN2CorrLG[quad]);
179 }
180 else if(det == 5){ // *** ZP2
181 pedindex = quad+34;
182 tZP2CorrHG[quad] = (Float_t) (digit.GetADCValue(0)-meanPed[pedindex]);
183 if(tZP2CorrHG[quad]<0.) tZP2CorrHG[quad] = 0.;
184 tZP2CorrLG[quad] = (Float_t) (digit.GetADCValue(1)-meanPed[pedindex+5]);
185 if(tZP2CorrLG[quad]<0.) tZP2CorrLG[quad] = 0.;
186 //printf("\t pedindex %d tZP2CorrHG[%d] = %1.0f tZP2CorrLG[%d] = %1.0f\n",
187 // pedindex, quad, tZP2CorrHG[quad], quad, tZP2CorrLG[quad]);
188 }
189 }
190
191 // reconstruct the event
192 ReconstructEvent(clustersTree, tZN1CorrHG, tZP1CorrHG, tZN2CorrHG,
193 tZP2CorrHG, tZN1CorrLG, tZP1CorrLG, tZN2CorrLG,
194 tZP2CorrLG, dZEMCorrHG);
195
196}
197
198//_____________________________________________________________________________
199void AliZDCReconstructor::Reconstruct(AliRawReader* rawReader, TTree* clustersTree) const
200{
201 // *** ZDC raw data reconstruction
202 // Works on the current event
203
204 // Retrieving calibration data
205 Float_t meanPed[47];
206 for(Int_t jj=0; jj<47; jj++) meanPed[jj] = fCalibData->GetMeanPed(jj);
207
208 rawReader->Reset();
209
210 // loop over raw data rawDatas
211 Float_t tZN1CorrHG[]={0.,0.,0.,0.,0.}, tZP1CorrHG[]={0.,0.,0.,0.,0.};
212 Float_t dZEMCorrHG=0.;
213 Float_t tZN2CorrHG[]={0.,0.,0.,0.,0.}, tZP2CorrHG[]={0.,0.,0.,0.,0.};
214 Float_t tZN1CorrLG[]={0.,0.,0.,0.,0.}, tZP1CorrLG[]={0.,0.,0.,0.,0.};
215 Float_t dZEMCorrLG=0.;
216 Float_t tZN2CorrLG[]={0.,0.,0.,0.,0.}, tZP2CorrLG[]={0.,0.,0.,0.,0.};
217 //
218 AliZDCRawStream rawData(rawReader);
219 while (rawData.Next()) {
220 if(rawData.IsADCDataWord()){
221 Int_t det = rawData.GetSector(0);
222 Int_t quad = rawData.GetSector(1);
223 Int_t gain = rawData.GetADCGain();
224 Int_t pedindex;
225 //
226 if(det == 1){
227 pedindex = quad;
228 if(gain == 0) tZN1CorrHG[quad] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]);
229 else tZN1CorrLG[quad] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex+5]);
230 }
231 else if(det == 2){
232 pedindex = quad+10;
233 if(gain == 0) tZP1CorrHG[quad] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]);
234 else tZP1CorrLG[quad] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex+5]);
235 }
236 else if(det == 3){
237 if(quad==1){
238 pedindex = quad+20;
239 if(gain == 0) dZEMCorrHG += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]);
240 else dZEMCorrLG += (Float_t) (rawData.GetADCValue()-meanPed[pedindex+2]);
241 }
242 else if(quad==2){
243 pedindex = rawData.GetSector(1)+21;
244 if(gain == 0) dZEMCorrHG += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]);
245 else dZEMCorrLG += (Float_t) (rawData.GetADCValue()-meanPed[pedindex+2]);
246 }
247 }
248 else if(det == 4){
249 pedindex = rawData.GetSector(1)+24;
250 if(gain == 0) tZN2CorrHG[quad] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]);
251 else tZN2CorrLG[quad] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex+2]);
252 }
253 else if(det == 5){
254 pedindex = rawData.GetSector(1)+34;
255 if(gain == 0) tZP2CorrHG[quad] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]);
256 else tZP2CorrLG[quad] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex+5]);
257 }
258 }
259 }
260
261 // reconstruct the event
262 ReconstructEvent(clustersTree, tZN1CorrHG, tZP1CorrHG, tZN2CorrHG,
263 tZP2CorrHG, tZN1CorrLG, tZP1CorrLG, tZN2CorrLG,
264 tZP2CorrLG, dZEMCorrHG);
265
266}
267
268//_____________________________________________________________________________
269void AliZDCReconstructor::ReconstructEvent(TTree *clustersTree,
270 Float_t* ZN1ADCCorrHG, Float_t* ZP1ADCCorrHG,
271 Float_t* ZN2ADCCorrHG, Float_t* ZP2ADCCorrHG,
272 Float_t* ZN1ADCCorrLG, Float_t* ZP1ADCCorrLG,
273 Float_t* ZN2ADCCorrLG, Float_t* ZP2ADCCorrLG,
274 Float_t corrADCZEMHG) const
275{
276 // ***** Reconstruct one event
277
278 // *** RECONSTRUCTION FROM SIMULATED DATA
279 // It passes trhough the no. of phe which is known from simulations
280 // --- ADCchannel -> photoelectrons
281 // NB-> PM gain = 10^(5), ADC resolution = 6.4*10^(-7)
282 // Move to V965 (E.S.,15/09/04) NB-> PM gain = 10^(5), ADC resolution = 8*10^(-7)
283 //Float_t zn1phe, zp1phe, zemphe, zn2phe, zp2phe, convFactor = 0.08;
284 //zn1phe = ZN1Corr/convFactor;
285 //zp1phe = ZP1Corr/convFactor;
286 //zemphe = ZEMCorr/convFactor;
287 //zn2phe = ZN2Corr/convFactor;
288 //zp2phe = ZP2Corr/convFactor;
289 ////if AliDebug(1,Form("\n znphe = %f, zpphe = %f, zemphe = %f\n",znphe, zpphe, zemphe);
290 //
291 //// --- Energy calibration
292 //// Conversion factors for hadronic ZDCs goes from phe yield to TRUE
293 //// incident energy (conversion from GeV to TeV is included); while for EM
294 //// calos conversion is from light yield to detected energy calculated by
295 //// GEANT NB -> ZN and ZP conversion factors are constant since incident
296 //// spectators have all the same energy, ZEM energy is obtained through a
297 //// fit over the whole range of incident particle energies
298 //// (obtained with full HIJING simulations)
299 //Float_t zn1energy, zp1energy, zemenergy, zdc1energy, zn2energy, zp2energy, zdc2energy;
300 //Float_t zn1phexTeV=329., zp1phexTeV=369., zn2phexTeV=329., zp2phexTeV=369.;
301 //zn1energy = zn1phe/zn1phexTeV;
302 //zp1energy = zp1phe/zp1phexTeV;
303 //zdc1energy = zn1energy+zp1energy;
304 //zn2energy = zn2phe/zn2phexTeV;
305 //zp2energy = zp2phe/zp2phexTeV;
306 //zdc2energy = zn2energy+zp2energy;
307 //zemenergy = -4.81+0.3238*zemphe;
308 //if(zemenergy<0) zemenergy=0;
309 //// if AliDebug(1,Form(" znenergy = %f TeV, zpenergy = %f TeV, zdcenergy = %f GeV, "
310 //// "\n zemenergy = %f TeV\n", znenergy, zpenergy,
311 //// zdcenergy, zemenergy);
312 //// if(zdcenergy==0)
313 //// if AliDebug(1,Form("\n\n ### ATTENZIONE!!! -> ev# %d: znenergy = %f TeV, zpenergy = %f TeV, zdcenergy = %f GeV, "
314 //// " zemenergy = %f TeV\n\n", fMerger->EvNum(), znenergy, zpenergy, zdcenergy, zemenergy);
315
316 //
317 // *** RECONSTRUCTION FROM "REAL" DATA
318 //
319 // Retrieving calibration data
320 Float_t equalCoeffZN1[5], equalCoeffZP1[5], equalCoeffZN2[5], equalCoeffZP2[5];
321 for(Int_t ji=0; ji<5; ji++){
322 equalCoeffZN1[ji] = fCalibData->GetZN1EqualCoeff(ji);
323 equalCoeffZP1[ji] = fCalibData->GetZP1EqualCoeff(ji);
324 equalCoeffZN2[ji] = fCalibData->GetZN2EqualCoeff(ji);
325 equalCoeffZP2[ji] = fCalibData->GetZP2EqualCoeff(ji);
326 }
327 //
328 Float_t calibEne[4];
329 for(Int_t ij=0; ij<4; ij++) calibEne[ij] = fCalibData->GetEnCalib(ij);
330 //
331 Float_t endPointZEM = fCalibData->GetZEMEndValue();
332 Float_t cutFractionZEM = fCalibData->GetZEMCutFraction();
333 Float_t dZEMSup = fCalibData->GetDZEMSup();
334 Float_t dZEMInf = fCalibData->GetDZEMInf();
335 //
336 Float_t cutValueZEM = endPointZEM*cutFractionZEM;
337 Float_t supValueZEM = cutValueZEM+(endPointZEM*dZEMSup);
338 Float_t infValueZEM = cutValueZEM-(endPointZEM*dZEMInf);
339 //
340 Float_t maxValEZN1 = fCalibData->GetEZN1MaxValue();
341 Float_t maxValEZP1 = fCalibData->GetEZP1MaxValue();
342 Float_t maxValEZDC1 = fCalibData->GetEZDC1MaxValue();
343 Float_t maxValEZN2 = fCalibData->GetEZN2MaxValue();
344 Float_t maxValEZP2 = fCalibData->GetEZP2MaxValue();
345 Float_t maxValEZDC2 = fCalibData->GetEZDC2MaxValue();
346 //
347 //printf("\n\t AliZDCReconstructor -> ZEMEndPoint %1.0f, ZEMCutValue %1.0f,"
348 // " ZEMSupValue %1.0f, ZEMInfValue %1.0f\n",endPointZEM,cutValueZEM,supValueZEM,infValueZEM);
349
350 // Equalization of detector responses
351 Float_t equalTowZN1HG[5], equalTowZN2HG[5], equalTowZP1HG[5], equalTowZP2HG[5];
352 Float_t equalTowZN1LG[5], equalTowZN2LG[5], equalTowZP1LG[5], equalTowZP2LG[5];
353 for(Int_t gi=0; gi<5; gi++){
354 equalTowZN1HG[gi] = ZN1ADCCorrHG[gi]*equalCoeffZN1[gi];
355 equalTowZP1HG[gi] = ZP1ADCCorrHG[gi]*equalCoeffZP1[gi];
356 equalTowZN2HG[gi] = ZN2ADCCorrHG[gi]*equalCoeffZN2[gi];
357 equalTowZP2HG[gi] = ZP2ADCCorrHG[gi]*equalCoeffZP2[gi];
358 //
359 equalTowZN1LG[gi] = ZN1ADCCorrLG[gi]*equalCoeffZN1[gi];
360 equalTowZP1LG[gi] = ZP1ADCCorrLG[gi]*equalCoeffZP1[gi];
361 equalTowZN2LG[gi] = ZN2ADCCorrLG[gi]*equalCoeffZN2[gi];
362 equalTowZP2LG[gi] = ZP2ADCCorrLG[gi]*equalCoeffZP2[gi];
363 }
364
365 // Energy calibration of detector responses
366 Float_t calibTowZN1HG[5], calibTowZN2HG[5], calibTowZP1HG[5], calibTowZP2HG[5];
367 Float_t calibSumZN1HG=0., calibSumZN2HG=0., calibSumZP1HG=0., calibSumZP2HG=0.;
368 Float_t calibTowZN1LG[5], calibTowZN2LG[5], calibTowZP1LG[5], calibTowZP2LG[5];
369 Float_t calibSumZN1LG=0., calibSumZN2LG=0., calibSumZ12LG=0., calibSumZP2LG=0.;
370 for(Int_t gi=0; gi<5; gi++){
371 calibTowZN1HG[gi] = equalTowZN1HG[gi]*calibEne[0];
372 calibTowZP1HG[gi] = equalTowZP1HG[gi]*calibEne[1];
373 calibTowZN2HG[gi] = equalTowZN2HG[gi]*calibEne[2];
374 calibTowZP2HG[gi] = equalTowZP2HG[gi]*calibEne[3];
375 calibSumZN1HG += calibTowZN1HG[gi];
376 calibSumZP1HG += calibTowZP1HG[gi];
377 calibSumZN2HG += calibTowZN2HG[gi];
378 calibSumZP2HG += calibTowZP2HG[gi];
379 //
380 calibTowZN1LG[gi] = equalTowZN1LG[gi]*calibEne[0];
381 calibTowZP1LG[gi] = equalTowZP1LG[gi]*calibEne[1];
382 calibTowZN2LG[gi] = equalTowZN2LG[gi]*calibEne[2];
383 calibTowZP2LG[gi] = equalTowZP2LG[gi]*calibEne[3];
384 calibSumZN1LG += calibTowZN1LG[gi];
385 calibSumZ12LG += calibTowZP1LG[gi];
386 calibSumZN2LG += calibTowZN2LG[gi];
387 calibSumZP2LG += calibTowZP2LG[gi];
388 }
389
390 // --- Number of detected spectator nucleons
391 // *** N.B. -> It works only in Pb-Pb
392 Int_t nDetSpecNLeft, nDetSpecPLeft, nDetSpecNRight, nDetSpecPRight;
393 nDetSpecNLeft = (Int_t) (calibSumZN1HG/2.760);
394 nDetSpecPLeft = (Int_t) (calibSumZP1HG/2.760);
395 nDetSpecNRight = (Int_t) (calibSumZN2HG/2.760);
396 nDetSpecPRight = (Int_t) (calibSumZP2HG/2.760);
397 /*printf("\n\t AliZDCReconstructor -> nDetSpecNLeft %d, nDetSpecPLeft %d,"
398 " nDetSpecNRight %d, nDetSpecPRight %d\n",nDetSpecNLeft, nDetSpecPLeft,
399 nDetSpecNRight, nDetSpecPRight);*/
400
401 // --- Number of generated spectator nucleons (from HIJING parameterization)
402 Int_t nGenSpecNLeft=0, nGenSpecPLeft=0, nGenSpecLeft=0;
403 Int_t nGenSpecNRight=0, nGenSpecPRight=0, nGenSpecRight=0;
404 Double_t impPar=0.;
405 //
406 // *** RECONSTRUCTION FROM SIMULATED DATA
407 // Cut value for Ezem (GeV)
408 // ### Results from production -> 0<b<18 fm (Apr 2002)
409 /*Float_t eZEMCut = 420.;
410 Float_t deltaEZEMSup = 690.;
411 Float_t deltaEZEMInf = 270.;
412 if(zemenergy > (eZEMCut+deltaEZEMSup)){
413 nGenSpecNLeft = (Int_t) (fZNCen->Eval(ZN1CalibSum));
414 nGenSpecPLeft = (Int_t) (fZPCen->Eval(ZP1CalibSum));
415 nGenSpecLeft = (Int_t) (fZDCCen->Eval(ZN1CalibSum+ZP1CalibSum));
416 nGenSpecNRight = (Int_t) (fZNCen->Eval(ZN2CalibSum));
417 nGenSpecPRight = (Int_t) (fZNCen->Eval(ZP2CalibSum));
418 nGenSpecRight = (Int_t) (fZNCen->Eval(ZN2CalibSum+ZP2CalibSum));
419 impPar = fbCen->Eval(ZN1CalibSum+ZP1CalibSum);
420 }
421 else if(zemenergy < (eZEMCut-deltaEZEMInf)){
422 nGenSpecNLeft = (Int_t) (fZNPer->Eval(ZN1CalibSum));
423 nGenSpecPLeft = (Int_t) (fZPPer->Eval(ZP1CalibSum));
424 nGenSpecLeft = (Int_t) (fZDCPer->Eval(ZN1CalibSum+ZP1CalibSum));
425 impPar = fbPer->Eval(ZN1CalibSum+ZP1CalibSum);
426 }
427 else if(zemenergy >= (eZEMCut-deltaEZEMInf) && zemenergy <= (eZEMCut+deltaEZEMSup)){
428 nGenSpecNLeft = (Int_t) (fZEMn->Eval(zemenergy));
429 nGenSpecPLeft = (Int_t) (fZEMp->Eval(zemenergy));
430 nGenSpecLeft = (Int_t)(fZEMsp->Eval(zemenergy));
431 impPar = fZEMb->Eval(zemenergy);
432 }
433 // ### Results from production -> 0<b<18 fm (Apr 2002)
434 if(ZN1CalibSum>162.) nGenSpecNLeft = (Int_t) (fZEMn->Eval(zemenergy));
435 if(ZP1CalibSum>59.75) nGenSpecPLeft = (Int_t) (fZEMp->Eval(zemenergy));
436 if(ZN1CalibSum+ZP1CalibSum>221.5) nGenSpecLeft = (Int_t)(fZEMsp->Eval(zemenergy));
437 if(ZN1CalibSum+ZP1CalibSum>220.) impPar = fZEMb->Eval(zemenergy);
438 */
439 //
440 //
441 // *** RECONSTRUCTION FROM REAL DATA
c0aec6f6 442 //
a4cab348 443 if(corrADCZEMHG > supValueZEM){
444 nGenSpecNLeft = (Int_t) (fZNCen->Eval(calibSumZN1HG));
445 nGenSpecPLeft = (Int_t) (fZPCen->Eval(calibSumZP1HG));
446 nGenSpecLeft = (Int_t) (fZDCCen->Eval(calibSumZN1HG+calibSumZP1HG));
447 nGenSpecNRight = (Int_t) (fZNCen->Eval(calibSumZN2HG));
448 nGenSpecPRight = (Int_t) (fZNCen->Eval(calibSumZP2HG));
449 nGenSpecRight = (Int_t) (fZNCen->Eval(calibSumZN2HG+calibSumZP2HG));
450 impPar = fbCen->Eval(calibSumZN1HG+calibSumZP1HG);
646f1679 451 }
a4cab348 452 else if(corrADCZEMHG < infValueZEM){
453 nGenSpecNLeft = (Int_t) (fZNPer->Eval(calibSumZN1HG));
454 nGenSpecPLeft = (Int_t) (fZPPer->Eval(calibSumZP1HG));
455 nGenSpecLeft = (Int_t) (fZDCPer->Eval(calibSumZN1HG+calibSumZP1HG));
456 impPar = fbPer->Eval(calibSumZN1HG+calibSumZP1HG);
646f1679 457 }
a4cab348 458 else if(corrADCZEMHG >= infValueZEM && corrADCZEMHG <= supValueZEM){
459 nGenSpecNLeft = (Int_t) (fZEMn->Eval(corrADCZEMHG));
460 nGenSpecPLeft = (Int_t) (fZEMp->Eval(corrADCZEMHG));
461 nGenSpecLeft = (Int_t)(fZEMsp->Eval(corrADCZEMHG));
462 impPar = fZEMb->Eval(corrADCZEMHG);
646f1679 463 }
464 //
a4cab348 465 if(calibSumZN1HG/maxValEZN1>1.) nGenSpecNLeft = (Int_t) (fZEMn->Eval(corrADCZEMHG));
466 if(calibSumZP1HG/maxValEZP1>1.) nGenSpecPLeft = (Int_t) (fZEMp->Eval(corrADCZEMHG));
467 if((calibSumZN1HG+calibSumZP1HG/maxValEZDC1)>1.){
468 nGenSpecLeft = (Int_t)(fZEMsp->Eval(corrADCZEMHG));
469 impPar = fZEMb->Eval(corrADCZEMHG);
646f1679 470 }
a4cab348 471 if(calibSumZN2HG/maxValEZN2>1.) nGenSpecNRight = (Int_t) (fZEMn->Eval(corrADCZEMHG));
472 if(calibSumZP2HG/maxValEZP2>1.) nGenSpecPRight = (Int_t) (fZEMp->Eval(corrADCZEMHG));
473 if((calibSumZN2HG+calibSumZP2HG/maxValEZDC2)>1.) nGenSpecRight = (Int_t)(fZEMsp->Eval(corrADCZEMHG));
646f1679 474 //
475 if(nGenSpecNLeft>125) nGenSpecNLeft=125;
476 else if(nGenSpecNLeft<0) nGenSpecNLeft=0;
477 if(nGenSpecPLeft>82) nGenSpecPLeft=82;
478 else if(nGenSpecPLeft<0) nGenSpecPLeft=0;
479 if(nGenSpecLeft>207) nGenSpecLeft=207;
480 else if(nGenSpecLeft<0) nGenSpecLeft=0;
8309c1ab 481
980685f2 482 // --- Number of generated participants (from HIJING parameterization)
646f1679 483 Int_t nPart, nPartTotLeft, nPartTotRight;
484 nPart = 207-nGenSpecNLeft-nGenSpecPLeft;
485 nPartTotLeft = 207-nGenSpecLeft;
486 nPartTotRight = 207-nGenSpecRight;
e90a5fef 487 if(nPart<0) nPart=0;
488 if(nPartTotLeft<0) nPartTotLeft=0;
489 if(nPartTotRight<0) nPartTotRight=0;
e97af564 490 //
e90a5fef 491 // *** DEBUG ***
422ed0d5 492 printf("\n\t AliZDCReconstructor -> calibSumZN1HG %1.0f, calibSumZP1HG %1.0f,"
e90a5fef 493 " calibSumZN2HG %1.0f, calibSumZP2HG %1.0f, corrADCZEMHG %1.0f\n",
494 calibSumZN1HG,calibSumZP1HG,calibSumZN2HG,calibSumZP2HG,corrADCZEMHG);
495 printf("\t AliZDCReconstructor -> nGenSpecNLeft %d, nGenSpecPLeft %d, nGenSpecLeft %d\n"
496 "\t\t nGenSpecNRight %d, nGenSpecPRight %d, nGenSpecRight %d\n",
497 nGenSpecNLeft, nGenSpecPLeft, nGenSpecLeft,
498 nGenSpecNRight, nGenSpecPRight, nGenSpecRight);
499 printf("\t AliZDCReconstructor -> NpartL %d, NpartR %d, b %1.2f fm\n\n",nPartTotLeft, nPartTotRight, impPar);
422ed0d5 500
646f1679 501 // create the output tree
a4cab348 502 AliZDCReco reco(calibSumZN1HG, calibSumZP1HG, calibSumZN2HG, calibSumZP2HG,
503 calibTowZN1LG, calibTowZN2LG, calibTowZP1LG, calibTowZP2LG,
f5d41205 504 corrADCZEMHG,
646f1679 505 nDetSpecNLeft, nDetSpecPLeft, nDetSpecNRight, nDetSpecPRight,
506 nGenSpecNLeft, nGenSpecPLeft, nGenSpecLeft, nGenSpecNRight,
507 nGenSpecPRight, nGenSpecRight,
508 nPartTotLeft, nPartTotRight, impPar);
509
8309c1ab 510 AliZDCReco* preco = &reco;
511 const Int_t kBufferSize = 4000;
70f04f6d 512 clustersTree->Branch("ZDC", "AliZDCReco", &preco, kBufferSize);
8309c1ab 513
514 // write the output tree
70f04f6d 515 clustersTree->Fill();
8309c1ab 516}
517
518//_____________________________________________________________________________
70f04f6d 519void AliZDCReconstructor::FillZDCintoESD(TTree *clustersTree, AliESDEvent* esd) const
8309c1ab 520{
70f04f6d 521 // fill energies and number of participants to the ESD
8309c1ab 522
8309c1ab 523 AliZDCReco reco;
524 AliZDCReco* preco = &reco;
70f04f6d 525 clustersTree->SetBranchAddress("ZDC", &preco);
8309c1ab 526
70f04f6d 527 clustersTree->GetEntry(0);
1c2caeca 528 /*Double_t tZN1Ene[4], tZN2Ene[4];
e90a5fef 529 for(Int_t i=0; i<4; i++){
530 tZN1Ene[i] = reco.GetZN1EnTow(i);
531 tZN2Ene[i] = reco.GetZN2EnTow(i);
532 }
533 esd->SetZDC(tZN1Ene, tZN2Ene, reco.GetZN1Energy(), reco.GetZP1Energy(), reco.GetZEMsignal(),
646f1679 534 reco.GetZN2Energy(), reco.GetZP2Energy(),
535 reco.GetNPartLeft());
1c2caeca 536 */
f5d41205 537 esd->SetZDC(reco.GetZN1Energy(), reco.GetZP1Energy(), reco.GetZEMsignal(),
422ed0d5 538 reco.GetZN2Energy(), reco.GetZP2Energy(),
1c2caeca 539 reco.GetNPartLeft());
422ed0d5 540
a4cab348 541 /*Double_t tZN1Ene[4], tZN2Ene[4];
542 for(Int_t i=0; i<4; i++){
543 tZN1Ene[i] = reco.GetZN1EnTow(i);
544 tZN2Ene[i] = reco.GetZN2EnTow(i);
545 }*/
546 //esd->SetZN1TowerEnergy(tZN1Ene);
547 //esd->SetZN2TowerEnergy(tZN2Ene);
548
8309c1ab 549}
48642b09 550
551//_____________________________________________________________________________
78d18275 552AliCDBStorage* AliZDCReconstructor::SetStorage(const char *uri)
48642b09 553{
cc2abffd 554 // Setting the storage
48642b09 555
78d18275 556 Bool_t deleteManager = kFALSE;
48642b09 557
78d18275 558 AliCDBManager *manager = AliCDBManager::Instance();
559 AliCDBStorage *defstorage = manager->GetDefaultStorage();
48642b09 560
78d18275 561 if(!defstorage || !(defstorage->Contains("ZDC"))){
562 AliWarning("No default storage set or default storage doesn't contain ZDC!");
563 manager->SetDefaultStorage(uri);
564 deleteManager = kTRUE;
565 }
566
567 AliCDBStorage *storage = manager->GetDefaultStorage();
568
569 if(deleteManager){
570 AliCDBManager::Instance()->UnsetDefaultStorage();
571 defstorage = 0; // the storage is killed by AliCDBManager::Instance()->Destroy()
572 }
573
574 return storage;
575}
48642b09 576
78d18275 577//_____________________________________________________________________________
4fda3ba1 578AliZDCCalibData* AliZDCReconstructor::GetCalibData() const
78d18275 579{
48642b09 580
4fda3ba1 581 // Getting calibration object for ZDC set
582
583 AliCDBEntry *entry = AliCDBManager::Instance()->Get("ZDC/Calib/Data");
457a440d 584 if(!entry) AliFatal("No calibration data loaded!");
4fda3ba1 585
457a440d 586 AliZDCCalibData *calibdata = dynamic_cast<AliZDCCalibData*> (entry->GetObject());
587 if(!calibdata) AliFatal("Wrong calibration object in calibration file!");
48642b09 588
78d18275 589 return calibdata;
48642b09 590}