]> git.uio.no Git - u/mrichter/AliRoot.git/blame - TOF/AliTOFClusterFinder.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Input number added to Print
[u/mrichter/AliRoot.git] / TOF / AliTOFClusterFinder.cxx
CommitLineData
d08a92dd 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/*
7fffa85b 17$Log: AliTOFClusterFinder.cxx,v $
18Revision 1.31 2007/11/24 14:53:19 zampolli
19Status flag implemented as UChar_t
20
98f5acd7 21Revision 1.30 2007/10/04 13:08:52 arcelli
22updates to comply with AliTOFGeometryV5 becoming AliTOFGeometry
23
ba66add8 24Revision 1.29 2007/10/03 10:42:33 arcelli
25updates to handle new AliTOFcluster, inheriting form AliCluster3D
26
ac359ffe 27Revision 1.28 2007/05/31 16:06:05 arcelli
28move instance of AliRawStream outside loop on DDL
29
ef58b2af 30Revision 1.27 2007/05/02 16:31:49 arcelli
c3891b7a 31Add methods to handle single event reconstruction. retrieval of Calib
32info moved to AliTOFReconstructor ctor, and passed via a pointer to
33AliTOFcalib
ef58b2af 34
94f5f8f2 35Revision 1.26 2007/04/30 19:02:24 arcelli
36hopefully the last refinements for correct type conversion in calibration
37
a33fec85 38Revision 1.25 2007/04/30 15:22:17 arcelli
39Change TOF digit Time, Tot etc to int type
40
bf33f8f0 41Revision 1.24 2007/04/27 11:19:31 arcelli
42updates for the new decoder
43
7813bb1a 44Revision 1.23 2007/04/23 16:51:39 decaro
c3891b7a 45Digits-to-raw_data conversion: correction for a more real description
46(A.De Caro, R.Preghenella)
7813bb1a 47
515faf5d 48Revision 1.22 2007/04/19 17:26:32 arcelli
49Fix a bug (add some debug printout
50
0451c2e6 51Revision 1.21 2007/04/18 17:28:12 arcelli
52Set the ToT bin width to the one actually used...
53
605370db 54Revision 1.20 2007/03/09 09:57:23 arcelli
55 Remove a forgotten include of Riostrem
56
c77771e2 57Revision 1.19 2007/03/08 15:41:20 arcelli
58set uncorrected times when filling RecPoints
59
3432ebfa 60Revision 1.18 2007/03/06 16:31:20 arcelli
61Add Uncorrected TOF Time signal
62
aa5476d8 63Revision 1.17 2007/02/28 18:09:11 arcelli
c3891b7a 64Add protection against failed retrieval of the CDB cal object,
65now Reconstruction exits with AliFatal
aa5476d8 66
a1cab04c 67Revision 1.16 2007/02/20 15:57:00 decaro
68Raw data update: to read the TOF raw data defined in UNPACKED mode
69
d08a92dd 70
71Revision 0.03 2005/07/28 A. De Caro
72 Implement public method
73 Raw2Digits(Int_t, AliRawReader *)
74 to convert digits from raw data in MC digits
75 (temporary solution)
76
77Revision 0.02 2005/07/27 A. De Caro
78 Implement public method
79 Digits2RecPoint(Int_t)
80 to convert digits in clusters
81
82Revision 0.02 2005/07/26 A. De Caro
83 Implement private methods
84 InsertCluster(AliTOFcluster *)
85 FindClusterIndex(Double_t)
86 originally implemented in AliTOFtracker
87 by S. Arcelli and C. Zampolli
88
89Revision 0.01 2005/07/25 A. De Caro
90 Implement public methods
91 Digits2RecPoint(AliRawReader *, TTree *)
92 Digits2RecPoint(Int_t, AliRawReader *)
93 to convert raw data in clusters
94 */
95
96////////////////////////////////////////////////////////////////
97// //
98// Class for TOF cluster finder //
99// //
100// Starting from Raw Data, create rec points, //
101// fill TreeR for TOF, //
102// write TOF.RecPoints.root file //
103// //
104////////////////////////////////////////////////////////////////
105
5c7c93fa 106#include "Riostream.h"
15ec34b9 107
0e46b9ae 108#include "TClonesArray.h"
515faf5d 109#include "TStopwatch.h"
0e46b9ae 110#include "TTree.h"
5c7c93fa 111//#include <TGeoManager.h>
ac359ffe 112#include <TGeoMatrix.h>
5c7c93fa 113//#include <TGeoPhysicalNode.h>
d08a92dd 114
d0eb8f39 115#include "AliDAQ.h"
0e46b9ae 116#include "AliLoader.h"
d08a92dd 117#include "AliLog.h"
0e46b9ae 118#include "AliRawReader.h"
d08a92dd 119#include "AliRunLoader.h"
5c7c93fa 120//#include "AliAlignObj.h"
121#include <AliGeomManager.h>
d08a92dd 122
15ec34b9 123#include "AliTOFcalib.h"
17149e6b 124#include "AliTOFChannelOnlineArray.h"
125#include "AliTOFChannelOnlineStatusArray.h"
ba66add8 126#include "AliTOFChannelOffline.h"
d08a92dd 127#include "AliTOFClusterFinder.h"
0e46b9ae 128#include "AliTOFcluster.h"
129#include "AliTOFdigit.h"
0e46b9ae 130#include "AliTOFGeometry.h"
15ec34b9 131#include "AliTOFrawData.h"
0e46b9ae 132
2bf4d9d6 133#include "AliTOFDeltaBCOffset.h"
134#include "AliTOFCTPLatency.h"
f04b3a69 135#include "AliTOFRunParams.h"
2bf4d9d6 136
15ec34b9 137//extern TFile *gFile;
d08a92dd 138
fe7d86eb 139using std::cout;
140using std::endl;
141using std::ofstream;
142using std::ios;
d08a92dd 143ClassImp(AliTOFClusterFinder)
144
94f5f8f2 145AliTOFClusterFinder::AliTOFClusterFinder(AliTOFcalib *calib):
6786addd 146 TTask("AliTOFClusterFinder",""),
d08a92dd 147 fRunLoader(0),
148 fTOFLoader(0),
149 fTreeD(0),
150 fTreeR(0),
151 fDigits(new TClonesArray("AliTOFdigit", 4000)),
152 fRecPoints(new TClonesArray("AliTOFcluster", 4000)),
15ec34b9 153 fNumberOfTofClusters(0),
6786addd 154 fNumberOfTofTrgPads(0),
7813bb1a 155 fVerbose(0),
94f5f8f2 156 fDecoderVersion(0),
0275b7df 157 fTOFcalib(calib),
158 fTOFRawStream(AliTOFRawStream())
d08a92dd 159{
160//
161// Constructor
162//
163
1d834a1e 164 for (Int_t ii=0; ii<kTofMaxCluster; ii++) fTofClusters[ii]=0x0;
165
87e6e016 166 TString validity = (TString)fTOFcalib->GetOfflineValidity();
167 if (validity.CompareTo("valid")==0) {
168 AliInfo(Form(" validity = %s - Using offline calibration parameters",validity.Data()));
169 } else {
170 AliInfo(Form(" validity = %s - Using online calibration parameters",validity.Data()));
171 }
172
d08a92dd 173}
2bf66a2d 174
d08a92dd 175//______________________________________________________________________________
176
94f5f8f2 177AliTOFClusterFinder::AliTOFClusterFinder(AliRunLoader* runLoader, AliTOFcalib *calib):
6786addd 178 TTask("AliTOFClusterFinder",""),
d08a92dd 179 fRunLoader(runLoader),
180 fTOFLoader(runLoader->GetLoader("TOFLoader")),
181 fTreeD(0),
182 fTreeR(0),
183 fDigits(new TClonesArray("AliTOFdigit", 4000)),
184 fRecPoints(new TClonesArray("AliTOFcluster", 4000)),
15ec34b9 185 fNumberOfTofClusters(0),
6786addd 186 fNumberOfTofTrgPads(0),
7813bb1a 187 fVerbose(0),
94f5f8f2 188 fDecoderVersion(0),
0275b7df 189 fTOFcalib(calib),
190 fTOFRawStream(AliTOFRawStream())
d08a92dd 191{
192//
193// Constructor
194//
195
1d834a1e 196 for (Int_t ii=0; ii<kTofMaxCluster; ii++) fTofClusters[ii]=0x0;
197
87e6e016 198 TString validity = (TString)fTOFcalib->GetOfflineValidity();
199 if (validity.CompareTo("valid")==0) {
200 AliInfo(Form(" validity = %s - Using offline calibration parameters",validity.Data()));
201 } else {
202 AliInfo(Form(" validity = %s - Using online calibration parameters",validity.Data()));
203 }
204
7aeeaf38 205}
206
207//------------------------------------------------------------------------
23afbd81 208AliTOFClusterFinder::AliTOFClusterFinder(const AliTOFClusterFinder &source) :
6786addd 209 TTask(source),
58d8d9a3 210 fRunLoader(0),
211 fTOFLoader(0),
212 fTreeD(0),
213 fTreeR(0),
8a190ba2 214 fDigits(source.fDigits),
215 fRecPoints(source.fRecPoints),
15ec34b9 216 fNumberOfTofClusters(0),
6786addd 217 fNumberOfTofTrgPads(0),
94f5f8f2 218 fVerbose(0),
8a190ba2 219 fDecoderVersion(source.fDecoderVersion),
0275b7df 220 fTOFcalib(source.fTOFcalib),
221 fTOFRawStream(source.fTOFRawStream)
7aeeaf38 222{
223 // copy constructor
1d834a1e 224
225 for (Int_t ii=0; ii<kTofMaxCluster; ii++) fTofClusters[ii]=source.fTofClusters[ii];
226
7aeeaf38 227}
228
229//------------------------------------------------------------------------
d0eb8f39 230AliTOFClusterFinder& AliTOFClusterFinder::operator=(const AliTOFClusterFinder &source)
7aeeaf38 231{
232 // ass. op.
8a190ba2 233
234 if (this == &source)
235 return *this;
236
6786addd 237 TTask::operator=(source);
8a190ba2 238 fDigits=source.fDigits;
239 fRecPoints=source.fRecPoints;
240 fVerbose=source.fVerbose;
241 fDecoderVersion=source.fDecoderVersion;
242 fTOFcalib=source.fTOFcalib;
0275b7df 243 fTOFRawStream=source.fTOFRawStream;
1d834a1e 244 for (Int_t ii=0; ii<kTofMaxCluster; ii++) fTofClusters[ii]=source.fTofClusters[ii];
245
7aeeaf38 246 return *this;
247
d08a92dd 248}
249//______________________________________________________________________________
250
251AliTOFClusterFinder::~AliTOFClusterFinder()
252{
253
254 //
255 // Destructor
256 //
257
258 if (fDigits)
259 {
260 fDigits->Delete();
261 delete fDigits;
262 fDigits=0;
263 }
264 if (fRecPoints)
265 {
266 fRecPoints->Delete();
267 delete fRecPoints;
268 fRecPoints=0;
269 }
270
8104fec9 271 //if (fTofClusters || fNumberOfTofClusters) {
272 if (fNumberOfTofClusters) {
cc06352e 273 for (Int_t ii=0; ii<kTofMaxCluster; ii++) {
fd6c5c3d 274 if (fTofClusters[ii]) fTofClusters[ii]->Delete();
cc06352e 275 delete fTofClusters[ii];
276 }
8ba211c3 277 fNumberOfTofClusters=0;
278 }
279
6786addd 280 fNumberOfTofTrgPads=0;
281
d08a92dd 282}
283//______________________________________________________________________________
284
285void AliTOFClusterFinder::Digits2RecPoints(Int_t iEvent)
286{
287 //
288 // Converts digits to recpoints for TOF
289 //
290
515faf5d 291 TStopwatch stopwatch;
292 stopwatch.Start();
293
56483762 294 Int_t inholes = 0;
295
d08a92dd 296 fRunLoader->GetEvent(iEvent);
297
298 fTreeD = fTOFLoader->TreeD();
de40f9c1 299 if (fTreeD == 0x0) {
300 AliFatal("AliTOFClusterFinder: Can not get TreeD");
301 return;
302 }
d08a92dd 303
23afbd81 304 fDigits->Clear();
305 fTreeD->GetBranch("TOF")->SetAutoDelete(kFALSE);
306 fTreeD->SetBranchAddress("TOF",&fDigits);
d08a92dd 307
308 ResetRecpoint();
309
310 fTreeR = fTOFLoader->TreeR();
311 if (fTreeR == 0x0)
312 {
313 fTOFLoader->MakeTree("R");
314 fTreeR = fTOFLoader->TreeR();
315 }
316
317 Int_t bufsize = 32000;
318 fTreeR->Branch("TOF", &fRecPoints, bufsize);
319
320 fTreeD->GetEvent(0);
23afbd81 321 Int_t nDigits = fDigits->GetEntriesFast();
d08a92dd 322 AliDebug(2,Form("Number of TOF digits: %d",nDigits));
323
ac359ffe 324 Int_t ii;
3495d79c 325 Int_t dig[5]={-1,-1,-1,-1,-1}; //cluster detector indeces
326 Int_t parTOF[7]={0,0,0,0,0,0,0}; //The TOF signal parameters
bf33f8f0 327 Bool_t status=kTRUE; // assume all sim channels ok in the beginning...
d08a92dd 328 for (ii=0; ii<nDigits; ii++) {
23afbd81 329 AliTOFdigit *d = (AliTOFdigit*)fDigits->UncheckedAt(ii);
d08a92dd 330 dig[0]=d->GetSector();
331 dig[1]=d->GetPlate();
332 dig[2]=d->GetStrip();
333 dig[3]=d->GetPadz();
334 dig[4]=d->GetPadx();
335
729f0d7f 336 /* check valid index */
337 if (dig[0]==-1||dig[1]==-1||dig[2]==-1||dig[3]==-1||dig[4]==-1) continue;
338
56483762 339 // Do not reconstruct anything in the holes
340 if (dig[0]==13 || dig[0]==14 || dig[0]==15 ) { // sectors with holes
341 if (dig[1]==2) { // plate with holes
342 inholes++;
343 continue;
344 }
345 }
346
2bf66a2d 347 AliDebug(2,Form(" %2d %1d %2d %1d %2d ",dig[0],dig[1],dig[2],dig[3],dig[4]));
d0eb8f39 348
bf33f8f0 349 parTOF[0] = d->GetTdc(); //the TDC signal
350 parTOF[1] = d->GetToT(); //the ToT signal
351 parTOF[2] = d->GetAdc(); // the adc charge
352 parTOF[3] = d->GetTdcND(); // non decalibrated sim time
353 parTOF[4] = d->GetTdc(); // raw time, == Tdc time for the moment
2bf4d9d6 354 parTOF[5] = 0; // deltaBC
355 parTOF[6] = 0; // L0-L1 latency
ac359ffe 356 Double_t posClus[3];
357 Double_t covClus[6];
358 UShort_t volIdClus=GetClusterVolIndex(dig);
359 GetClusterPars(dig, posClus,covClus);
360 AliTOFcluster *tofCluster = new AliTOFcluster(volIdClus,posClus[0],posClus[1],posClus[2],covClus[0],covClus[1],covClus[2],covClus[3],covClus[4],covClus[5],d->GetTracks(),dig,parTOF,status,ii);
d08a92dd 361 InsertCluster(tofCluster);
bafe290d 362
d08a92dd 363 }
364
bafe290d 365 AliDebug(1,Form("Number of found clusters: %d for event: %d", fNumberOfTofClusters, iEvent));
d08a92dd 366
37879eed 367 CalibrateRecPoint();
d08a92dd 368 FillRecPoint();
369
370 fTreeR->Fill();
6786addd 371// ResetRecpoint();
d08a92dd 372
373 fTOFLoader = fRunLoader->GetLoader("TOFLoader");
374 fTOFLoader->WriteRecPoints("OVERWRITE");
375
bafe290d 376 AliDebug(1,Form("Execution time to read TOF digits and to write TOF clusters : R:%.4fs C:%.4fs",
377 stopwatch.RealTime(),stopwatch.CpuTime()));
56483762 378 if (inholes) AliWarning(Form("Clusters in the TOF holes: %d",inholes));
515faf5d 379
94f5f8f2 380}
381
382//______________________________________________________________________________
383
384void AliTOFClusterFinder::Digits2RecPoints(TTree* digitsTree, TTree* clusterTree)
385{
386 //
387 // Converts digits to recpoints for TOF
388 //
389
390 TStopwatch stopwatch;
391 stopwatch.Start();
392
56483762 393 Int_t inholes = 0;
394
de40f9c1 395 if (digitsTree == 0x0) {
396 AliFatal("AliTOFClusterFinder: Can not get TreeD");
397 return;
398 }
94f5f8f2 399
23afbd81 400 fDigits->Clear();
401 digitsTree->GetBranch("TOF")->SetAutoDelete(kFALSE);
402 digitsTree->SetBranchAddress("TOF",&fDigits);
94f5f8f2 403
404 ResetRecpoint();
94f5f8f2 405 Int_t bufsize = 32000;
23afbd81 406 clusterTree->Branch("TOF", &fRecPoints, bufsize);
94f5f8f2 407
408 digitsTree->GetEvent(0);
23afbd81 409 Int_t nDigits = fDigits->GetEntriesFast();
94f5f8f2 410 AliDebug(2,Form("Number of TOF digits: %d",nDigits));
411
ac359ffe 412 Int_t ii;
3495d79c 413 Int_t dig[5]={-1,-1,-1,-1,-1}; //cluster detector indeces
414 Int_t parTOF[7]={0,0,0,0,0,0,0}; //The TOF signal parameters
94f5f8f2 415 Bool_t status=kTRUE; // assume all sim channels ok in the beginning...
416 for (ii=0; ii<nDigits; ii++) {
23afbd81 417 AliTOFdigit *d = (AliTOFdigit*)fDigits->UncheckedAt(ii);
94f5f8f2 418 dig[0]=d->GetSector();
419 dig[1]=d->GetPlate();
420 dig[2]=d->GetStrip();
421 dig[3]=d->GetPadz();
422 dig[4]=d->GetPadx();
423
729f0d7f 424 /* check valid index */
425 if (dig[0]==-1||dig[1]==-1||dig[2]==-1||dig[3]==-1||dig[4]==-1) continue;
426
56483762 427 // Do not reconstruct anything in the holes
428 if (dig[0]==13 || dig[0]==14 || dig[0]==15 ) { // sectors with holes
429 if (dig[1]==2) { // plate with holes
430 inholes++;
431 continue;
432 }
433 }
434
2bf66a2d 435 // AliDebug(2,Form(" %2d %1d %2d %1d %2d ",dig[0],dig[1],dig[2],dig[3],dig[4]));
94f5f8f2 436
94f5f8f2 437 parTOF[0] = d->GetTdc(); //the TDC signal
438 parTOF[1] = d->GetToT(); //the ToT signal
439 parTOF[2] = d->GetAdc(); // the adc charge
440 parTOF[3] = d->GetTdcND(); // non decalibrated sim time
441 parTOF[4] = d->GetTdc(); // raw time, == Tdc time for the moment
2bf4d9d6 442 parTOF[5] = 0; // deltaBC
443 parTOF[6] = 0; // L0-L1 latency
ac359ffe 444
445 Double_t posClus[3];
446 Double_t covClus[6];
447 UShort_t volIdClus=GetClusterVolIndex(dig);
448 GetClusterPars(dig,posClus,covClus);
2bf66a2d 449 AliTOFcluster *tofCluster = new AliTOFcluster(volIdClus,posClus[0],posClus[1],posClus[2],covClus[0],covClus[1],covClus[2],covClus[3],covClus[4],covClus[5],d->GetTracks(),dig,parTOF,status,ii);
94f5f8f2 450 InsertCluster(tofCluster);
451
452 }
453
bafe290d 454 AliDebug(1,Form("Number of found clusters: %d", fNumberOfTofClusters));
94f5f8f2 455
456 CalibrateRecPoint();
457 FillRecPoint();
458
459 clusterTree->Fill();
6786addd 460// ResetRecpoint();
94f5f8f2 461
bafe290d 462 AliDebug(1,Form("Execution time to read TOF digits and to write TOF clusters : R:%.4fs C:%.4fs",
463 stopwatch.RealTime(),stopwatch.CpuTime()));
56483762 464 if (inholes) AliWarning(Form("Clusters in the TOF holes: %d",inholes));
94f5f8f2 465
d08a92dd 466}
467//______________________________________________________________________________
468
469void AliTOFClusterFinder::Digits2RecPoints(AliRawReader *rawReader,
470 TTree *clustersTree)
471{
472 //
473 // Converts RAW data to recpoints for TOF
474 //
475
515faf5d 476 TStopwatch stopwatch;
477 stopwatch.Start();
478
56483762 479 Int_t inholes = 0;
480
d0eb8f39 481 const Int_t kDDL = AliDAQ::NumberOfDdls("TOF");
d08a92dd 482
483 ResetRecpoint();
484
485 Int_t bufsize = 32000;
486 clustersTree->Branch("TOF", &fRecPoints, bufsize);
487
15ec34b9 488 TClonesArray * clonesRawData;
15ec34b9 489 Int_t dummy = -1;
d08a92dd 490
6786addd 491 Int_t detectorIndex[5]={-1,-1,-1,-1,-1};
492 Int_t parTOF[7]={-1,-1,-1,-1,-1,-1,-1};
d08a92dd 493
15ec34b9 494 ofstream ftxt;
495 if (fVerbose==2) ftxt.open("TOFdigitsRead.txt",ios::app);
496
0275b7df 497 fTOFRawStream.Clear();
498 fTOFRawStream.SetRawReader(rawReader);
ef58b2af 499
5b4ed716 500 if (fDecoderVersion == 1) {
bafe290d 501 AliInfo("Using New Decoder");
5b4ed716 502 }
503 else if (fDecoderVersion == 2) {
504 AliInfo("Using Enhanced Decoder");
505 }
506 else {
507 AliInfo("Using Old Decoder");
508 }
bafe290d 509
15ec34b9 510 Int_t indexDDL = 0;
511 for (indexDDL = 0; indexDDL < kDDL; indexDDL++) {
512
513 rawReader->Reset();
5b4ed716 514 if (fDecoderVersion == 1) {
0275b7df 515 fTOFRawStream.LoadRawDataBuffers(indexDDL,fVerbose);
5b4ed716 516 }
517 else if (fDecoderVersion == 2) {
518 fTOFRawStream.LoadRawDataBuffersV2(indexDDL,fVerbose);
519 }
520 else {
521 fTOFRawStream.LoadRawData(indexDDL);
522 }
523
0275b7df 524 clonesRawData = (TClonesArray*)fTOFRawStream.GetRawData();
23afbd81 525
15ec34b9 526 for (Int_t iRawData = 0; iRawData<clonesRawData->GetEntriesFast(); iRawData++) {
527
528 AliTOFrawData *tofRawDatum = (AliTOFrawData*)clonesRawData->UncheckedAt(iRawData);
529
c3891b7a 530 //if (tofRawDatum->GetTOT()==-1 || tofRawDatum->GetTOF()==-1) continue;
531 if (tofRawDatum->GetTOF()==-1) continue;
15ec34b9 532
533 if (fVerbose==2) {
534 if (indexDDL<10) ftxt << " " << indexDDL;
535 else ftxt << " " << indexDDL;
536 if (tofRawDatum->GetTRM()<10) ftxt << " " << tofRawDatum->GetTRM();
537 else ftxt << " " << tofRawDatum->GetTRM();
538 ftxt << " " << tofRawDatum->GetTRMchain();
539 if (tofRawDatum->GetTDC()<10) ftxt << " " << tofRawDatum->GetTDC();
540 else ftxt << " " << tofRawDatum->GetTDC();
541 ftxt << " " << tofRawDatum->GetTDCchannel();
542 }
543
6786addd 544 if ( tofRawDatum->GetTRM()==3 &&
545 (tofRawDatum->GetTDC()> 11 && tofRawDatum->GetTDC()< 15) ) FillTOFtriggerMap(indexDDL, tofRawDatum);
546
547 for (Int_t aa=0; aa<5; aa++) detectorIndex[aa] = -1;
548
0275b7df 549 fTOFRawStream.EquipmentId2VolumeId(indexDDL, tofRawDatum->GetTRM(), tofRawDatum->GetTRMchain(),
550 tofRawDatum->GetTDC(), tofRawDatum->GetTDCchannel(), detectorIndex);
15ec34b9 551 dummy = detectorIndex[3];
552 detectorIndex[3] = detectorIndex[4];
553 detectorIndex[4] = dummy;
554
555 if (fVerbose==2) {
556 if (detectorIndex[0]<10) ftxt << " -> " << detectorIndex[0];
557 else ftxt << " -> " << detectorIndex[0];
558 ftxt << " " << detectorIndex[1];
559 if (detectorIndex[2]<10) ftxt << " " << detectorIndex[2];
560 else ftxt << " " << detectorIndex[2];
561 ftxt << " " << detectorIndex[3];
562 if (detectorIndex[4]<10) ftxt << " " << detectorIndex[4];
563 else ftxt << " " << detectorIndex[4];
564 }
565
729f0d7f 566 /* check valid index */
567 if (detectorIndex[0]==-1||detectorIndex[1]==-1||detectorIndex[2]==-1||detectorIndex[3]==-1||detectorIndex[4]==-1) continue;
568
56483762 569 // Do not reconstruct anything in the holes
570 if (detectorIndex[0]==13 || detectorIndex[0]==14 || detectorIndex[0]==15 ) { // sectors with holes
571 if (detectorIndex[1]==2) { // plate with holes
572 inholes++;
573 continue;
574 }
575 }
576
bf33f8f0 577 parTOF[0] = tofRawDatum->GetTOF(); //TDC
578 parTOF[1] = tofRawDatum->GetTOT(); // TOT
579 parTOF[2] = tofRawDatum->GetTOT(); //ADC==TOF
3495d79c 580 parTOF[3] = 0;//raw data: no track of undecalib sim time
bf33f8f0 581 parTOF[4] = tofRawDatum->GetTOF(); // RAW time
2bf4d9d6 582 parTOF[5] = tofRawDatum->GetDeltaBC(); // deltaBC
583 parTOF[6] = tofRawDatum->GetL0L1Latency(); // L0-L1 latency
ac359ffe 584 Double_t posClus[3];
585 Double_t covClus[6];
586 UShort_t volIdClus=GetClusterVolIndex(detectorIndex);
587 Int_t lab[3]={-1,-1,-1};
588 Bool_t status=kTRUE;
589 GetClusterPars(detectorIndex,posClus,covClus);
2bf66a2d 590 AliTOFcluster *tofCluster = new AliTOFcluster(volIdClus,posClus[0],posClus[1],posClus[2],covClus[0],covClus[1],covClus[2],covClus[3],covClus[4],covClus[5],lab,detectorIndex,parTOF,status,-1);
15ec34b9 591 InsertCluster(tofCluster);
592
593 if (fVerbose==2) {
bf33f8f0 594 if (parTOF[1]<10)ftxt << " " << parTOF[1];
595 else if (parTOF[1]>=10 && parTOF[1]<100) ftxt << " " << parTOF[1];
596 else ftxt << " " << parTOF[1];
597 if (parTOF[0]<10) ftxt << " " << parTOF[0] << endl;
598 else if (parTOF[0]>=10 && parTOF[0]<100) ftxt << " " << parTOF[0] << endl;
599 else if (parTOF[0]>=100 && parTOF[0]<1000) ftxt << " " << parTOF[0] << endl;
c5cf594b 600 else ftxt << " " << parTOF[0] << endl;
15ec34b9 601 }
602
603 } // closed loop on TOF raw data per current DDL file
604
23afbd81 605 clonesRawData->Clear("C");
15ec34b9 606
607 } // closed loop on DDL index
608
15ec34b9 609 if (fVerbose==2) ftxt.close();
d08a92dd 610
bafe290d 611 AliDebug(1,Form("Number of found clusters: %d", fNumberOfTofClusters));
d08a92dd 612
f04b3a69 613 CalibrateRecPoint(rawReader->GetTimestamp());
d08a92dd 614 FillRecPoint();
615
616 clustersTree->Fill();
37879eed 617
6786addd 618// ResetRecpoint();
d08a92dd 619
515faf5d 620 AliDebug(1, Form("Execution time to read TOF raw data and to write TOF clusters : R:%.4fs C:%.4fs",
621 stopwatch.RealTime(),stopwatch.CpuTime()));
56483762 622 if (inholes) AliWarning(Form("Clusters in the TOF holes: %d",inholes));
515faf5d 623
d08a92dd 624}
625//______________________________________________________________________________
626
627void AliTOFClusterFinder::Digits2RecPoints(Int_t iEvent, AliRawReader *rawReader)
628{
629 //
630 // Converts RAW data to recpoints for TOF
631 //
632
515faf5d 633 TStopwatch stopwatch;
634 stopwatch.Start();
635
56483762 636 Int_t inholes = 0;
637
d0eb8f39 638 const Int_t kDDL = AliDAQ::NumberOfDdls("TOF");
d08a92dd 639
640 fRunLoader->GetEvent(iEvent);
641
2bf66a2d 642 AliDebug(2,Form(" Event number %2d ", iEvent));
d08a92dd 643
644 fTreeR = fTOFLoader->TreeR();
645
646 if (fTreeR == 0x0){
647 fTOFLoader->MakeTree("R");
648 fTreeR = fTOFLoader->TreeR();
649 }
650
651 Int_t bufsize = 32000;
652 fTreeR->Branch("TOF", &fRecPoints, bufsize);
653
15ec34b9 654 TClonesArray * clonesRawData;
655
15ec34b9 656 Int_t dummy = -1;
d08a92dd 657
d0eb8f39 658 Int_t detectorIndex[5] = {-1, -1, -1, -1, -1};
2bf4d9d6 659 Int_t parTOF[7];
15ec34b9 660 ofstream ftxt;
661 if (fVerbose==2) ftxt.open("TOFdigitsRead.txt",ios::app);
662
0275b7df 663 fTOFRawStream.Clear();
664 fTOFRawStream.SetRawReader(rawReader);
ef58b2af 665
5b4ed716 666 if (fDecoderVersion == 1) {
bafe290d 667 AliInfo("Using New Decoder");
5b4ed716 668 }
669 else if (fDecoderVersion == 2) {
670 AliInfo("Using Enhanced Decoder");
671 }
672 else {
673 AliInfo("Using Old Decoder");
674 }
bafe290d 675
15ec34b9 676 Int_t indexDDL = 0;
d08a92dd 677 for (indexDDL = 0; indexDDL < kDDL; indexDDL++) {
678
679 rawReader->Reset();
5b4ed716 680 if (fDecoderVersion == 1) {
0275b7df 681 fTOFRawStream.LoadRawDataBuffers(indexDDL,fVerbose);
5b4ed716 682 }
683 else if (fDecoderVersion == 2) {
684 fTOFRawStream.LoadRawDataBuffersV2(indexDDL,fVerbose);
685 }
686 else {
687 fTOFRawStream.LoadRawData(indexDDL);
688 }
15ec34b9 689
0275b7df 690 clonesRawData = (TClonesArray*)fTOFRawStream.GetRawData();
15ec34b9 691
692 for (Int_t iRawData = 0; iRawData<clonesRawData->GetEntriesFast(); iRawData++) {
693
694 AliTOFrawData *tofRawDatum = (AliTOFrawData*)clonesRawData->UncheckedAt(iRawData);
695
c3891b7a 696 //if (tofRawDatum->GetTOT()==-1 || tofRawDatum->GetTOF()==-1) continue;
697 if (tofRawDatum->GetTOF()==-1) continue;
15ec34b9 698
699 if (fVerbose==2) {
700 if (indexDDL<10) ftxt << " " << indexDDL;
701 else ftxt << " " << indexDDL;
702 if (tofRawDatum->GetTRM()<10) ftxt << " " << tofRawDatum->GetTRM();
703 else ftxt << " " << tofRawDatum->GetTRM();
704 ftxt << " " << tofRawDatum->GetTRMchain();
705 if (tofRawDatum->GetTDC()<10) ftxt << " " << tofRawDatum->GetTDC();
706 else ftxt << " " << tofRawDatum->GetTDC();
707 ftxt << " " << tofRawDatum->GetTDCchannel();
708 }
709
0275b7df 710 fTOFRawStream.EquipmentId2VolumeId(indexDDL, tofRawDatum->GetTRM(), tofRawDatum->GetTRMchain(),
711 tofRawDatum->GetTDC(), tofRawDatum->GetTDCchannel(), detectorIndex);
15ec34b9 712 dummy = detectorIndex[3];
713 detectorIndex[3] = detectorIndex[4];
714 detectorIndex[4] = dummy;
715
716 if (fVerbose==2) {
717 if (detectorIndex[0]<10) ftxt << " -> " << detectorIndex[0];
718 else ftxt << " -> " << detectorIndex[0];
719 ftxt << " " << detectorIndex[1];
720 if (detectorIndex[2]<10) ftxt << " " << detectorIndex[2];
721 else ftxt << " " << detectorIndex[2];
722 ftxt << " " << detectorIndex[3];
723 if (detectorIndex[4]<10) ftxt << " " << detectorIndex[4];
724 else ftxt << " " << detectorIndex[4];
725 }
d0eb8f39 726
729f0d7f 727 /* check valid index */
728 if (detectorIndex[0]==-1||detectorIndex[1]==-1||detectorIndex[2]==-1||detectorIndex[3]==-1||detectorIndex[4]==-1) continue;
729
56483762 730 // Do not reconstruct anything in the holes
731 if (detectorIndex[0]==13 || detectorIndex[0]==14 || detectorIndex[0]==15 ) { // sectors with holes
732 if (detectorIndex[1]==2) { // plate with holes
733 inholes++;
734 continue;
735 }
736 }
737
bf33f8f0 738 parTOF[0] = tofRawDatum->GetTOF(); // TDC
739 parTOF[1] = tofRawDatum->GetTOT(); // TOT
740 parTOF[2] = tofRawDatum->GetTOT(); // raw data have ADC=TOT
3495d79c 741 parTOF[3] = 0; //raw data: no track of the undecalib sim time
bf33f8f0 742 parTOF[4] = tofRawDatum->GetTOF(); // Raw time == TDC
2bf4d9d6 743 parTOF[5] = tofRawDatum->GetDeltaBC(); // deltaBC
744 parTOF[6] = tofRawDatum->GetL0L1Latency(); // L0-L1 latency
ac359ffe 745 Double_t posClus[3];
746 Double_t covClus[6];
747 UShort_t volIdClus=GetClusterVolIndex(detectorIndex);
748 Int_t lab[3]={-1,-1,-1};
749 Bool_t status=kTRUE;
750 GetClusterPars(detectorIndex,posClus,covClus);
751 AliTOFcluster *tofCluster = new AliTOFcluster(volIdClus,posClus[0],posClus[1],posClus[2],covClus[0],covClus[1],covClus[2],covClus[3],covClus[4],covClus[5],lab,detectorIndex,parTOF,status,-1);
d08a92dd 752 InsertCluster(tofCluster);
753
15ec34b9 754 if (fVerbose==2) {
bf33f8f0 755 if (parTOF[1]<10)ftxt << " " << parTOF[1];
756 else if (parTOF[1]>=10 && parTOF[1]<100) ftxt << " " << parTOF[1];
757 else ftxt << " " << parTOF[1];
758 if (parTOF[0]<10) ftxt << " " << parTOF[0] << endl;
759 else if (parTOF[0]>=10 && parTOF[0]<100) ftxt << " " << parTOF[0] << endl;
760 else if (parTOF[0]>=100 && parTOF[0]<1000) ftxt << " " << parTOF[0] << endl;
c5cf594b 761 else ftxt << " " << parTOF[0] << endl;
15ec34b9 762 }
d08a92dd 763
15ec34b9 764 } // closed loop on TOF raw data per current DDL file
765
23afbd81 766 clonesRawData->Clear("C");
15ec34b9 767
768 } // closed loop on DDL index
769
770 if (fVerbose==2) ftxt.close();
d08a92dd 771
bafe290d 772 AliDebug(1,Form("Number of found clusters: %d for event: %d", fNumberOfTofClusters, iEvent));
d08a92dd 773
f04b3a69 774 CalibrateRecPoint(rawReader->GetTimestamp());
d08a92dd 775 FillRecPoint();
776
777 fTreeR->Fill();
6786addd 778// ResetRecpoint();
d08a92dd 779
780 fTOFLoader = fRunLoader->GetLoader("TOFLoader");
781 fTOFLoader->WriteRecPoints("OVERWRITE");
782
515faf5d 783 AliDebug(1, Form("Execution time to read TOF raw data and to write TOF clusters : R:%.4fs C:%.4fs",
784 stopwatch.RealTime(),stopwatch.CpuTime()));
56483762 785 if (inholes) AliWarning(Form("Clusters in the TOF holes: %d",inholes));
515faf5d 786
d08a92dd 787}
788//______________________________________________________________________________
789
790void AliTOFClusterFinder::Raw2Digits(Int_t iEvent, AliRawReader *rawReader)
791{
792 //
793 // Converts RAW data to MC digits for TOF
794 //
795 // (temporary solution)
796 //
797
515faf5d 798 TStopwatch stopwatch;
799 stopwatch.Start();
800
ba66add8 801 const Int_t kDDL = AliTOFGeometry::NDDL()*AliTOFGeometry::NSectors();
15ec34b9 802
d08a92dd 803 fRunLoader->GetEvent(iEvent);
804
805 fTreeD = fTOFLoader->TreeD();
806 if (fTreeD)
807 {
d0eb8f39 808 AliInfo("TreeD re-creation");
d08a92dd 809 fTreeD = 0x0;
810 fTOFLoader->MakeTree("D");
811 fTreeD = fTOFLoader->TreeD();
812 }
8104fec9 813 else {
814 AliFatal("Can not get TreeD");
815 return;
816 }
d08a92dd 817
d08a92dd 818 Int_t bufsize = 32000;
23afbd81 819 fDigits->Clear();
820 fTreeD->Branch("TOF", &fDigits, bufsize);
d08a92dd 821
d08a92dd 822 fRunLoader->GetEvent(iEvent);
823
2bf66a2d 824 AliDebug(2,Form(" Event number %2d ", iEvent));
d08a92dd 825
15ec34b9 826 TClonesArray * clonesRawData;
827
828 Int_t dummy = -1;
d08a92dd 829
830 Int_t detectorIndex[5];
bf33f8f0 831 Int_t digit[4];
d08a92dd 832
0275b7df 833 fTOFRawStream.Clear();
834 fTOFRawStream.SetRawReader(rawReader);
ef58b2af 835
5b4ed716 836 if (fDecoderVersion == 1) {
bafe290d 837 AliInfo("Using New Decoder");
5b4ed716 838 }
839 else if (fDecoderVersion == 2) {
840 AliInfo("Using Enhanced Decoder");
841 }
842 else {
843 AliInfo("Using Old Decoder");
844 }
bafe290d 845
15ec34b9 846 Int_t indexDDL = 0;
d08a92dd 847 for (indexDDL = 0; indexDDL < kDDL; indexDDL++) {
848
849 rawReader->Reset();
5b4ed716 850 if (fDecoderVersion == 1) {
0275b7df 851 fTOFRawStream.LoadRawDataBuffers(indexDDL,fVerbose);
5b4ed716 852 }
853 else if (fDecoderVersion == 2) {
854 fTOFRawStream.LoadRawDataBuffersV2(indexDDL,fVerbose);
855 }
856 else {
857 fTOFRawStream.LoadRawData(indexDDL);
858 }
d08a92dd 859
0275b7df 860 clonesRawData = (TClonesArray*)fTOFRawStream.GetRawData();
d08a92dd 861
15ec34b9 862 for (Int_t iRawData = 0; iRawData<clonesRawData->GetEntriesFast(); iRawData++) {
d0eb8f39 863
15ec34b9 864 AliTOFrawData *tofRawDatum = (AliTOFrawData*)clonesRawData->UncheckedAt(iRawData);
d0eb8f39 865
3e2f0097 866 //if (!tofRawDatum->GetTOT() || !tofRawDatum->GetTOF()) continue;
867 if (tofRawDatum->GetTOF()==-1) continue;
15ec34b9 868
0275b7df 869 fTOFRawStream.EquipmentId2VolumeId(indexDDL, tofRawDatum->GetTRM(), tofRawDatum->GetTRMchain(),
870 tofRawDatum->GetTDC(), tofRawDatum->GetTDCchannel(), detectorIndex);
15ec34b9 871 dummy = detectorIndex[3];
872 detectorIndex[3] = detectorIndex[4];
873 detectorIndex[4] = dummy;
d0eb8f39 874
0275b7df 875 digit[0] = fTOFRawStream.GetTofBin();
876 digit[1] = fTOFRawStream.GetToTbin();
877 digit[2] = fTOFRawStream.GetToTbin();
3495d79c 878 digit[3] = 0;
d08a92dd 879
880 Int_t tracknum[3]={-1,-1,-1};
881
23afbd81 882 TClonesArray &aDigits = *fDigits;
883 Int_t last=fDigits->GetEntriesFast();
d08a92dd 884 new (aDigits[last]) AliTOFdigit(tracknum, detectorIndex, digit);
885
886 } // while loop
887
23afbd81 888 clonesRawData->Clear("C");
15ec34b9 889
d08a92dd 890 } // DDL Loop
891
892 fTreeD->Fill();
893
894 fTOFLoader = fRunLoader->GetLoader("TOFLoader");
895 fTOFLoader->WriteDigits("OVERWRITE");
2bf66a2d 896
515faf5d 897 AliDebug(1, Form("Execution time to read TOF raw data and to write TOF clusters : R:%.2fs C:%.2fs",
898 stopwatch.RealTime(),stopwatch.CpuTime()));
899
94f5f8f2 900}
901
902//______________________________________________________________________________
903
904void AliTOFClusterFinder::Raw2Digits(AliRawReader *rawReader, TTree* digitsTree)
905{
906 //
907 // Converts RAW data to MC digits for TOF for the current event
908 //
909 //
910
911 TStopwatch stopwatch;
912 stopwatch.Start();
913
ba66add8 914 const Int_t kDDL = AliTOFGeometry::NDDL()*AliTOFGeometry::NSectors();
94f5f8f2 915
916 if (!digitsTree)
917 {
918 AliError("No input digits Tree");
919 return;
920 }
921
94f5f8f2 922 Int_t bufsize = 32000;
23afbd81 923 digitsTree->Branch("TOF", &fDigits, bufsize);
94f5f8f2 924
94f5f8f2 925 TClonesArray * clonesRawData;
94f5f8f2 926 Int_t dummy = -1;
927
928 Int_t detectorIndex[5];
929 Int_t digit[4];
930
0275b7df 931 fTOFRawStream.Clear();
932 fTOFRawStream.SetRawReader(rawReader);
ef58b2af 933
5b4ed716 934 if (fDecoderVersion == 1) {
bafe290d 935 AliInfo("Using New Decoder");
5b4ed716 936 }
937 else if (fDecoderVersion == 2) {
938 AliInfo("Using Enhanced Decoder");
939 }
940 else {
941 AliInfo("Using Old Decoder");
942 }
bafe290d 943
94f5f8f2 944 Int_t indexDDL = 0;
945 for (indexDDL = 0; indexDDL < kDDL; indexDDL++) {
946
947 rawReader->Reset();
5b4ed716 948 if (fDecoderVersion == 1) {
0275b7df 949 fTOFRawStream.LoadRawDataBuffers(indexDDL,fVerbose);
5b4ed716 950 }
951 else if (fDecoderVersion == 2) {
952 fTOFRawStream.LoadRawDataBuffersV2(indexDDL,fVerbose);
953 }
954 else {
955 fTOFRawStream.LoadRawData(indexDDL);
956 }
94f5f8f2 957
0275b7df 958 clonesRawData = (TClonesArray*)fTOFRawStream.GetRawData();
94f5f8f2 959
960 for (Int_t iRawData = 0; iRawData<clonesRawData->GetEntriesFast(); iRawData++) {
961
962 AliTOFrawData *tofRawDatum = (AliTOFrawData*)clonesRawData->UncheckedAt(iRawData);
963
3e2f0097 964 //if (!tofRawDatum->GetTOT() || !tofRawDatum->GetTOF()) continue;
965 if (tofRawDatum->GetTOF()==-1) continue;
94f5f8f2 966
0275b7df 967 fTOFRawStream.EquipmentId2VolumeId(indexDDL, tofRawDatum->GetTRM(), tofRawDatum->GetTRMchain(),
968 tofRawDatum->GetTDC(), tofRawDatum->GetTDCchannel(), detectorIndex);
94f5f8f2 969 dummy = detectorIndex[3];
970 detectorIndex[3] = detectorIndex[4];
971 detectorIndex[4] = dummy;
972
0275b7df 973 digit[0] = fTOFRawStream.GetTofBin();
974 digit[1] = fTOFRawStream.GetToTbin();
975 digit[2] = fTOFRawStream.GetToTbin();
3495d79c 976 digit[3] = 0;
94f5f8f2 977
978 Int_t tracknum[3]={-1,-1,-1};
979
23afbd81 980 TClonesArray &aDigits = *fDigits;
981 Int_t last=fDigits->GetEntriesFast();
94f5f8f2 982 new (aDigits[last]) AliTOFdigit(tracknum, detectorIndex, digit);
983
984 } // while loop
985
23afbd81 986 clonesRawData->Clear("C");
94f5f8f2 987
988 } // DDL Loop
989
990 digitsTree->Fill();
991
2bf66a2d 992 AliDebug(1, Form("Got %d digits: ", fDigits->GetEntries()));
94f5f8f2 993 AliDebug(1, Form("Execution time to read TOF raw data and fill TOF digit tree : R:%.2fs C:%.2fs",
994 stopwatch.RealTime(),stopwatch.CpuTime()));
995
d08a92dd 996}
997//______________________________________________________________________________
998
999Int_t AliTOFClusterFinder::InsertCluster(AliTOFcluster *tofCluster) {
1000 //---------------------------------------------------------------------------//
1001 // This function adds a TOF cluster to the array of TOF clusters sorted in Z //
1002 //---------------------------------------------------------------------------//
1003 if (fNumberOfTofClusters==kTofMaxCluster) {
1004 AliError("Too many clusters !");
1005 return 1;
1006 }
1007
1008 if (fNumberOfTofClusters==0) {
1009 fTofClusters[fNumberOfTofClusters++] = tofCluster;
1010 return 0;
1011 }
1012
1013 Int_t ii = FindClusterIndex(tofCluster->GetZ());
1014 memmove(fTofClusters+ii+1 ,fTofClusters+ii,(fNumberOfTofClusters-ii)*sizeof(AliTOFcluster*));
1015 fTofClusters[ii] = tofCluster;
1016 fNumberOfTofClusters++;
1017
1018 return 0;
1019
1020}
1021//_________________________________________________________________________
1022
1023Int_t AliTOFClusterFinder::FindClusterIndex(Double_t z) const {
1024 //--------------------------------------------------------------------
ac359ffe 1025 // This function returns the index of the nearest cluster in z
d08a92dd 1026 //--------------------------------------------------------------------
1027 if (fNumberOfTofClusters==0) return 0;
1028 if (z <= fTofClusters[0]->GetZ()) return 0;
1029 if (z > fTofClusters[fNumberOfTofClusters-1]->GetZ()) return fNumberOfTofClusters;
1030 Int_t b = 0, e = fNumberOfTofClusters-1, m = (b+e)/2;
1031 for (; b<e; m=(b+e)/2) {
1032 if (z > fTofClusters[m]->GetZ()) b=m+1;
1033 else e=m;
1034 }
1035
1036 return m;
1037
1038}
1039//_________________________________________________________________________
1040
1041void AliTOFClusterFinder::FillRecPoint()
1042{
1043 //
1044 // Copy the global array of AliTOFcluster, i.e. fTofClusters (sorted
1045 // in Z) in the global TClonesArray of AliTOFcluster,
1046 // i.e. fRecPoints.
1047 //
1048
1049 Int_t ii, jj;
1050
1051 Int_t detectorIndex[5];
2bf4d9d6 1052 Int_t parTOF[7];
d08a92dd 1053 Int_t trackLabels[3];
1054 Int_t digitIndex = -1;
bf33f8f0 1055 Bool_t status=kTRUE;
d08a92dd 1056
1057 TClonesArray &lRecPoints = *fRecPoints;
1058
1059 for (ii=0; ii<fNumberOfTofClusters; ii++) {
e9f92e04 1060 AliTOFcluster* clOr = fTofClusters[ii];
1061 fTofClusters[ii] = 0;
1062 digitIndex = clOr->GetIndex();
1063 for(jj=0; jj<5; jj++) detectorIndex[jj] = clOr->GetDetInd(jj);
1064 for(jj=0; jj<3; jj++) trackLabels[jj] = clOr->GetLabel(jj);
1065 parTOF[0] = clOr->GetTDC(); // TDC
1066 parTOF[1] = clOr->GetToT(); // TOT
1067 parTOF[2] = clOr->GetADC(); // ADC=TOT
1068 parTOF[3] = clOr->GetTDCND(); // TDCND
1069 parTOF[4] = clOr->GetTDCRAW();//RAW
1070 parTOF[5] = clOr->GetDeltaBC();//deltaBC
1071 parTOF[6] = clOr->GetL0L1Latency();//L0-L1 latency
1072 status=clOr->GetStatus();
ac359ffe 1073 Double_t posClus[3];
1074 Double_t covClus[6];
1075 UShort_t volIdClus=GetClusterVolIndex(detectorIndex);
1076 GetClusterPars(detectorIndex,posClus,covClus);
1077 new(lRecPoints[ii]) AliTOFcluster(volIdClus,posClus[0],posClus[1],posClus[2],covClus[0],covClus[1],covClus[2],covClus[3],covClus[4],covClus[5],trackLabels,detectorIndex, parTOF,status,digitIndex);
d08a92dd 1078
2bf66a2d 1079 AliDebug(2, Form(" %4d %4d %f %f %f %f %f %f %f %f %f %3d %3d %3d %2d %1d %2d %1d %2d %4d %3d %3d %4d %4d %1d %4d",
3e2f0097 1080 ii, volIdClus, posClus[0], posClus[1], posClus[2],
e9f92e04 1081 clOr->GetSigmaX2(),
1082 clOr->GetSigmaXY(),
1083 clOr->GetSigmaXZ(),
1084 clOr->GetSigmaY2(),
1085 clOr->GetSigmaYZ(),
1086 clOr->GetSigmaZ2(),
3e2f0097 1087 trackLabels[0], trackLabels[1], trackLabels[2],
1088 detectorIndex[0], detectorIndex[1], detectorIndex[2], detectorIndex[3], detectorIndex[4],
1089 parTOF[0], parTOF[1], parTOF[2], parTOF[3], parTOF[4],
1090 status, digitIndex));
1091
e9f92e04 1092 delete clOr;
d08a92dd 1093 } // loop on clusters
1094
1095}
37879eed 1096
1097//_________________________________________________________________________
5b4ed716 1098
1099/*
1100 * OLD CALIBRATE REC POINTS FUNCTION
1101 */
1102
1103#if 0
f04b3a69 1104void AliTOFClusterFinder::CalibrateRecPoint(UInt_t timestamp)
37879eed 1105{
1106 //
1107 // Copy the global array of AliTOFcluster, i.e. fTofClusters (sorted
1108 // in Z) in the global TClonesArray of AliTOFcluster,
1109 // i.e. fRecPoints.
1110 //
1111
1112 Int_t ii, jj;
1113
1114 Int_t detectorIndex[5];
1115 Int_t digitIndex = -1;
a33fec85 1116 Double_t tToT;
1117 Double_t timeCorr;
bf33f8f0 1118 Int_t tdcCorr;
2bf4d9d6 1119 Float_t tdcLatencyWindow;
bafe290d 1120 AliDebug(1," Calibrating TOF Clusters");
1121
17149e6b 1122 AliTOFChannelOnlineArray *calDelay = fTOFcalib->GetTOFOnlineDelay();
1123 AliTOFChannelOnlineStatusArray *calStatus = fTOFcalib->GetTOFOnlineStatus();
ba66add8 1124 TObjArray *calTOFArrayOffline = fTOFcalib->GetTOFCalArrayOffline();
2bf4d9d6 1125
1126 AliTOFDeltaBCOffset *deltaBCOffsetObj = fTOFcalib->GetDeltaBCOffset();
1127 Int_t deltaBCOffset = deltaBCOffsetObj->GetDeltaBCOffset();
1128 AliTOFCTPLatency *ctpLatencyObj = fTOFcalib->GetCTPLatency();
1129 Float_t ctpLatency = ctpLatencyObj->GetCTPLatency();
f04b3a69 1130 AliTOFRunParams *runParamsObj = fTOFcalib->GetRunParams();
1131 Float_t t0 = runParamsObj->EvalT0(timestamp);
bafe290d 1132
ba66add8 1133 TString validity = (TString)fTOFcalib->GetOfflineValidity();
ba66add8 1134 Int_t calibration = -1;
1135 if (validity.CompareTo("valid")==0) {
87e6e016 1136 //AliInfo(Form(" validity = %s - Using offline calibration parameters",validity.Data()));
ba66add8 1137 calibration = 1;
bafe290d 1138 } else {
87e6e016 1139 //AliInfo(Form(" validity = %s - Using online calibration parameters",validity.Data()));
ba66add8 1140 calibration = 0 ;
1141 }
bafe290d 1142
37879eed 1143 for (ii=0; ii<fNumberOfTofClusters; ii++) {
1144 digitIndex = fTofClusters[ii]->GetIndex();
1145 for(jj=0; jj<5; jj++) detectorIndex[jj] = fTofClusters[ii]->GetDetInd(jj);
1146
ba66add8 1147 Int_t index = AliTOFGeometry::GetIndex(detectorIndex);
37879eed 1148
17149e6b 1149 UChar_t statusPulser=calStatus->GetPulserStatus(index);
1150 UChar_t statusNoise=calStatus->GetNoiseStatus(index);
1151 UChar_t statusHW=calStatus->GetHWStatus(index);
1152 UChar_t status=calStatus->GetStatus(index);
2bf4d9d6 1153 tdcLatencyWindow = calStatus->GetLatencyWindow(index) * 1.e3; /* ns -> ps */
1154
17149e6b 1155 //check the status, also unknown is fine!!!!!!!
1156
2bf66a2d 1157 AliDebug(2, Form(" Status for channel %d = %d",index, (Int_t)status));
17149e6b 1158 if((statusPulser & AliTOFChannelOnlineStatusArray::kTOFPulserBad)==(AliTOFChannelOnlineStatusArray::kTOFPulserBad)||(statusNoise & AliTOFChannelOnlineStatusArray::kTOFNoiseBad)==(AliTOFChannelOnlineStatusArray::kTOFNoiseBad)||(statusHW & AliTOFChannelOnlineStatusArray::kTOFHWBad)==(AliTOFChannelOnlineStatusArray::kTOFHWBad)){
2bf66a2d 1159 AliDebug(2, Form(" Bad Status for channel %d",index));
7fffa85b 1160 fTofClusters[ii]->SetStatus(kFALSE); //odd convention, to avoid conflict with calibration objects currently in the db (temporary solution).
1161 }
1162 else {
2bf66a2d 1163 AliDebug(2, Form(" Good Status for channel %d",index));
7fffa85b 1164 }
58d8d9a3 1165 // Get Rough channel online equalization
17149e6b 1166 Double_t roughDelay=(Double_t)calDelay->GetDelay(index); // in ns
ba66add8 1167 AliDebug(2,Form(" channel delay (ns) = %f", roughDelay));
58d8d9a3 1168 // Get Refined channel offline calibration parameters
ba66add8 1169 if (calibration ==1){
1170 AliTOFChannelOffline * calChannelOffline = (AliTOFChannelOffline*)calTOFArrayOffline->At(index);
1171 Double_t par[6];
1172 for (Int_t j = 0; j<6; j++){
1173 par[j]=(Double_t)calChannelOffline->GetSlewPar(j);
1174 }
bf33f8f0 1175 AliDebug(2,Form(" Calib Pars = %f, %f, %f, %f, %f, %f ",par[0],par[1],par[2],par[3],par[4],par[5]));
2bf66a2d 1176 AliDebug(2,Form(" The ToT and Time, uncorr (counts) = %d , %d", fTofClusters[ii]->GetToT(),fTofClusters[ii]->GetTDC()));
3495d79c 1177 tToT = (Double_t)(fTofClusters[ii]->GetToT()*AliTOFGeometry::ToTBinWidth());
ba66add8 1178 tToT*=1.E-3; //ToT in ns
104ba366 1179
1180 /* check TOT limits and set new TOT in case */
1181 if (tToT < AliTOFGeometry::SlewTOTMin()) tToT = AliTOFGeometry::SlewTOTMin();
1182 if (tToT > AliTOFGeometry::SlewTOTMax()) tToT = AliTOFGeometry::SlewTOTMax();
1183
ba66add8 1184 AliDebug(2,Form(" The ToT and Time, uncorr (ns)= %e, %e",fTofClusters[ii]->GetTDC()*AliTOFGeometry::TdcBinWidth()*1.E-3,tToT));
1185 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; // the time correction (ns)
1186 }
1187 else {
1188 timeCorr = roughDelay; // correction in ns
1189 }
1190 AliDebug(2,Form(" The ToT and Time, uncorr (ns)= %e, %e",fTofClusters[ii]->GetTDC()*AliTOFGeometry::TdcBinWidth()*1.E-3,fTofClusters[ii]->GetToT()*AliTOFGeometry::ToTBinWidth()));
bf33f8f0 1191 AliDebug(2,Form(" The time correction (ns) = %f", timeCorr));
a33fec85 1192 timeCorr=(Double_t)(fTofClusters[ii]->GetTDC())*AliTOFGeometry::TdcBinWidth()*1.E-3-timeCorr;//redefine the time
1193 timeCorr*=1.E3;
1194 AliDebug(2,Form(" The channel time, corr (ps)= %e",timeCorr ));
2bf4d9d6 1195
1196 /* here timeCorr should be already corrected for calibration.
1197 * we now go into further corrections keeping in mind that timeCorr
1198 * is in ps.
1199 *
1200 * the following corrections are performed in this way:
1201 *
f04b3a69 1202 * time = timeRaw - deltaBC + L0L1Latency + CTPLatency - TDCLatencyWindow - T0
2bf4d9d6 1203 *
1204 */
1205
1206 AliDebug(2, Form("applying further corrections (DeltaBC): DeltaBC=%d (BC bins), DeltaBCoffset=%d (BC bins)", fTofClusters[ii]->GetDeltaBC(), deltaBCOffset));
1207 AliDebug(2, Form("applying further corrections (L0L1Latency): L0L1Latency=%d (BC bins)", fTofClusters[ii]->GetL0L1Latency()));
1208 AliDebug(2, Form("applying further corrections (CTPLatency): CTPLatency=%f (ps)", ctpLatency));
1209 AliDebug(2, Form("applying further corrections (TDCLatencyWindow): TDCLatencyWindow=%f (ps)", tdcLatencyWindow));
f04b3a69 1210 AliDebug(2, Form("applying further corrections (T0): T0=%f (ps)", t0));
2bf4d9d6 1211
f04b3a69 1212 /* deltaBC correction (inhibited for the time being) */
1213 // timeCorr -= (fTofClusters[ii]->GetDeltaBC() - deltaBCOffset) * AliTOFGeometry::BunchCrossingBinWidth();
2bf4d9d6 1214 /* L0L1-latency correction */
1215 timeCorr += fTofClusters[ii]->GetL0L1Latency() * AliTOFGeometry::BunchCrossingBinWidth();
1216 /* CTP-latency correction (from OCDB) */
1217 timeCorr += ctpLatency;
1218 /* TDC latency-window correction (from OCDB) */
1219 timeCorr -= tdcLatencyWindow;
f04b3a69 1220 /* T0 correction (from OCDB) */
1221 timeCorr -= t0;
2bf4d9d6 1222
1223 /*
1224 * end of furhter corrections
1225 */
1226
a33fec85 1227 tdcCorr=(Int_t)(timeCorr/AliTOFGeometry::TdcBinWidth()); //the corrected time (tdc counts)
340693af 1228 fTofClusters[ii]->SetTDC(tdcCorr);
6786addd 1229
37879eed 1230 } // loop on clusters
1231
37879eed 1232}
5b4ed716 1233#endif
1234
1235//_________________________________________________________________________
1236
1237void AliTOFClusterFinder::CalibrateRecPoint(UInt_t timestamp)
1238{
1239 //
1240 // Copy the global array of AliTOFcluster, i.e. fTofClusters (sorted
1241 // in Z) in the global TClonesArray of AliTOFcluster,
1242 // i.e. fRecPoints.
1243 //
1244
1245 Int_t detectorIndex[5];
1246 Double_t time, tot, corr;
1247 Int_t deltaBC, l0l1, tdcBin;
1248 for (Int_t ii = 0; ii < fNumberOfTofClusters; ii++) {
1249 for(Int_t jj = 0; jj < 5; jj++) detectorIndex[jj] = fTofClusters[ii]->GetDetInd(jj);
1250
1251 Int_t index = AliTOFGeometry::GetIndex(detectorIndex);
1252
1253 /* check channel enabled */
1254 if (!fTOFcalib->IsChannelEnabled(index)) fTofClusters[ii]->SetStatus(kFALSE);
1255
1256 /* get cluster info */
1257 time = fTofClusters[ii]->GetTDC() * AliTOFGeometry::TdcBinWidth(); /* ps */
1258 tot = fTofClusters[ii]->GetToT() * AliTOFGeometry::ToTBinWidth() * 1.e-3; /* ns */
1259 deltaBC = fTofClusters[ii]->GetDeltaBC();
1260 l0l1 = fTofClusters[ii]->GetL0L1Latency();
1261
1262 /* get correction */
1263 corr = fTOFcalib->GetTimeCorrection(index, tot, deltaBC, l0l1, timestamp); /* ps */
1264 AliDebug(2, Form("calibrate index %d: time=%f (ps) tot=%f (ns) deltaBC=%d l0l1=%d timestamp=%d corr=%f (ps)", index, time, tot, deltaBC, l0l1, timestamp, corr));
1265
1266 /* apply time correction */
1267 time -= corr;
1268
1269 /* convert in TDC bins and set cluster */
3495d79c 1270 //tdcBin = (Int_t)(time / AliTOFGeometry::TdcBinWidth()); //the corrected time (tdc counts)
1271 tdcBin = TMath::Nint(time / AliTOFGeometry::TdcBinWidth()); //the corrected time (tdc counts)
5b4ed716 1272 fTofClusters[ii]->SetTDC(tdcBin);
1273
6786addd 1274 // noferini
1275 Float_t pos[3];
1276 AliTOFGeometry::GetPosPar(detectorIndex, pos);
1277 Float_t length = 0.;
1278 for (Int_t ic = 0; ic < 3; ic++) length += pos[ic] * pos[ic];
1279 length = TMath::Sqrt(length);
1280 Float_t timealligned = tdcBin*24.4 - length * 0.0333564095198152043; // subtract the minimal time in
1281
1282 if(timealligned > -1000 && timealligned < 24000 && fTOFcalib->IsChannelEnabled(index)){
1283 fNumberOfTofTrgPads++;
1284 }
1285
5b4ed716 1286 } // loop on clusters
1287
1288}
1289
d08a92dd 1290//______________________________________________________________________________
1291
1292void AliTOFClusterFinder::ResetRecpoint()
1293{
1294 //
1295 // Clear the list of reconstructed points
1296 //
1297
1298 fNumberOfTofClusters = 0;
6786addd 1299 fNumberOfTofTrgPads = 0;
d08a92dd 1300 if (fRecPoints) fRecPoints->Clear();
1301
1302}
1303//______________________________________________________________________________
1304
1305void AliTOFClusterFinder::Load()
1306{
1307 //
1308 // Load TOF.Digits.root and TOF.RecPoints.root files
1309 //
1310
1311 fTOFLoader->LoadDigits("READ");
1312 fTOFLoader->LoadRecPoints("recreate");
1313
1314}
1315//______________________________________________________________________________
1316
1317void AliTOFClusterFinder::LoadClusters()
1318{
1319 //
1320 // Load TOF.RecPoints.root file
1321 //
1322
1323 fTOFLoader->LoadRecPoints("recreate");
1324
1325}
1326//______________________________________________________________________________
1327
1328void AliTOFClusterFinder::UnLoad()
1329{
1330 //
1331 // Unload TOF.Digits.root and TOF.RecPoints.root files
1332 //
1333
1334 fTOFLoader->UnloadDigits();
1335 fTOFLoader->UnloadRecPoints();
1336
1337}
1338//______________________________________________________________________________
1339
1340void AliTOFClusterFinder::UnLoadClusters()
1341{
1342 //
1343 // Unload TOF.RecPoints.root file
1344 //
1345
1346 fTOFLoader->UnloadRecPoints();
1347
1348}
ac359ffe 1349//-------------------------------------------------------------------------
0e74c396 1350UShort_t AliTOFClusterFinder::GetClusterVolIndex(const Int_t * const ind) const {
ac359ffe 1351
1352 //First of all get the volume ID to retrieve the l2t transformation...
1353 //
1354 // Detector numbering scheme
1355 Int_t nSector = 18;
1356 Int_t nPlate = 5;
1357 Int_t nStripA = 15;
1358 Int_t nStripB = 19;
1359 Int_t nStripC = 19;
1360
1361 Int_t isector =ind[0];
1362 if (isector >= nSector)
1363 AliError(Form("Wrong sector number in TOF (%d) !",isector));
1364 Int_t iplate = ind[1];
1365 if (iplate >= nPlate)
1366 AliError(Form("Wrong plate number in TOF (%d) !",iplate));
1367 Int_t istrip = ind[2];
1368
1369 Int_t stripOffset = 0;
1370 switch (iplate) {
1371 case 0:
1372 stripOffset = 0;
1373 break;
1374 case 1:
1375 stripOffset = nStripC;
1376 break;
1377 case 2:
1378 stripOffset = nStripC+nStripB;
1379 break;
1380 case 3:
1381 stripOffset = nStripC+nStripB+nStripA;
1382 break;
1383 case 4:
1384 stripOffset = nStripC+nStripB+nStripA+nStripB;
1385 break;
1386 default:
1387 AliError(Form("Wrong plate number in TOF (%d) !",iplate));
1388 break;
1389 };
1390
1391 Int_t index= (2*(nStripC+nStripB)+nStripA)*isector +
1392 stripOffset +
1393 istrip;
1394
1395 UShort_t volIndex = AliGeomManager::LayerToVolUID(AliGeomManager::kTOF,index);
1396 return volIndex;
1397}
1398//
1399//-------------------------------------------------------------------------
1400void AliTOFClusterFinder::GetClusterPars(Int_t *ind, Double_t* pos,Double_t* cov) const {
1401
1402 //First of all get the volume ID to retrieve the l2t transformation...
1403 //
1404 UShort_t volIndex = GetClusterVolIndex(ind);
1405 //
1406 //
1407 //we now go in the system of the strip: determine the local coordinates
1408 //
1409 //
1410 // 47---------------------------------------------------0 ^ z
1411 // | | | | | | | | | | | | | | | | | | | | | | | | | | | 1 |
1412 // ----------------------------------------------------- | y going outwards
1413 // | | | | | | | | | | | | | | | | | | | | | | | | | | | 0 | par[0]=0;
1414
1415 // ----------------------------------------------------- |
1416 // x <-----------------------------------------------------
1417
b3e52baa 1418 /*
1419 Float_t localX = (ind[4]-23.5)*AliTOFGeometry::XPad();
1420 Float_t localY = 0;
1421 Float_t localZ = (ind[3]- 0.5)*AliTOFGeometry::ZPad();
1422 */
1423 Float_t localX = (ind[4]-AliTOFGeometry::NpadX()/2)*AliTOFGeometry::XPad()+AliTOFGeometry::XPad()/2.;
1424 Float_t localY = 0;
1425 Float_t localZ = (ind[3]-AliTOFGeometry::NpadZ()/2)*AliTOFGeometry::ZPad()+AliTOFGeometry::ZPad()/2.;
ac359ffe 1426 //move to the tracking ref system
1427
1428 Double_t lpos[3];
b3e52baa 1429 lpos[0] = localX;
1430 lpos[1] = localY;
1431 lpos[2] = localZ;
ac359ffe 1432
1433 const TGeoHMatrix *l2t= AliGeomManager::GetTracking2LocalMatrix(volIndex);
1434 // Get The position in the track ref system
1435 Double_t tpos[3];
1436 l2t->MasterToLocal(lpos,tpos);
b3e52baa 1437 pos[0] = tpos[0];
1438 pos[1] = tpos[1];
1439 pos[2] = tpos[2];
ac359ffe 1440
1441 //Get The cluster covariance in the track ref system
1442 Double_t lcov[9];
1443
1444 //cluster covariance in the local system:
1445 // sx2 0 0
1446 // 0 0 0
1447 // 0 0 sz2
1448
b3e52baa 1449 lcov[0] = AliTOFGeometry::XPad()*AliTOFGeometry::XPad()/12.;
1450 lcov[1] = 0;
1451 lcov[2] = 0;
1452 lcov[3] = 0;
1453 lcov[4] = 0;
1454 lcov[5] = 0;
1455 lcov[6] = 0;
1456 lcov[7] = 0;
1457 lcov[8] = AliTOFGeometry::ZPad()*AliTOFGeometry::ZPad()/12.;
ac359ffe 1458
1459 //cluster covariance in the tracking system:
1460 TGeoHMatrix m;
1461 m.SetRotation(lcov);
1462 m.Multiply(l2t);
1463 m.MultiplyLeft(&l2t->Inverse());
1464 Double_t *tcov = m.GetRotationMatrix();
1465 cov[0] = tcov[0]; cov[1] = tcov[1]; cov[2] = tcov[2];
1466 cov[3] = tcov[4]; cov[4] = tcov[5];
1467 cov[5] = tcov[8];
1468
1469 return;
1470
1471}
6786addd 1472//-------------------------------------------------------------------------
1473void AliTOFClusterFinder::FillTOFtriggerMap(Int_t iDDL, AliTOFrawData *tofRawDatum)
1474{
1475
1476 /* get cluster info */
1477 //Int_t trm = tofRawDatum->GetTRM();
1478 // Int_t tdc = tofRawDatum->GetTDC();
1479// Int_t tdc_ch = tofRawDatum->GetTDCchannel();
1480 Int_t chain = tofRawDatum->GetTRMchain();
1481 Int_t l0l1 = tofRawDatum->GetL0L1Latency();
1482 Double_t corr = l0l1 * AliTOFGeometry::BunchCrossingBinWidth();
1483 AliTOFCTPLatency *ctpLatencyObj = fTOFcalib->GetCTPLatency();
1484 Float_t ctpLatency = ctpLatencyObj->GetCTPLatency();
1485 corr += ctpLatency;
1486
1487 Double_t timeTOF=tofRawDatum->GetTOF()*AliTOFGeometry::TdcBinWidth();
1488 timeTOF-=corr;
1489 //Int_t timeRaw_bc = Int_t(timeTOF/1000/24.4); // per ora non usata
1490
1491 //Int_t timeRaw_bc = Int_t((tofRawDatum->GetTOF()*AliTOFGeometry::TdcBinWidth())/1000/24.4); // per ora non usata
1492
1493 /*
1494 const Int_t crate_CTTM[72] = { 0, 1, 37, 36, 2, 3, 39, 38, 4, 5,
1495 41, 40, 6, 7, 43, 42, 8, 9, 45, 44,
1496 10, 11, 47, 46, 12, 13, 49, 48, 14, 15,
1497 51, 50, 16, 17, 53, 52, 18, 19, 55, 54,
1498 20, 21, 57, 56, 22, 23, 59, 58, 24, 25,
1499 61, 60, 26, 27, 63, 62, 28, 29, 65, 64,
1500 30, 31, 67, 66, 32, 33, 69, 68, 34, 35,
1501 71, 70};
1502 */
1503
1504 Int_t cttmCrate=-1;
1505// Int_t cttmBit = tdc_ch + (tdc-12)*AliTOFGeometry::NCh();
1506 switch(iDDL%AliTOFGeometry::NDDL()){
1507 case 1:
1508 cttmCrate=1;
1509 break;
1510 case 3:
1511 cttmCrate=36;
1512 break;
1513 default:
1514 break;
1515 }
1516 cttmCrate+=2*(Int_t)(iDDL/AliTOFGeometry::NDDL());
1517 if(chain==0) {
1518 if (iDDL<36) cttmCrate--;
1519 else cttmCrate++;
1520 }
1521
1522
1523
1524
1525}
1526