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