ef23880e4788d4c6614b5983dd0f931068c00482
[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 $Log$
18 Revision 1.22  2007/04/19 17:26:32  arcelli
19 Fix a bug (add some debug printout
20
21 Revision 1.21  2007/04/18 17:28:12  arcelli
22 Set the ToT bin width to the one actually used...
23
24 Revision 1.20  2007/03/09 09:57:23  arcelli
25  Remove a forgotten include of Riostrem
26
27 Revision 1.19  2007/03/08 15:41:20  arcelli
28 set uncorrected times when filling RecPoints
29
30 Revision 1.18  2007/03/06 16:31:20  arcelli
31 Add Uncorrected TOF Time signal
32
33 Revision 1.17  2007/02/28 18:09:11  arcelli
34 Add protection against failed retrieval of the CDB cal object, now Reconstruction exits with AliFatal
35
36 Revision 1.16  2007/02/20 15:57:00  decaro
37 Raw data update: to read the TOF raw data defined in UNPACKED mode
38
39
40 Revision 0.03  2005/07/28 A. De Caro
41          Implement public method
42          Raw2Digits(Int_t, AliRawReader *)
43          to convert digits from raw data in MC digits
44          (temporary solution)
45
46 Revision 0.02  2005/07/27 A. De Caro
47          Implement public method
48          Digits2RecPoint(Int_t)
49          to convert digits in clusters
50
51 Revision 0.02  2005/07/26 A. De Caro
52          Implement private methods
53          InsertCluster(AliTOFcluster *)
54          FindClusterIndex(Double_t)
55          originally implemented in AliTOFtracker
56          by S. Arcelli and C. Zampolli
57
58 Revision 0.01  2005/07/25 A. De Caro
59          Implement public methods
60          Digits2RecPoint(AliRawReader *, TTree *)
61          Digits2RecPoint(Int_t, AliRawReader *)
62          to convert raw data in clusters
63  */
64
65 ////////////////////////////////////////////////////////////////
66 //                                                            //
67 //         Class for TOF cluster finder                       //
68 //                                                            //
69 // Starting from Raw Data, create rec points,                 //
70 //                         fill TreeR for TOF,                //
71 //                         write TOF.RecPoints.root file      //
72 //                                                            //
73 ////////////////////////////////////////////////////////////////
74
75
76 #include "TClonesArray.h"
77 //#include "TFile.h"
78 #include "TStopwatch.h"
79 #include "TTree.h"
80
81 #include "AliDAQ.h"
82 #include "AliLoader.h"
83 #include "AliLog.h"
84 #include "AliRawReader.h"
85 #include "AliRunLoader.h"
86
87 #include "AliTOFCal.h"
88 #include "AliTOFcalib.h"
89 #include "AliTOFChannel.h"
90 #include "AliTOFClusterFinder.h"
91 #include "AliTOFcluster.h"
92 #include "AliTOFdigit.h"
93 #include "AliTOFGeometry.h"
94 #include "AliTOFGeometryV5.h"
95 #include "AliTOFrawData.h"
96 #include "AliTOFRawStream.h"
97 #include "Riostream.h"
98
99 //extern TFile *gFile;
100
101 ClassImp(AliTOFClusterFinder)
102
103 AliTOFClusterFinder::AliTOFClusterFinder():
104   fRunLoader(0),
105   fTOFLoader(0),
106   fTreeD(0),
107   fTreeR(0),
108   fTOFGeometry(new AliTOFGeometryV5()),
109   fDigits(new TClonesArray("AliTOFdigit", 4000)),
110   fRecPoints(new TClonesArray("AliTOFcluster", 4000)),
111   fNumberOfTofClusters(0),
112   fVerbose(0)
113 {
114 //
115 // Constructor
116 //
117
118   AliInfo("V5 TOF Geometry is taken as the default");
119
120 }
121 //______________________________________________________________________________
122
123 AliTOFClusterFinder::AliTOFClusterFinder(AliRunLoader* runLoader):
124   fRunLoader(runLoader),
125   fTOFLoader(runLoader->GetLoader("TOFLoader")),
126   fTreeD(0),
127   fTreeR(0),
128   fTOFGeometry(new AliTOFGeometryV5()),
129   fDigits(new TClonesArray("AliTOFdigit", 4000)),
130   fRecPoints(new TClonesArray("AliTOFcluster", 4000)),
131   fNumberOfTofClusters(0),
132   fVerbose(0)
133 {
134 //
135 // Constructor
136 //
137
138 //  runLoader->CdGAFile();
139 //  TFile *in=(TFile*)gFile;
140 //  in->cd();
141 //  fTOFGeometry = (AliTOFGeometry*)in->Get("TOFgeometry");
142
143 }
144
145 //------------------------------------------------------------------------
146 AliTOFClusterFinder::AliTOFClusterFinder(const AliTOFClusterFinder &source)
147   :TObject(),
148   fRunLoader(0),
149   fTOFLoader(0),
150   fTreeD(0),
151   fTreeR(0),
152   fTOFGeometry(new AliTOFGeometryV5()),
153   fDigits(new TClonesArray("AliTOFdigit", 4000)),
154   fRecPoints(new TClonesArray("AliTOFcluster", 4000)),
155   fNumberOfTofClusters(0),
156   fVerbose(0)
157 {
158   // copy constructor
159   this->fDigits=source.fDigits;
160   this->fRecPoints=source.fRecPoints;
161   this->fTOFGeometry=source.fTOFGeometry;
162
163 }
164
165 //------------------------------------------------------------------------
166 AliTOFClusterFinder& AliTOFClusterFinder::operator=(const AliTOFClusterFinder &source)
167 {
168   // ass. op.
169   this->fDigits=source.fDigits;
170   this->fRecPoints=source.fRecPoints;
171   this->fTOFGeometry=source.fTOFGeometry;
172   this->fVerbose=source.fVerbose;
173   return *this;
174
175 }
176 //______________________________________________________________________________
177
178 AliTOFClusterFinder::~AliTOFClusterFinder()
179 {
180
181   //
182   // Destructor
183   //
184
185   if (fDigits)
186     {
187       fDigits->Delete();
188       delete fDigits;
189       fDigits=0;
190     }
191   if (fRecPoints)
192     {
193       fRecPoints->Delete();
194       delete fRecPoints;
195       fRecPoints=0;
196     }
197
198   delete fTOFGeometry;
199
200 }
201 //______________________________________________________________________________
202
203 void AliTOFClusterFinder::Digits2RecPoints(Int_t iEvent)
204 {
205   //
206   // Converts digits to recpoints for TOF
207   //
208
209   TStopwatch stopwatch;
210   stopwatch.Start();
211
212   fRunLoader->GetEvent(iEvent);
213
214   fTreeD = fTOFLoader->TreeD();
215   if (fTreeD == 0x0)
216     {
217       AliFatal("AliTOFClusterFinder: Can not get TreeD");
218     }
219
220   TBranch *branch = fTreeD->GetBranch("TOF");
221   if (!branch) { 
222     AliError("can't get the branch with the TOF digits !");
223     return;
224   }
225
226   TClonesArray *digits = new TClonesArray("AliTOFdigit",10000);
227   branch->SetAddress(&digits);
228
229   ResetRecpoint();
230
231   fTreeR = fTOFLoader->TreeR();
232   if (fTreeR == 0x0)
233     {
234       fTOFLoader->MakeTree("R");
235       fTreeR = fTOFLoader->TreeR();
236     }
237
238   Int_t bufsize = 32000;
239   fTreeR->Branch("TOF", &fRecPoints, bufsize);
240
241   fTreeD->GetEvent(0);
242   Int_t nDigits = digits->GetEntriesFast();
243   AliDebug(2,Form("Number of TOF digits: %d",nDigits));
244
245   Int_t ii, jj;
246   Int_t dig[5];
247   Float_t g[3];
248   Double_t h[5];
249   Float_t tToT;
250   Double_t tTdcND;
251   for (ii=0; ii<nDigits; ii++) {
252     AliTOFdigit *d = (AliTOFdigit*)digits->UncheckedAt(ii);
253     dig[0]=d->GetSector();
254     dig[1]=d->GetPlate();
255     dig[2]=d->GetStrip();
256     dig[3]=d->GetPadz();
257     dig[4]=d->GetPadx();
258
259     //AliInfo(Form(" %2i  %1i  %2i  %1i  %2i ",dig[0],dig[1],dig[2],dig[3],dig[4]));
260
261     for (jj=0; jj<3; jj++) g[jj] = 0.;
262     fTOFGeometry->GetPos(dig,g);
263
264     h[0] = TMath::Sqrt(g[0]*g[0]+g[1]*g[1]);
265     h[1] = TMath::ATan2(g[1],g[0]);
266     h[2] = g[2];
267     h[3] = d->GetTdc();
268     h[4] = d->GetAdc();
269     tToT = d->GetToT();
270     tTdcND = d->GetTdcND();
271
272     AliTOFcluster *tofCluster = new AliTOFcluster(h,d->GetTracks(),dig,ii,tToT, tTdcND);
273     tofCluster->SetTDCRAW(d->GetTdc());
274     InsertCluster(tofCluster);
275
276   }
277
278   AliInfo(Form("Number of found clusters: %i", fNumberOfTofClusters));
279
280   CalibrateRecPoint();
281   FillRecPoint();
282
283   fTreeR->Fill();
284   ResetRecpoint();
285
286   fTOFLoader = fRunLoader->GetLoader("TOFLoader");  
287   fTOFLoader->WriteRecPoints("OVERWRITE");
288
289   AliInfo(Form("Execution time to read TOF digits and to write TOF clusters : R:%.4fs C:%.4fs",
290                stopwatch.RealTime(),stopwatch.CpuTime()));
291
292 }
293 //______________________________________________________________________________
294
295 void AliTOFClusterFinder::Digits2RecPoints(AliRawReader *rawReader,
296                                            TTree *clustersTree)
297 {
298   //
299   // Converts RAW data to recpoints for TOF
300   //
301
302   TStopwatch stopwatch;
303   stopwatch.Start();
304
305   //const Int_t kDDL = fTOFGeometry->NDDL()*fTOFGeometry->NSectors();
306   const Int_t kDDL = AliDAQ::NumberOfDdls("TOF");
307
308   ResetRecpoint();
309
310   Int_t bufsize = 32000;
311   clustersTree->Branch("TOF", &fRecPoints, bufsize);
312
313   TClonesArray * clonesRawData;
314
315   Int_t ii = 0;
316   Int_t dummy = -1;
317
318   Int_t detectorIndex[5];
319   Float_t position[3];
320   Double_t cylindricalPosition[5];
321   Float_t tToT;
322   Double_t tTdcND;
323
324   ofstream ftxt;
325   if (fVerbose==2) ftxt.open("TOFdigitsRead.txt",ios::app);
326
327   Int_t indexDDL = 0;
328   for (indexDDL = 0; indexDDL < kDDL; indexDDL++) {
329
330     rawReader->Reset();
331     AliTOFRawStream tofInput(rawReader);
332     tofInput.LoadRawData(indexDDL);
333
334     clonesRawData = (TClonesArray*)tofInput.GetRawData();
335
336     for (Int_t iRawData = 0; iRawData<clonesRawData->GetEntriesFast(); iRawData++) {
337
338       AliTOFrawData *tofRawDatum = (AliTOFrawData*)clonesRawData->UncheckedAt(iRawData);
339
340       if (tofRawDatum->GetTOT()==-1 || tofRawDatum->GetTOF()==-1) continue;
341
342       if (fVerbose==2) {
343         if (indexDDL<10) ftxt << "  " << indexDDL;
344         else         ftxt << " " << indexDDL;
345         if (tofRawDatum->GetTRM()<10) ftxt << "  " << tofRawDatum->GetTRM();
346         else         ftxt << " " << tofRawDatum->GetTRM();
347         ftxt << "  " << tofRawDatum->GetTRMchain();
348         if (tofRawDatum->GetTDC()<10) ftxt << "  " << tofRawDatum->GetTDC();
349         else         ftxt << " " << tofRawDatum->GetTDC();
350         ftxt << "  " << tofRawDatum->GetTDCchannel();
351       }
352
353       tofInput.EquipmentId2VolumeId(indexDDL, tofRawDatum->GetTRM(), tofRawDatum->GetTRMchain(),
354                                     tofRawDatum->GetTDC(), tofRawDatum->GetTDCchannel(), detectorIndex);
355       dummy = detectorIndex[3];
356       detectorIndex[3] = detectorIndex[4];
357       detectorIndex[4] = dummy;
358
359       if (fVerbose==2) {
360         if (detectorIndex[0]<10) ftxt  << "  ->  " << detectorIndex[0];
361         else              ftxt  << "  -> " << detectorIndex[0];
362         ftxt << "  " << detectorIndex[1];
363         if (detectorIndex[2]<10) ftxt << "  " << detectorIndex[2];
364         else              ftxt << " " << detectorIndex[2];
365         ftxt << "  " << detectorIndex[3];
366         if (detectorIndex[4]<10) ftxt << "  " << detectorIndex[4];
367         else              ftxt << " " << detectorIndex[4];
368       }
369
370       for (ii=0; ii<3; ii++) position[ii] =  0.;
371       fTOFGeometry->GetPos(detectorIndex, position);
372
373       cylindricalPosition[0] = TMath::Sqrt(position[0]*position[0] + position[1]*position[1]);
374       cylindricalPosition[1] = TMath::ATan2(position[1], position[0]);
375       cylindricalPosition[2] = position[2];
376       cylindricalPosition[3] = tofRawDatum->GetTOF();
377       cylindricalPosition[4] = tofRawDatum->GetTOT();
378       tToT = tofRawDatum->GetTOT();
379       tTdcND = -1.;
380       AliTOFcluster *tofCluster = new AliTOFcluster(cylindricalPosition, detectorIndex);
381       tofCluster->SetToT(tToT);
382       tofCluster->SetTDCND(tTdcND);
383       tofCluster->SetTDCRAW(tofRawDatum->GetTOF());
384       InsertCluster(tofCluster);
385
386       if (fVerbose==2) {
387         if (cylindricalPosition[4]<10)                        ftxt << "        " << cylindricalPosition[4];
388         else if (cylindricalPosition[4]>=10 && cylindricalPosition[4]<100) ftxt << "       " << cylindricalPosition[4];
389         else                                     ftxt << "      " << cylindricalPosition[4];
390         if (cylindricalPosition[3]<10)                             ftxt << "      " << cylindricalPosition[3] << endl;
391         else if (cylindricalPosition[3]>=10 && cylindricalPosition[3]<100)   ftxt << "     " << cylindricalPosition[3] << endl;
392         else if (cylindricalPosition[3]>=100 && cylindricalPosition[3]<1000) ftxt << "    " << cylindricalPosition[3] << endl;
393         else                                             ftxt << "   " << cylindricalPosition[3] << endl;
394       }
395
396     } // closed loop on TOF raw data per current DDL file
397
398     clonesRawData->Clear();
399
400   } // closed loop on DDL index
401
402   /*
403   Int_t indexDDL = 0;
404   for (indexDDL = 0; indexDDL < kDDL; indexDDL++) {
405
406     rawReader->Reset();
407     AliTOFRawStream tofInput(rawReader);
408     rawReader->Select("TOF", indexDDL, indexDDL);
409
410     while(tofInput.Next()) {
411
412       for (ii=0; ii<5; ii++) detectorIndex[ii] = -1;
413
414       detectorIndex[0] = tofInput.GetSector();
415       detectorIndex[1] = tofInput.GetPlate();
416       detectorIndex[2] = tofInput.GetStrip();
417       detectorIndex[3] = tofInput.GetPadZ();
418       detectorIndex[4] = tofInput.GetPadX();
419       
420       //AliInfo(Form("  %2i  %1i  %2i  %1i  %2i ",detectorIndex[0],detectorIndex[1],detectorIndex[2],detectorIndex[3],detectorIndex[4]));
421
422       if (detectorIndex[0]==-1 ||
423           detectorIndex[1]==-1 ||
424           detectorIndex[2]==-1 ||
425           detectorIndex[3]==-1 ||
426           detectorIndex[4]==-1) continue;
427
428       for (ii=0; ii<3; ii++) position[ii] =  0.;
429
430       fTOFGeometry->GetPos(detectorIndex, position);
431
432       cylindricalPosition[0] = TMath::Sqrt(position[0]*position[0] + position[1]*position[1]);
433       cylindricalPosition[1] = TMath::ATan2(position[1], position[0]);
434       cylindricalPosition[2] = position[2];
435       cylindricalPosition[3] = tofInput.GetTofBin();
436       cylindricalPosition[4] = tofInput.GetToTbin();
437       tToT = tofInput.GetToTbin();
438       tTdcND = -1.;
439       AliTOFcluster *tofCluster = new AliTOFcluster(cylindricalPosition, detectorIndex);
440       tofCluster->SetToT(tToT);
441       tofCluster->SetTDCND(tTdcND);
442       InsertCluster(tofCluster);
443
444     } // while loop
445
446   } // loop on DDL files
447   */
448
449   if (fVerbose==2) ftxt.close();
450
451   AliInfo(Form("Number of found clusters: %i", fNumberOfTofClusters));
452
453   CalibrateRecPoint();
454   FillRecPoint();
455
456   clustersTree->Fill();
457
458   ResetRecpoint();
459
460   AliDebug(1, Form("Execution time to read TOF raw data and to write TOF clusters : R:%.4fs C:%.4fs",
461                    stopwatch.RealTime(),stopwatch.CpuTime()));
462
463 }
464 //______________________________________________________________________________
465
466 void AliTOFClusterFinder::Digits2RecPoints(Int_t iEvent, AliRawReader *rawReader)
467 {
468   //
469   // Converts RAW data to recpoints for TOF
470   //
471
472   TStopwatch stopwatch;
473   stopwatch.Start();
474
475   //const Int_t kDDL = fTOFGeometry->NDDL()*fTOFGeometry->NSectors();
476   const Int_t kDDL = AliDAQ::NumberOfDdls("TOF");
477
478   fRunLoader->GetEvent(iEvent);
479
480   AliDebug(2,Form(" Event number %2i ", iEvent));
481
482   fTreeR = fTOFLoader->TreeR();
483
484   if (fTreeR == 0x0){
485     fTOFLoader->MakeTree("R");
486     fTreeR = fTOFLoader->TreeR();
487   }
488
489   Int_t bufsize = 32000;
490   fTreeR->Branch("TOF", &fRecPoints, bufsize);
491
492   TClonesArray * clonesRawData;
493
494   Int_t ii = 0;
495   Int_t dummy = -1;
496
497   Int_t detectorIndex[5] = {-1, -1, -1, -1, -1};
498   Float_t position[3];
499   Double_t cylindricalPosition[5];
500   Float_t tToT;
501   Double_t tTdcND;
502
503   ofstream ftxt;
504   if (fVerbose==2) ftxt.open("TOFdigitsRead.txt",ios::app);
505
506   Int_t indexDDL = 0;
507   for (indexDDL = 0; indexDDL < kDDL; indexDDL++) {
508
509     rawReader->Reset();
510     AliTOFRawStream tofInput(rawReader);
511     tofInput.LoadRawData(indexDDL);
512
513     clonesRawData = (TClonesArray*)tofInput.GetRawData();
514
515     for (Int_t iRawData = 0; iRawData<clonesRawData->GetEntriesFast(); iRawData++) {
516
517       AliTOFrawData *tofRawDatum = (AliTOFrawData*)clonesRawData->UncheckedAt(iRawData);
518
519       if (tofRawDatum->GetTOT()==-1 || tofRawDatum->GetTOF()==-1) continue;
520
521       if (fVerbose==2) {
522         if (indexDDL<10) ftxt << "  " << indexDDL;
523         else         ftxt << " " << indexDDL;
524         if (tofRawDatum->GetTRM()<10) ftxt << "  " << tofRawDatum->GetTRM();
525         else         ftxt << " " << tofRawDatum->GetTRM();
526         ftxt << "  " << tofRawDatum->GetTRMchain();
527         if (tofRawDatum->GetTDC()<10) ftxt << "  " << tofRawDatum->GetTDC();
528         else         ftxt << " " << tofRawDatum->GetTDC();
529         ftxt << "  " << tofRawDatum->GetTDCchannel();
530       }
531
532       tofInput.EquipmentId2VolumeId(indexDDL, tofRawDatum->GetTRM(), tofRawDatum->GetTRMchain(),
533                                     tofRawDatum->GetTDC(), tofRawDatum->GetTDCchannel(), detectorIndex);
534       dummy = detectorIndex[3];
535       detectorIndex[3] = detectorIndex[4];
536       detectorIndex[4] = dummy;
537
538       if (fVerbose==2) {
539         if (detectorIndex[0]<10) ftxt  << "  ->  " << detectorIndex[0];
540         else              ftxt  << "  -> " << detectorIndex[0];
541         ftxt << "  " << detectorIndex[1];
542         if (detectorIndex[2]<10) ftxt << "  " << detectorIndex[2];
543         else              ftxt << " " << detectorIndex[2];
544         ftxt << "  " << detectorIndex[3];
545         if (detectorIndex[4]<10) ftxt << "  " << detectorIndex[4];
546         else              ftxt << " " << detectorIndex[4];
547       }
548
549       for (ii=0; ii<3; ii++) position[ii] =  0.;
550       fTOFGeometry->GetPos(detectorIndex, position);
551
552       cylindricalPosition[0] = TMath::Sqrt(position[0]*position[0] + position[1]*position[1]);
553       cylindricalPosition[1] = TMath::ATan2(position[1], position[0]);
554       cylindricalPosition[2] = position[2];
555       cylindricalPosition[3] = tofRawDatum->GetTOF();
556       cylindricalPosition[4] = tofRawDatum->GetTOT();
557       tToT = tofRawDatum->GetTOT();
558       tTdcND = -1.;
559       AliTOFcluster *tofCluster = new AliTOFcluster(cylindricalPosition, detectorIndex);
560       tofCluster->SetToT(tToT);
561       tofCluster->SetTDCND(tTdcND);
562       tofCluster->SetTDCRAW(tofRawDatum->GetTOF());
563       InsertCluster(tofCluster);
564
565       if (fVerbose==2) {
566         if (cylindricalPosition[4]<10)                        ftxt << "        " << cylindricalPosition[4];
567         else if (cylindricalPosition[4]>=10 && cylindricalPosition[4]<100) ftxt << "       " << cylindricalPosition[4];
568         else                                     ftxt << "      " << cylindricalPosition[4];
569         if (cylindricalPosition[3]<10)                             ftxt << "      " << cylindricalPosition[3] << endl;
570         else if (cylindricalPosition[3]>=10 && cylindricalPosition[3]<100)   ftxt << "     " << cylindricalPosition[3] << endl;
571         else if (cylindricalPosition[3]>=100 && cylindricalPosition[3]<1000) ftxt << "    " << cylindricalPosition[3] << endl;
572         else                                             ftxt << "   " << cylindricalPosition[3] << endl;
573       }
574
575     } // closed loop on TOF raw data per current DDL file
576
577     clonesRawData->Clear();
578
579   } // closed loop on DDL index
580
581   if (fVerbose==2) ftxt.close();
582
583   AliInfo(Form("Number of found clusters: %i", fNumberOfTofClusters));
584
585   CalibrateRecPoint();
586   FillRecPoint();
587
588   fTreeR->Fill();
589   ResetRecpoint();
590
591   fTOFLoader = fRunLoader->GetLoader("TOFLoader");
592   fTOFLoader->WriteRecPoints("OVERWRITE");
593   
594   AliDebug(1, Form("Execution time to read TOF raw data and to write TOF clusters : R:%.4fs C:%.4fs",
595                stopwatch.RealTime(),stopwatch.CpuTime()));
596
597 }
598 //______________________________________________________________________________
599
600 void AliTOFClusterFinder::Raw2Digits(Int_t iEvent, AliRawReader *rawReader)
601 {
602   //
603   // Converts RAW data to MC digits for TOF
604   //
605   //             (temporary solution)
606   //
607
608   TStopwatch stopwatch;
609   stopwatch.Start();
610
611   //const Int_t kDDL = fTOFGeometry->NDDL()*fTOFGeometry->NSectors();
612   const Int_t kDDL = fTOFGeometry->NDDL()*fTOFGeometry->NSectors();
613
614   fRunLoader->GetEvent(iEvent);
615
616   fTreeD = fTOFLoader->TreeD();
617   if (fTreeD)
618     {
619     AliInfo("TreeD re-creation");
620     fTreeD = 0x0;
621     fTOFLoader->MakeTree("D");
622     fTreeD = fTOFLoader->TreeD();
623     }
624
625   TClonesArray *tofDigits = new TClonesArray("AliTOFdigit",10000);
626   Int_t bufsize = 32000;
627   fTreeD->Branch("TOF", &tofDigits, bufsize);
628
629   fRunLoader->GetEvent(iEvent);
630
631   AliDebug(2,Form(" Event number %2i ", iEvent));
632
633   TClonesArray * clonesRawData;
634
635   Int_t dummy = -1;
636
637   Int_t detectorIndex[5];
638   Float_t digit[4];
639
640   Int_t indexDDL = 0;
641   for (indexDDL = 0; indexDDL < kDDL; indexDDL++) {
642
643     rawReader->Reset();
644     AliTOFRawStream tofInput(rawReader);
645     tofInput.LoadRawData(indexDDL);
646
647     clonesRawData = (TClonesArray*)tofInput.GetRawData();
648
649     for (Int_t iRawData = 0; iRawData<clonesRawData->GetEntriesFast(); iRawData++) {
650
651       AliTOFrawData *tofRawDatum = (AliTOFrawData*)clonesRawData->UncheckedAt(iRawData);
652
653       if (!tofRawDatum->GetTOT() || !tofRawDatum->GetTOF()) continue;
654
655       tofInput.EquipmentId2VolumeId(indexDDL, tofRawDatum->GetTRM(), tofRawDatum->GetTRMchain(),
656                                     tofRawDatum->GetTDC(), tofRawDatum->GetTDCchannel(), detectorIndex);
657       dummy = detectorIndex[3];
658       detectorIndex[3] = detectorIndex[4];
659       detectorIndex[4] = dummy;
660
661       digit[0] = (Float_t)tofInput.GetTofBin();
662       digit[1] = (Float_t)tofInput.GetToTbin();
663       digit[2] = (Float_t)tofInput.GetToTbin();
664       digit[3] = -1.;
665
666       Int_t tracknum[3]={-1,-1,-1};
667
668       TClonesArray &aDigits = *tofDigits;
669       Int_t last=tofDigits->GetEntriesFast();
670       new (aDigits[last]) AliTOFdigit(tracknum, detectorIndex, digit);
671
672     } // while loop
673
674     clonesRawData->Clear();
675
676   } // DDL Loop
677
678   fTreeD->Fill();
679
680   fTOFLoader = fRunLoader->GetLoader("TOFLoader");
681   fTOFLoader->WriteDigits("OVERWRITE");
682   
683   AliDebug(1, Form("Execution time to read TOF raw data and to write TOF clusters : R:%.2fs C:%.2fs",
684                    stopwatch.RealTime(),stopwatch.CpuTime()));
685
686 }
687 //______________________________________________________________________________
688
689 Int_t AliTOFClusterFinder::InsertCluster(AliTOFcluster *tofCluster) {
690   //---------------------------------------------------------------------------//
691   // This function adds a TOF cluster to the array of TOF clusters sorted in Z //
692   //---------------------------------------------------------------------------//
693   if (fNumberOfTofClusters==kTofMaxCluster) {
694     AliError("Too many clusters !");
695     return 1;
696   }
697
698   if (fNumberOfTofClusters==0) {
699     fTofClusters[fNumberOfTofClusters++] = tofCluster;
700     return 0;
701   }
702
703   Int_t ii = FindClusterIndex(tofCluster->GetZ());
704   memmove(fTofClusters+ii+1 ,fTofClusters+ii,(fNumberOfTofClusters-ii)*sizeof(AliTOFcluster*));
705   fTofClusters[ii] = tofCluster;
706   fNumberOfTofClusters++;
707   
708   return 0;
709
710 }
711 //_________________________________________________________________________
712
713 Int_t AliTOFClusterFinder::FindClusterIndex(Double_t z) const {
714   //--------------------------------------------------------------------
715   // This function returns the index of the nearest cluster 
716   //--------------------------------------------------------------------
717   if (fNumberOfTofClusters==0) return 0;
718   if (z <= fTofClusters[0]->GetZ()) return 0;
719   if (z > fTofClusters[fNumberOfTofClusters-1]->GetZ()) return fNumberOfTofClusters;
720   Int_t b = 0, e = fNumberOfTofClusters-1, m = (b+e)/2;
721   for (; b<e; m=(b+e)/2) {
722     if (z > fTofClusters[m]->GetZ()) b=m+1;
723     else e=m;
724   }
725
726   return m;
727
728 }
729 //_________________________________________________________________________
730
731 void AliTOFClusterFinder::FillRecPoint()
732 {
733   //
734   // Copy the global array of AliTOFcluster, i.e. fTofClusters (sorted
735   // in Z) in the global TClonesArray of AliTOFcluster,
736   // i.e. fRecPoints.
737   //
738
739   Int_t ii, jj;
740
741   Int_t detectorIndex[5];
742   Double_t cylindricalPosition[5];
743   Int_t trackLabels[3];
744   Int_t digitIndex = -1;
745   Float_t tToT=0.;
746   Double_t tTdcND=0.;
747   Double_t tTdcRAW=0.;
748   Bool_t cStatus = kTRUE;
749
750   TClonesArray &lRecPoints = *fRecPoints;
751   
752   for (ii=0; ii<fNumberOfTofClusters; ii++) {
753
754     digitIndex = fTofClusters[ii]->GetIndex();
755     for(jj=0; jj<5; jj++) detectorIndex[jj] = fTofClusters[ii]->GetDetInd(jj);
756     for(jj=0; jj<3; jj++) trackLabels[jj] = fTofClusters[ii]->GetLabel(jj);
757     cylindricalPosition[0] = fTofClusters[ii]->GetR();
758     cylindricalPosition[1] = fTofClusters[ii]->GetPhi();
759     cylindricalPosition[2] = fTofClusters[ii]->GetZ();
760     cylindricalPosition[3] = fTofClusters[ii]->GetTDC();
761     cylindricalPosition[4] = fTofClusters[ii]->GetADC();
762     tToT = fTofClusters[ii]->GetToT();
763     tTdcND = fTofClusters[ii]->GetTDCND();
764     cStatus=fTofClusters[ii]->GetStatus();
765     tTdcRAW=fTofClusters[ii]->GetTDCRAW();
766     new(lRecPoints[ii]) AliTOFcluster(cylindricalPosition, trackLabels, detectorIndex, digitIndex, tToT, tTdcND, tTdcRAW,cStatus);
767
768     //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]));
769
770   } // loop on clusters
771
772 }
773
774 //_________________________________________________________________________
775 void AliTOFClusterFinder::CalibrateRecPoint()
776 {
777   //
778   // Copy the global array of AliTOFcluster, i.e. fTofClusters (sorted
779   // in Z) in the global TClonesArray of AliTOFcluster,
780   // i.e. fRecPoints.
781   //
782
783   Int_t ii, jj;
784
785   Int_t detectorIndex[5];
786   Int_t digitIndex = -1;
787   Float_t tToT;
788   Float_t tdcCorr;
789   AliInfo(" Calibrating TOF Clusters: ")
790   AliTOFcalib *calib = new AliTOFcalib(fTOFGeometry);
791   // calib->ReadParFromCDB("TOF/Calib",0); // original
792   // Use AliCDBManager's run number
793  if(!calib->ReadParFromCDB("TOF/Calib",-1)) {AliFatal("Exiting, no CDB object found!!!");exit(0);}  
794   
795   AliTOFCal *calTOFArray = calib->GetTOFCalArray();  
796
797   for (ii=0; ii<fNumberOfTofClusters; ii++) {
798     digitIndex = fTofClusters[ii]->GetIndex();
799     for(jj=0; jj<5; jj++) detectorIndex[jj] = fTofClusters[ii]->GetDetInd(jj);
800
801     Int_t index = calib->GetIndex(detectorIndex);
802      
803     AliTOFChannel * calChannel = calTOFArray->GetChannel(index);
804
805     // Get channel status 
806     Bool_t status=calChannel->GetStatus();
807     if(status)fTofClusters[ii]->SetStatus(!status); //odd convention, to avoid conflict with calibration objects currently in the db (temporary solution).
808
809     // Get Rough channel online equalization 
810     Float_t roughDelay=calChannel->GetDelay();
811     AliDebug(2,Form(" channel delay = %f", roughDelay));
812     // Get Refined channel offline calibration parameters
813     Float_t par[6];
814     for (Int_t j = 0; j<6; j++){
815       par[j]=calChannel->GetSlewPar(j);
816     }
817     tToT = fTofClusters[ii]->GetToT()*AliTOFGeometry::ToTBinWidth()*1.E-3;
818     Float_t timeCorr=par[0]+par[1]*tToT+par[2]*tToT*tToT+par[3]*tToT*tToT*tToT+par[4]*tToT*tToT*tToT*tToT+par[5]*tToT*tToT*tToT*tToT*tToT+roughDelay;
819     AliDebug(2,Form(" time correction (ns) = %f", timeCorr));
820     AliDebug(2,Form(" channel time, uncorr (ns)= %f",fTofClusters[ii]->GetTDC()*AliTOFGeometry::TdcBinWidth()*1.E-3 ));
821     tdcCorr=(fTofClusters[ii]->GetTDC()*AliTOFGeometry::TdcBinWidth()+32)*1.E-3-timeCorr;
822     tdcCorr=(tdcCorr*1E3-32)/AliTOFGeometry::TdcBinWidth();
823     fTofClusters[ii]->SetTDC(tdcCorr);
824     AliDebug(2,Form(" channel time, corr (ns)= %f",fTofClusters[ii]->GetTDC()*AliTOFGeometry::TdcBinWidth()*1.E-3 ));
825
826   } // loop on clusters
827
828   delete calib;
829 }
830 //______________________________________________________________________________
831
832 void AliTOFClusterFinder::ResetRecpoint()
833 {
834   //
835   // Clear the list of reconstructed points
836   //
837
838   fNumberOfTofClusters = 0;
839   if (fRecPoints) fRecPoints->Clear();
840
841 }
842 //______________________________________________________________________________
843
844 void AliTOFClusterFinder::Load()
845 {
846   //
847   // Load TOF.Digits.root and TOF.RecPoints.root files
848   //
849
850   fTOFLoader->LoadDigits("READ");
851   fTOFLoader->LoadRecPoints("recreate");
852
853 }
854 //______________________________________________________________________________
855
856 void AliTOFClusterFinder::LoadClusters()
857 {
858   //
859   // Load TOF.RecPoints.root file
860   //
861
862   fTOFLoader->LoadRecPoints("recreate");
863
864 }
865 //______________________________________________________________________________
866
867 void AliTOFClusterFinder::UnLoad()
868 {
869   //
870   // Unload TOF.Digits.root and TOF.RecPoints.root files
871   //
872
873   fTOFLoader->UnloadDigits();
874   fTOFLoader->UnloadRecPoints();
875
876 }
877 //______________________________________________________________________________
878
879 void AliTOFClusterFinder::UnLoadClusters()
880 {
881   //
882   // Unload TOF.RecPoints.root file
883   //
884
885   fTOFLoader->UnloadRecPoints();
886
887 }
888 //______________________________________________________________________________