Handling of missaligned geometry. Function transform added. Transform cluster positio...
[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 *
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 "AliESD.h"
30#include "AliZDCDigit.h"
31#include "AliZDCRawStream.h"
32#include "AliZDCReco.h"
33#include "AliZDCReconstructor.h"
48642b09 34#include "AliZDCCalibData.h"
8309c1ab 35
36
37ClassImp(AliZDCReconstructor)
38
39
40//_____________________________________________________________________________
41AliZDCReconstructor:: AliZDCReconstructor()
42{
48642b09 43 // **** Default constructor
78d18275 44 fStorage = 0;
8309c1ab 45
46 // --- Number of generated spectator nucleons and impact parameter
47 // --------------------------------------------------------------------------------------------------
8309c1ab 48 // [1] ### Results from a new production -> 0<b<18 fm (Apr 2002)
49 // Fit results for neutrons (Nspectator n true vs. EZN)
50 fZNCen = new TF1("fZNCen",
51 "(-2.287920+sqrt(2.287920*2.287920-4*(-0.007629)*(11.921710-x)))/(2*(-0.007629))",0.,164.);
52 fZNPer = new TF1("fZNPer",
53 "(-37.812280-sqrt(37.812280*37.812280-4*(-0.190932)*(-1709.249672-x)))/(2*(-0.190932))",0.,164.);
54 // Fit results for protons (Nspectator p true vs. EZP)
55 fZPCen = new TF1("fZPCen",
56 "(-1.321353+sqrt(1.321353*1.321353-4*(-0.007283)*(3.550697-x)))/(2*(-0.007283))",0.,60.);
57 fZPPer = new TF1("fZPPer",
58 "(-42.643308-sqrt(42.643308*42.643308-4*(-0.310786)*(-1402.945615-x)))/(2*(-0.310786))",0.,60.);
59 // Fit results for total number of spectators (Nspectators true vs. EZDC)
60 fZDCCen = new TF1("fZDCCen",
61 "(-1.934991+sqrt(1.934991*1.934991-4*(-0.004080)*(15.111124-x)))/(2*(-0.004080))",0.,225.);
62 fZDCPer = new TF1("fZDCPer",
63 "(-34.380639-sqrt(34.380639*34.380639-4*(-0.104251)*(-2612.189017-x)))/(2*(-0.104251))",0.,225.);
64 // --------------------------------------------------------------------------------------------------
48642b09 65 // Fit results for b (b vs. EZDC)
8309c1ab 66 // [2] ### Results from a new production -> 0<b<18 fm (Apr 2002)
67 fbCen = new TF1("fbCen","-0.056923+0.079703*x-0.0004301*x*x+0.000001366*x*x*x",0.,220.);
68 fbPer = new TF1("fbPer","17.943998-0.046846*x+0.000074*x*x",0.,220.);
69 // --------------------------------------------------------------------------------------------------
70 // Evaluating Nspectators and b from ZEM energy
8309c1ab 71 // [2] ### Results from a new production -> 0<b<18 fm (Apr 2002)
72 fZEMn = new TF1("fZEMn","126.2-0.05399*x+0.000005679*x*x",0.,4000.);
73 fZEMp = new TF1("fZEMp","82.49-0.03611*x+0.00000385*x*x",0.,4000.);
74 fZEMsp = new TF1("fZEMsp","208.7-0.09006*x+0.000009526*x*x",0.,4000.);
75 fZEMb = new TF1("fZEMb","16.06-0.01633*x+1.44e-5*x*x-6.778e-9*x*x*x+1.438e-12*x*x*x*x-1.112e-16*x*x*x*x*x",0.,4000.);
78d18275 76
77 // Setting storage
78 fStorage = SetStorage("local://$ALICE_ROOT");
79
80 // Get calibration data
81 int runNumber = 0;
82 fCalibData = GetCalibData(runNumber);
8309c1ab 83}
84
85//_____________________________________________________________________________
86AliZDCReconstructor::AliZDCReconstructor(const AliZDCReconstructor&
87 reconstructor):
88 AliReconstructor(reconstructor)
89{
90// copy constructor
91
92 Fatal("AliZDCReconstructor", "copy constructor not implemented");
93}
94
95//_____________________________________________________________________________
96AliZDCReconstructor& AliZDCReconstructor::operator =
97 (const AliZDCReconstructor& /*reconstructor*/)
98{
99// assignment operator
100
101 Fatal("operator =", "assignment operator not implemented");
102 return *this;
103}
104
105//_____________________________________________________________________________
106AliZDCReconstructor::~AliZDCReconstructor()
107{
108// destructor
109
110 delete fZNCen;
111 delete fZNPer;
112 delete fZPCen;
113 delete fZPPer;
114 delete fZDCCen;
115 delete fZDCPer;
116 delete fbCen;
117 delete fbPer;
118 delete fZEMn;
119 delete fZEMp;
120 delete fZEMsp;
121 delete fZEMb;
122}
123
124
125//_____________________________________________________________________________
126void AliZDCReconstructor::Reconstruct(AliRunLoader* runLoader) const
127{
48642b09 128 // *** Local ZDC reconstruction for digits
78d18275 129
48642b09 130 Float_t meanPed[47];
78d18275 131 for(Int_t jj=0; jj<47; jj++) meanPed[jj] = fCalibData->GetMeanPed(jj);
8309c1ab 132
133 AliLoader* loader = runLoader->GetLoader("ZDCLoader");
134 if (!loader) return;
135 loader->LoadDigits("read");
136 loader->LoadRecPoints("recreate");
137 AliZDCDigit digit;
138 AliZDCDigit* pdigit = &digit;
139
140 // Event loop
141 for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
142 runLoader->GetEvent(iEvent);
143
144 // load digits
145 loader->LoadDigits();
146 TTree* treeD = loader->TreeD();
147 if (!treeD) continue;
148 treeD->SetBranchAddress("ZDC", &pdigit);
149
150 // loop over digits
980685f2 151 Float_t zn1corr=0, zp1corr=0, zn2corr=0, zp2corr=0, zemcorr=0;
8309c1ab 152 for (Int_t iDigit = 0; iDigit < treeD->GetEntries(); iDigit++) {
153 treeD->GetEntry(iDigit);
154 if (!pdigit) continue;
155
48642b09 156 if(digit.GetSector(0) == 1)
980685f2 157 zn1corr += (Float_t) (digit.GetADCValue(0)-meanPed[digit.GetSector(1)]); // high gain ZN1 ADCs
48642b09 158 else if(digit.GetSector(0) == 2)
980685f2 159 zp1corr += (Float_t) (digit.GetADCValue(0)-meanPed[digit.GetSector(1)+10]); // high gain ZP1 ADCs
48642b09 160 else if(digit.GetSector(0) == 3){
78d18275 161 if(digit.GetSector(1)==1)
980685f2 162 zemcorr += (Float_t) (digit.GetADCValue(0)-meanPed[digit.GetSector(1)+20]); // high gain ZEM1 ADCs
78d18275 163 else if(digit.GetSector(1)==2)
980685f2 164 zemcorr += (Float_t) (digit.GetADCValue(0)-meanPed[digit.GetSector(1)+22]); // high gain ZEM2 ADCs
48642b09 165 }
980685f2 166 else if(digit.GetSector(0) == 4)
167 zn2corr += (Float_t) (digit.GetADCValue(0)-meanPed[digit.GetSector(1)+24]); // high gain ZN2 ADCs
168 else if(digit.GetSector(0) == 5)
169 zp2corr += (Float_t) (digit.GetADCValue(0)-meanPed[digit.GetSector(1)+34]); // high gain ZP2 ADCs
8309c1ab 170 }
980685f2 171 if(zn1corr<0) zn1corr=0;
172 if(zp1corr<0) zp1corr=0;
173 if(zn2corr<0) zn2corr=0;
174 if(zp2corr<0) zp2corr=0;
175 if(zemcorr<0) zemcorr=0;
8309c1ab 176
177 // reconstruct the event
78d18275 178 //printf("\n \t ZDCReco from digits-> Ev.#%d ZN = %.0f, ZP = %.0f, ZEM = %.0f\n",iEvent,zncorr,zpcorr,zemcorr);
980685f2 179 ReconstructEvent(loader, zn1corr, zp1corr, zemcorr, zn2corr, zp2corr);
8309c1ab 180 }
181
182 loader->UnloadDigits();
183 loader->UnloadRecPoints();
184}
185
186//_____________________________________________________________________________
187void AliZDCReconstructor::Reconstruct(AliRunLoader* runLoader,
188 AliRawReader* rawReader) const
189{
48642b09 190 // *** Local ZDC reconstruction for raw data
191
48642b09 192 Float_t meanPed[47];
78d18275 193 for(Int_t jj=0; jj<47; jj++) meanPed[jj] = fCalibData->GetMeanPed(jj);
8309c1ab 194
195 AliLoader* loader = runLoader->GetLoader("ZDCLoader");
196 if (!loader) return;
197 loader->LoadRecPoints("recreate");
198 // Event loop
199 Int_t iEvent = 0;
200 while (rawReader->NextEvent()) {
201 runLoader->GetEvent(iEvent++);
202
203 // loop over raw data digits
980685f2 204 Float_t zn1corr=0, zp1corr=0, zn2corr=0, zp2corr=0,zemcorr=0;
8309c1ab 205 AliZDCRawStream digit(rawReader);
206 while (digit.Next()) {
207 if(digit.IsADCDataWord()){
208 if(digit.GetADCGain() == 0){
980685f2 209 if(digit.GetSector(0) == 1)
210 zn1corr += (Float_t) (digit.GetADCValue()-meanPed[digit.GetSector(1)]); // high gain ZN1 ADCs;
211 else if(digit.GetSector(0) == 2)
212 zp1corr += (Float_t) (digit.GetADCValue()-meanPed[digit.GetSector(1)+10]); // high gain ZP1 ADCs;
213 else if(digit.GetSector(0) == 3)
214 if(digit.GetSector(1)==1)
215 zemcorr += (Float_t) (digit.GetADCValue()-meanPed[digit.GetSector(1)+20]); // high gain ZEM1 ADCs
216 else if(digit.GetSector(1)==2)
217 zemcorr += (Float_t) (digit.GetADCValue()-meanPed[digit.GetSector(1)+22]); // high gain ZEM2 ADCs
218 else if(digit.GetSector(0) == 4)
219 zn2corr += (Float_t) (digit.GetADCValue()-meanPed[digit.GetSector(1)+24]); // high gain ZN2 ADCs;
220 else if(digit.GetSector(0) == 5)
221 zp2corr += (Float_t) (digit.GetADCValue()-meanPed[digit.GetSector(1)+34]); // high gain ZP2 ADCs;
48642b09 222 }
8309c1ab 223 }
224 }
980685f2 225 if(zn1corr<0) zn1corr=0;
226 if(zp1corr<0) zp1corr=0;
227 if(zn2corr<0) zn2corr=0;
228 if(zp2corr<0) zp2corr=0;
48642b09 229 if(zemcorr<0) zemcorr=0;
230
8309c1ab 231 // reconstruct the event
78d18275 232 //printf("\n\t ZDCReco from raw-> Ev.#%d ZN = %.0f, ZP = %.0f, ZEM = %.0f\n",iEvent,zncorr,zpcorr,zemcorr);
980685f2 233 ReconstructEvent(loader, zn1corr, zp1corr, zemcorr, zn2corr, zp2corr);
8309c1ab 234 }
235
236 loader->UnloadRecPoints();
237}
238
239//_____________________________________________________________________________
980685f2 240void AliZDCReconstructor::ReconstructEvent(AliLoader* loader, Float_t zn1corr,
241 Float_t zp1corr, Float_t zemcorr, Float_t zn2corr, Float_t zp2corr) const
8309c1ab 242{
48642b09 243 // ***** Reconstruct one event
8309c1ab 244
245 // --- ADCchannel -> photoelectrons
246 // NB-> PM gain = 10^(5), ADC resolution = 6.4*10^(-7)
247 // Move to V965 (E.S.,15/09/04) NB-> PM gain = 10^(5), ADC resolution = 8*10^(-7)
980685f2 248 Float_t zn1phe, zp1phe, zemphe, zn2phe, zp2phe, convFactor = 0.08;
249 zn1phe = zn1corr/convFactor;
250 zp1phe = zp1corr/convFactor;
8309c1ab 251 zemphe = zemcorr/convFactor;
980685f2 252 zn2phe = zn2corr/convFactor;
253 zp2phe = zp2corr/convFactor;
48642b09 254 //if AliDebug(1,Form("\n znphe = %f, zpphe = %f, zemphe = %f\n",znphe, zpphe, zemphe);
8309c1ab 255
256 // --- Energy calibration
257 // Conversion factors for hadronic ZDCs goes from phe yield to TRUE
258 // incident energy (conversion from GeV to TeV is included); while for EM
259 // calos conversion is from light yield to detected energy calculated by
260 // GEANT NB -> ZN and ZP conversion factors are constant since incident
261 // spectators have all the same energy, ZEM energy is obtained through a
262 // fit over the whole range of incident particle energies
263 // (obtained with full HIJING simulations)
980685f2 264 Float_t zn1energy, zp1energy, zemenergy, zdc1energy, zn2energy, zp2energy, zdc2energy;
265 Float_t zn1phexTeV=329., zp1phexTeV=369., zn2phexTeV=329., zp2phexTeV=369.;
266 zn1energy = zn1phe/zn1phexTeV;
267 zp1energy = zp1phe/zp1phexTeV;
268 zdc1energy = zn1energy+zp1energy;
269 zn2energy = zn2phe/zn2phexTeV;
270 zp2energy = zp2phe/zp2phexTeV;
271 zdc2energy = zn2energy+zp2energy;
8309c1ab 272 zemenergy = -4.81+0.3238*zemphe;
273 if(zemenergy<0) zemenergy=0;
48642b09 274 // if AliDebug(1,Form(" znenergy = %f TeV, zpenergy = %f TeV, zdcenergy = %f GeV, "
275 // "\n zemenergy = %f TeV\n", znenergy, zpenergy,
276 // zdcenergy, zemenergy);
48642b09 277 // if(zdcenergy==0)
278 // if AliDebug(1,Form("\n\n ### ATTENZIONE!!! -> ev# %d: znenergy = %f TeV, zpenergy = %f TeV, zdcenergy = %f GeV, "
279 // " zemenergy = %f TeV\n\n", fMerger->EvNum(), znenergy, zpenergy, zdcenergy, zemenergy);
8309c1ab 280
980685f2 281 // --- Number of detected spectator nucleons
282 // *** N.B. -> It works only in Pb-Pb
283 Int_t nDetSpecNLeft, nDetSpecPLeft, nDetSpecNRight, nDetSpecPRight;
284 nDetSpecNLeft = (Int_t) (zn1energy/2.760);
285 nDetSpecPLeft = (Int_t) (zp1energy/2.760);
286 nDetSpecNRight = (Int_t) (zn2energy/2.760);
287 nDetSpecPRight = (Int_t) (zp2energy/2.760);
288
289 // --- Number of generated spectator nucleons (from HIJING parameterization)
290 // *** N.B. -> Only one side!!!
291 Int_t nGenSpecN=0, nGenSpecP=0, nGenSpec=0;
8309c1ab 292 Double_t impPar=0;
293 // Cut value for Ezem (GeV)
980685f2 294 // ### Results from production -> 0<b<18 fm (Apr 2002)
8309c1ab 295 Float_t eZEMCut = 420.;
296 Float_t deltaEZEMSup = 690.;
297 Float_t deltaEZEMInf = 270.;
298 if(zemenergy > (eZEMCut+deltaEZEMSup)){
980685f2 299 nGenSpecN = (Int_t) (fZNCen->Eval(zn1energy));
300 nGenSpecP = (Int_t) (fZPCen->Eval(zp1energy));
301 nGenSpec = (Int_t) (fZDCCen->Eval(zdc1energy));
302 impPar = fbCen->Eval(zdc1energy);
8309c1ab 303 }
304 else if(zemenergy < (eZEMCut-deltaEZEMInf)){
980685f2 305 nGenSpecN = (Int_t) (fZNPer->Eval(zn1energy));
306 nGenSpecP = (Int_t) (fZPPer->Eval(zp1energy));
307 nGenSpec = (Int_t) (fZDCPer->Eval(zdc1energy));
308 impPar = fbPer->Eval(zdc1energy);
8309c1ab 309 }
310 else if(zemenergy >= (eZEMCut-deltaEZEMInf) && zemenergy <= (eZEMCut+deltaEZEMSup)){
311 nGenSpecN = (Int_t) (fZEMn->Eval(zemenergy));
312 nGenSpecP = (Int_t) (fZEMp->Eval(zemenergy));
313 nGenSpec = (Int_t)(fZEMsp->Eval(zemenergy));
314 impPar = fZEMb->Eval(zemenergy);
8309c1ab 315 }
980685f2 316 // ### Results from production -> 0<b<18 fm (Apr 2002)
317 if(zn1energy>162.) nGenSpecN = (Int_t) (fZEMn->Eval(zemenergy));
318 if(zp1energy>59.75) nGenSpecP = (Int_t) (fZEMp->Eval(zemenergy));
319 if(zdc1energy>221.5) nGenSpec = (Int_t)(fZEMsp->Eval(zemenergy));
320 if(zdc1energy>220.) impPar = fZEMb->Eval(zemenergy);
8309c1ab 321
322 if(nGenSpecN>125) nGenSpecN=125;
323 else if(nGenSpecN<0) nGenSpecN=0;
324 if(nGenSpecP>82) nGenSpecP=82;
325 else if(nGenSpecP<0) nGenSpecP=0;
326 if(nGenSpec>207) nGenSpec=207;
327 else if(nGenSpec<0) nGenSpec=0;
8309c1ab 328
980685f2 329 // --- Number of generated participants (from HIJING parameterization)
8309c1ab 330 Int_t nPart, nPartTot;
331 nPart = 207-nGenSpecN-nGenSpecP;
332 nPartTot = 207-nGenSpec;
78d18275 333 //printf("\t ZDCeventReco-> ZNEn = %.0f GeV, ZPEn = %.0f GeV, ZEMEn = %.0f GeV\n",
334 // znenergy, zpenergy, zemenergy);
8309c1ab 335
336 // create the output tree
337 loader->MakeTree("R");
338 TTree* treeR = loader->TreeR();
980685f2 339 AliZDCReco reco(zn1energy, zp1energy, zdc1energy, zemenergy,
340 zn2energy, zp2energy, zdc2energy,
341 nDetSpecNLeft, nDetSpecPLeft, nDetSpecNRight, nDetSpecPRight,
342 nGenSpecN, nGenSpecP, nGenSpec,nPartTot, impPar);
8309c1ab 343 AliZDCReco* preco = &reco;
344 const Int_t kBufferSize = 4000;
345 treeR->Branch("ZDC", "AliZDCReco", &preco, kBufferSize);
346
347 // write the output tree
348 treeR->Fill();
349 loader->WriteRecPoints("OVERWRITE");
350}
351
352//_____________________________________________________________________________
353void AliZDCReconstructor::FillESD(AliRunLoader* runLoader,
354 AliESD* esd) const
355{
356// fill energies and number of participants to the ESD
357
358 AliLoader* loader = runLoader->GetLoader("ZDCLoader");
359 if (!loader) return;
360 loader->LoadRecPoints();
361
362 TTree* treeR = loader->TreeR();
363 if (!treeR) return;
364 AliZDCReco reco;
365 AliZDCReco* preco = &reco;
366 treeR->SetBranchAddress("ZDC", &preco);
367
368 treeR->GetEntry(0);
980685f2 369 esd->SetZDC(reco.GetZN1energy(), reco.GetZP1energy(), reco.GetZEMenergy(),
370 reco.GetZN2energy(), reco.GetZP2energy(), reco.GetNPart());
8309c1ab 371
372 loader->UnloadRecPoints();
373}
48642b09 374
375//_____________________________________________________________________________
78d18275 376AliCDBStorage* AliZDCReconstructor::SetStorage(const char *uri)
48642b09 377{
78d18275 378 //printf("\n\t AliZDCReconstructor::SetStorage \n");
48642b09 379
78d18275 380 Bool_t deleteManager = kFALSE;
48642b09 381
78d18275 382 AliCDBManager *manager = AliCDBManager::Instance();
383 AliCDBStorage *defstorage = manager->GetDefaultStorage();
48642b09 384
78d18275 385 if(!defstorage || !(defstorage->Contains("ZDC"))){
386 AliWarning("No default storage set or default storage doesn't contain ZDC!");
387 manager->SetDefaultStorage(uri);
388 deleteManager = kTRUE;
389 }
390
391 AliCDBStorage *storage = manager->GetDefaultStorage();
392
393 if(deleteManager){
394 AliCDBManager::Instance()->UnsetDefaultStorage();
395 defstorage = 0; // the storage is killed by AliCDBManager::Instance()->Destroy()
396 }
397
398 return storage;
399}
48642b09 400
78d18275 401//_____________________________________________________________________________
402AliZDCCalibData* AliZDCReconstructor::GetCalibData(int runNumber) const
403{
48642b09 404
78d18275 405 //printf("\n\t AliZDCReconstructor::GetCalibData \n");
406
407 AliCDBEntry *entry = fStorage->Get("ZDC/Calib/Data",runNumber);
408 AliZDCCalibData *calibdata = (AliZDCCalibData*) entry->GetObject();
409
410 if (!calibdata) AliWarning("No calibration data from calibration database !");
48642b09 411
78d18275 412 return calibdata;
48642b09 413}