Restoring EMCAL digitization and reconstruction
[u/mrichter/AliRoot.git] / TOF / AliTOFClusterFinder.cxx
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 /* 
17
18 Revision 0.03  2005/07/28 A. De Caro
19          Implement public method
20          Raw2Digits(Int_t, AliRawReader *)
21          to convert digits from raw data in MC digits
22          (temporary solution)
23
24 Revision 0.02  2005/07/27 A. De Caro
25          Implement public method
26          Digits2RecPoint(Int_t)
27          to convert digits in clusters
28
29 Revision 0.02  2005/07/26 A. De Caro
30          Implement private methods
31          InsertCluster(AliTOFcluster *)
32          FindClusterIndex(Double_t)
33          originally implemented in AliTOFtracker
34          by S. Arcelli and C. Zampolli
35
36 Revision 0.01  2005/07/25 A. De Caro
37          Implement public methods
38          Digits2RecPoint(AliRawReader *, TTree *)
39          Digits2RecPoint(Int_t, AliRawReader *)
40          to convert raw data in clusters
41  */
42
43 ////////////////////////////////////////////////////////////////
44 //                                                            //
45 //         Class for TOF cluster finder                       //
46 //                                                            //
47 // Starting from Raw Data, create rec points,                 //
48 //                         fill TreeR for TOF,                //
49 //                         write TOF.RecPoints.root file      //
50 //                                                            //
51 ////////////////////////////////////////////////////////////////
52
53 #include <Riostream.h>
54 #include <TTree.h>
55 #include <TObjArray.h>
56 #include <TClonesArray.h>
57
58 #include "AliLog.h"
59 #include "AliRunLoader.h"
60 #include "AliLoader.h"
61
62 #include "AliTOFdigit.h"
63 #include "AliTOFcluster.h"
64 #include "AliTOFGeometry.h"
65 #include "AliTOFRawStream.h"
66
67 #include "AliTOFClusterFinder.h"
68
69 ClassImp(AliTOFClusterFinder)
70
71 AliTOFClusterFinder::AliTOFClusterFinder():
72   fRunLoader(0),
73   fTOFLoader(0),
74   fTreeD(0),
75   fTreeR(0),
76   fDigits(new TClonesArray("AliTOFdigit", 4000)),
77   fRecPoints(new TClonesArray("AliTOFcluster", 4000)),
78   fNumberOfTofClusters(0)
79 {
80 //
81 // Constructor
82 //
83
84   fTOFGeometry = new AliTOFGeometry();
85
86 }
87 //______________________________________________________________________________
88
89 AliTOFClusterFinder::AliTOFClusterFinder(AliRunLoader* runLoader):
90   fRunLoader(runLoader),
91   fTOFLoader(runLoader->GetLoader("TOFLoader")),
92   fTreeD(0),
93   fTreeR(0),
94   fDigits(new TClonesArray("AliTOFdigit", 4000)),
95   fRecPoints(new TClonesArray("AliTOFcluster", 4000)),
96   fNumberOfTofClusters(0)
97 {
98 //
99 // Constructor
100 //
101
102   fTOFGeometry = new AliTOFGeometry();
103
104 }
105 //______________________________________________________________________________
106
107 AliTOFClusterFinder::~AliTOFClusterFinder()
108 {
109
110   //
111   // Destructor
112   //
113
114   if (fDigits)
115     {
116       fDigits->Delete();
117       delete fDigits;
118       fDigits=0;
119     }
120   if (fRecPoints)
121     {
122       fRecPoints->Delete();
123       delete fRecPoints;
124       fRecPoints=0;
125     }
126
127   delete fTOFGeometry;
128
129 }
130 //______________________________________________________________________________
131
132 void AliTOFClusterFinder::Digits2RecPoints(Int_t iEvent)
133 {
134   //
135   // Converts digits to recpoints for TOF
136   //
137
138   fRunLoader->GetEvent(iEvent);
139
140   fTreeD = fTOFLoader->TreeD();
141   if (fTreeD == 0x0)
142     {
143       AliFatal("AliTOFClusterFinder: Can not get TreeD");
144     }
145
146   TBranch *branch = fTreeD->GetBranch("TOF");
147   if (!branch) { 
148     AliError("can't get the branch with the TOF digits !");
149     return;
150   }
151
152   TClonesArray dummy("AliTOFdigit",10000), *digits=&dummy;
153   branch->SetAddress(&digits);
154
155   ResetRecpoint();
156
157   fTreeR = fTOFLoader->TreeR();
158   if (fTreeR == 0x0)
159     {
160       fTOFLoader->MakeTree("R");
161       fTreeR = fTOFLoader->TreeR();
162     }
163
164   Int_t bufsize = 32000;
165   fTreeR->Branch("TOF", &fRecPoints, bufsize);
166
167   fTreeD->GetEvent(0);
168   Int_t nDigits = digits->GetEntriesFast();
169   AliDebug(2,Form("Number of TOF digits: %d",nDigits));
170
171   Int_t ii, jj;
172   Int_t dig[5];
173   Float_t g[3];
174   Double_t h[5];
175   for (ii=0; ii<nDigits; ii++) {
176     AliTOFdigit *d = (AliTOFdigit*)digits->UncheckedAt(ii);
177     dig[0]=d->GetSector();
178     dig[1]=d->GetPlate();
179     dig[2]=d->GetStrip();
180     dig[3]=d->GetPadz();
181     dig[4]=d->GetPadx();
182
183     for (jj=0; jj<3; jj++) g[jj] = 0.;
184     fTOFGeometry->GetPos(dig,g);
185
186     h[0] = TMath::Sqrt(g[0]*g[0]+g[1]*g[1]);
187     h[1] = TMath::ATan2(g[1],g[0]);
188     h[2] = g[2];
189     h[3] = d->GetTdc();
190     h[4] = d->GetAdc();
191
192     AliTOFcluster *tofCluster = new AliTOFcluster(h,d->GetTracks(),dig,ii);
193     InsertCluster(tofCluster);
194
195   }
196
197   AliInfo(Form("Number of found clusters: %i", fNumberOfTofClusters));
198
199   FillRecPoint();
200
201   fTreeR->Fill();
202   ResetRecpoint();
203
204   fTOFLoader = fRunLoader->GetLoader("TOFLoader");  
205   fTOFLoader->WriteRecPoints("OVERWRITE");
206
207 }
208 //______________________________________________________________________________
209
210 void AliTOFClusterFinder::Digits2RecPoints(AliRawReader *rawReader,
211                                            TTree *clustersTree)
212 {
213   //
214   // Converts RAW data to recpoints for TOF
215   //
216
217   const Int_t kDDL = fTOFGeometry->NDDL()*fTOFGeometry->NSectors();
218
219   ResetRecpoint();
220
221   Int_t bufsize = 32000;
222   clustersTree->Branch("TOF", &fRecPoints, bufsize);
223
224   Int_t ii = 0;
225   Int_t indexDDL = 0;
226
227   Int_t detectorIndex[5];
228   Float_t position[3];
229   Double_t cylindricalPosition[5];
230
231   for (indexDDL = 0; indexDDL < kDDL; indexDDL++) {
232
233     rawReader->Reset();
234     AliTOFRawStream tofInput(rawReader);
235     rawReader->Select(5, indexDDL, indexDDL);
236
237     while(tofInput.Next()) {
238
239       detectorIndex[0] = tofInput.GetSector();
240       detectorIndex[1] = tofInput.GetPlate();
241       detectorIndex[2] = tofInput.GetStrip();
242       detectorIndex[3] = tofInput.GetPadZ();
243       detectorIndex[4] = tofInput.GetPadX();
244       
245       for (ii=0; ii<3; ii++) position[ii] =  0.;
246
247       fTOFGeometry->GetPos(detectorIndex, position);
248
249       cylindricalPosition[0] = TMath::Sqrt(position[0]*position[0] + position[1]*position[1]);
250       cylindricalPosition[1] = TMath::ATan2(position[1], position[0]);
251       cylindricalPosition[2] = position[2];
252       cylindricalPosition[3] = tofInput.GetTofBin();
253       cylindricalPosition[4] = tofInput.GetADCbin();
254
255       AliTOFcluster *tofCluster = new AliTOFcluster(cylindricalPosition, detectorIndex);
256       InsertCluster(tofCluster);
257
258     } // while loop
259
260   } // loop on DDL files
261
262   AliInfo(Form("Number of found clusters: %i", fNumberOfTofClusters));
263
264   FillRecPoint();
265
266   clustersTree->Fill();
267   ResetRecpoint();
268
269 }
270 //______________________________________________________________________________
271
272 void AliTOFClusterFinder::Digits2RecPoints(Int_t iEvent, AliRawReader *rawReader)
273 {
274   //
275   // Converts RAW data to recpoints for TOF
276   //
277
278   const Int_t kDDL = fTOFGeometry->NDDL()*fTOFGeometry->NSectors();
279
280   fRunLoader->GetEvent(iEvent);
281
282   AliDebug(2,Form(" Event number %2i ", iEvent));
283
284   fTreeR = fTOFLoader->TreeR();
285
286   if (fTreeR == 0x0){
287     fTOFLoader->MakeTree("R");
288     fTreeR = fTOFLoader->TreeR();
289   }
290
291   Int_t bufsize = 32000;
292   fTreeR->Branch("TOF", &fRecPoints, bufsize);
293
294   Int_t ii = 0;
295   Int_t indexDDL = 0;
296
297   Int_t detectorIndex[5];
298   Float_t position[3];
299   Double_t cylindricalPosition[5];
300
301   for (indexDDL = 0; indexDDL < kDDL; indexDDL++) {
302
303     rawReader->Reset();
304     AliTOFRawStream tofInput(rawReader);
305     rawReader->Select(5, indexDDL, indexDDL);
306
307     while(tofInput.Next()) {
308
309       detectorIndex[0] = (Int_t)tofInput.GetSector();
310       detectorIndex[1] = (Int_t)tofInput.GetPlate();
311       detectorIndex[2] = (Int_t)tofInput.GetStrip();
312       detectorIndex[3] = (Int_t)tofInput.GetPadZ();
313       detectorIndex[4] = (Int_t)tofInput.GetPadX();
314
315       for (ii=0; ii<3; ii++) position[ii] =  0.;
316
317       fTOFGeometry->GetPos(detectorIndex, position);
318       
319       cylindricalPosition[0] = (Double_t)TMath::Sqrt(position[0]*position[0] + position[1]*position[1]);
320       cylindricalPosition[1] = (Double_t)TMath::ATan2(position[1], position[0]);
321       cylindricalPosition[2] = (Double_t)position[2];
322       cylindricalPosition[3] = (Double_t)tofInput.GetTofBin();
323       cylindricalPosition[4] = (Double_t)tofInput.GetADCbin();
324
325       AliTOFcluster *tofCluster = new AliTOFcluster(cylindricalPosition, detectorIndex);
326       InsertCluster(tofCluster);
327
328     } // while loop
329
330   } // DDL Loop
331
332   AliInfo(Form("Number of found clusters: %i", fNumberOfTofClusters));
333
334   FillRecPoint();
335
336   fTreeR->Fill();
337   ResetRecpoint();
338
339   fTOFLoader = fRunLoader->GetLoader("TOFLoader");
340   fTOFLoader->WriteRecPoints("OVERWRITE");
341   
342 }
343 //______________________________________________________________________________
344
345 void AliTOFClusterFinder::Raw2Digits(Int_t iEvent, AliRawReader *rawReader)
346 {
347   //
348   // Converts RAW data to MC digits for TOF
349   //
350   //             (temporary solution)
351   //
352
353   fRunLoader->GetEvent(iEvent);
354
355   fTreeD = fTOFLoader->TreeD();
356   if (fTreeD)
357     {
358     AliInfo("AliTOFClusterFinder: TreeD re-creation");
359     fTreeD = 0x0;
360     fTOFLoader->MakeTree("D");
361     fTreeD = fTOFLoader->TreeD();
362     }
363
364
365   fTreeR = fTOFLoader->TreeD();
366   if (fTreeD == 0x0)
367     {
368       fTOFLoader->MakeTree("D");
369       fTreeD = fTOFLoader->TreeD();
370     }
371
372   TClonesArray dummy("AliTOFdigit",10000), *tofDigits=&dummy;
373   Int_t bufsize = 32000;
374   fTreeD->Branch("TOF", &tofDigits, bufsize);
375
376
377   const Int_t kDDL = fTOFGeometry->NDDL()*fTOFGeometry->NSectors();
378
379   fRunLoader->GetEvent(iEvent);
380
381   AliDebug(2,Form(" Event number %2i ", iEvent));
382
383   Int_t indexDDL = 0;
384
385   Int_t detectorIndex[5];
386   Float_t digit[2];
387
388   for (indexDDL = 0; indexDDL < kDDL; indexDDL++) {
389
390     rawReader->Reset();
391     AliTOFRawStream tofInput(rawReader);
392     rawReader->Select(5, indexDDL, indexDDL);
393
394     while(tofInput.Next()) {
395
396       detectorIndex[0] = tofInput.GetSector();
397       detectorIndex[1] = tofInput.GetPlate();
398       detectorIndex[2] = tofInput.GetStrip();
399       detectorIndex[3] = tofInput.GetPadX();
400       detectorIndex[4] = tofInput.GetPadZ();
401       
402       digit[0] = (Float_t)tofInput.GetTofBin();
403       digit[1] = (Float_t)tofInput.GetADCbin();
404
405       Int_t tracknum[3]={-1,-1,-1};
406
407       TClonesArray &aDigits = *tofDigits;
408       Int_t last=tofDigits->GetEntriesFast();
409       new (aDigits[last]) AliTOFdigit(tracknum, detectorIndex, digit);
410
411     } // while loop
412
413   } // DDL Loop
414
415   fTreeD->Fill();
416
417   fTOFLoader = fRunLoader->GetLoader("TOFLoader");
418   fTOFLoader->WriteDigits("OVERWRITE");
419   
420 }
421 //______________________________________________________________________________
422
423 Int_t AliTOFClusterFinder::InsertCluster(AliTOFcluster *tofCluster) {
424   //---------------------------------------------------------------------------//
425   // This function adds a TOF cluster to the array of TOF clusters sorted in Z //
426   //---------------------------------------------------------------------------//
427   if (fNumberOfTofClusters==kTofMaxCluster) {
428     AliError("Too many clusters !");
429     return 1;
430   }
431
432   if (fNumberOfTofClusters==0) {
433     fTofClusters[fNumberOfTofClusters++] = tofCluster;
434     return 0;
435   }
436
437   Int_t ii = FindClusterIndex(tofCluster->GetZ());
438   memmove(fTofClusters+ii+1 ,fTofClusters+ii,(fNumberOfTofClusters-ii)*sizeof(AliTOFcluster*));
439   fTofClusters[ii] = tofCluster;
440   fNumberOfTofClusters++;
441   
442   return 0;
443
444 }
445 //_________________________________________________________________________
446
447 Int_t AliTOFClusterFinder::FindClusterIndex(Double_t z) const {
448   //--------------------------------------------------------------------
449   // This function returns the index of the nearest cluster 
450   //--------------------------------------------------------------------
451   if (fNumberOfTofClusters==0) return 0;
452   if (z <= fTofClusters[0]->GetZ()) return 0;
453   if (z > fTofClusters[fNumberOfTofClusters-1]->GetZ()) return fNumberOfTofClusters;
454   Int_t b = 0, e = fNumberOfTofClusters-1, m = (b+e)/2;
455   for (; b<e; m=(b+e)/2) {
456     if (z > fTofClusters[m]->GetZ()) b=m+1;
457     else e=m;
458   }
459
460   return m;
461
462 }
463 //_________________________________________________________________________
464
465 void AliTOFClusterFinder::FillRecPoint()
466 {
467   //
468   // Copy the global array of AliTOFcluster, i.e. fTofClusters (sorted
469   // in Z) in the global TClonesArray of AliTOFcluster,
470   // i.e. fRecPoints.
471   //
472
473   Int_t ii, jj;
474
475   Int_t detectorIndex[5];
476   Double_t cylindricalPosition[5];
477   Int_t trackLabels[3];
478   Int_t digitIndex = -1;
479
480   TClonesArray &lRecPoints = *fRecPoints;
481   
482   for (ii=0; ii<fNumberOfTofClusters; ii++) {
483
484     digitIndex = fTofClusters[ii]->GetIndex();
485     for(jj=0; jj<5; jj++) detectorIndex[jj] = fTofClusters[ii]->GetDetInd(jj);
486     for(jj=0; jj<3; jj++) trackLabels[jj] = fTofClusters[ii]->GetLabel(jj);
487     cylindricalPosition[0] = fTofClusters[ii]->GetR();
488     cylindricalPosition[1] = fTofClusters[ii]->GetPhi();
489     cylindricalPosition[2] = fTofClusters[ii]->GetZ();
490     cylindricalPosition[3] = fTofClusters[ii]->GetTDC();
491     cylindricalPosition[4] = fTofClusters[ii]->GetADC();
492
493     new(lRecPoints[ii]) AliTOFcluster(cylindricalPosition, trackLabels, detectorIndex, digitIndex);
494
495     //AliInfo(Form("%3i  %3i  %f %f %f %f %f  %2i %2i %2i %1i %2i",ii,digitIndex, cylindricalPosition[2],cylindricalPosition[0],cylindricalPosition[1],cylindricalPosition[3],cylindricalPosition[4],detectorIndex[0],detectorIndex[1],detectorIndex[2],detectorIndex[3],detectorIndex[4]));
496
497   } // loop on clusters
498
499 }
500 //______________________________________________________________________________
501
502 void AliTOFClusterFinder::ResetRecpoint()
503 {
504   //
505   // Clear the list of reconstructed points
506   //
507
508   fNumberOfTofClusters = 0;
509   if (fRecPoints) fRecPoints->Clear();
510
511 }
512 //______________________________________________________________________________
513
514 void AliTOFClusterFinder::Load()
515 {
516   //
517   // Load TOF.Digits.root and TOF.RecPoints.root files
518   //
519
520   fTOFLoader->LoadDigits("READ");
521   fTOFLoader->LoadRecPoints("recreate");
522
523 }
524 //______________________________________________________________________________
525
526 void AliTOFClusterFinder::LoadClusters()
527 {
528   //
529   // Load TOF.RecPoints.root file
530   //
531
532   fTOFLoader->LoadRecPoints("recreate");
533
534 }
535 //______________________________________________________________________________
536
537 void AliTOFClusterFinder::UnLoad()
538 {
539   //
540   // Unload TOF.Digits.root and TOF.RecPoints.root files
541   //
542
543   fTOFLoader->UnloadDigits();
544   fTOFLoader->UnloadRecPoints();
545
546 }
547 //______________________________________________________________________________
548
549 void AliTOFClusterFinder::UnLoadClusters()
550 {
551   //
552   // Unload TOF.RecPoints.root file
553   //
554
555   fTOFLoader->UnloadRecPoints();
556
557 }
558 //______________________________________________________________________________