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