]> git.uio.no Git - u/mrichter/AliRoot.git/blame - TOF/AliTOFClusterFinderV1.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Minor changes
[u/mrichter/AliRoot.git] / TOF / AliTOFClusterFinderV1.cxx
CommitLineData
e3bd5504 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: AliTOFClusterFinderV1.cxx,v $
e885fb81 18Revision 2009/04/20 A. De Caro
19 - added two new global variables, called fTOFGeometry and fTOFdigits;
20 - added a new method, called FindClustersWithoutTOT,
21 to transform TOF digits with fTOT=0 in one pad clusters;
22 - update of the covariance matrix elements for the TOF clusters
23
e3bd5504 24Revision 0.01 2008/05/10 A. De Caro
25 */
26
27/////////////////////////////////////////
28// //
29// Class for TOF cluster finder (V1) //
30// //
31// Input data: Raw Data or Digits; //
32// Output data: Digits or Rec Points //
33// //
34/////////////////////////////////////////
35
36#include "Riostream.h"
37
38#include "TClonesArray.h"
39#include "TStopwatch.h"
40#include "TTree.h"
41#include "TGeoMatrix.h"
42#include "TString.h"
43
44#include "AliDAQ.h"
45#include "AliLog.h"
46#include "AliRawReader.h"
47#include "AliRunLoader.h"
48#include "AliGeomManager.h"
49
50#include "AliTOFcalib.h"
51#include "AliTOFChannelOnlineArray.h"
52#include "AliTOFChannelOnlineStatusArray.h"
53#include "AliTOFChannelOffline.h"
54#include "AliTOFClusterFinderV1.h"
55#include "AliTOFcluster.h"
56#include "AliTOFdigit.h"
e3bd5504 57#include "AliTOFDigitMap.h"
e3bd5504 58#include "AliTOFrawData.h"
e3bd5504 59
60ClassImp(AliTOFClusterFinderV1)
61
e885fb81 62//_____________________________________________________________________________
e3bd5504 63AliTOFClusterFinderV1::AliTOFClusterFinderV1(AliTOFcalib *calib):
64 fRunLoader(0),
65 fDigits(new TClonesArray("AliTOFdigit", 4000)),
66 fRecPoints(new TClonesArray("AliTOFcluster", 4000)),
67 fNumberOfTofClusters(0),
68 fNumberOfTofDigits(0),
e885fb81 69 fMaxDeltaTime(2),
e3bd5504 70 fVerbose(0),
71 fDecoderVersion(0),
72 fTOFcalib(calib),
0275b7df 73 fTOFdigitMap(new AliTOFDigitMap()),
e885fb81 74 fTOFGeometry(new AliTOFGeometry()),
75 fTOFdigits(0),
0275b7df 76 fTOFRawStream(AliTOFRawStream())
e3bd5504 77{
78//
79// Constructor
80//
81
82}
e3bd5504 83
e885fb81 84//_____________________________________________________________________________
e3bd5504 85AliTOFClusterFinderV1::AliTOFClusterFinderV1(AliRunLoader* runLoader, AliTOFcalib *calib):
86 fRunLoader(runLoader),
87 fDigits(new TClonesArray("AliTOFdigit", 4000)),
88 fRecPoints(new TClonesArray("AliTOFcluster", 4000)),
89 fNumberOfTofClusters(0),
90 fNumberOfTofDigits(0),
e885fb81 91 fMaxDeltaTime(2),
e3bd5504 92 fVerbose(0),
93 fDecoderVersion(0),
94 fTOFcalib(calib),
0275b7df 95 fTOFdigitMap(new AliTOFDigitMap()),
e885fb81 96 fTOFGeometry(new AliTOFGeometry()),
97 fTOFdigits(0),
0275b7df 98 fTOFRawStream(AliTOFRawStream())
e3bd5504 99{
100//
101// Constructor
102//
103
104}
105//_____________________________________________________________________________
106
107AliTOFClusterFinderV1::AliTOFClusterFinderV1(const AliTOFClusterFinderV1 &source)
8a190ba2 108 :TObject(source),
109 fRunLoader(0),
110 fDigits(source.fDigits),
111 fRecPoints(source.fRecPoints),
c0f9ecc7 112 fNumberOfTofClusters(0),
113 fNumberOfTofDigits(0),
e885fb81 114 fMaxDeltaTime(2),
c0f9ecc7 115 fVerbose(0),
116 fDecoderVersion(source.fDecoderVersion),
117 fTOFcalib(source.fTOFcalib),
0275b7df 118 fTOFdigitMap(new AliTOFDigitMap()),
e885fb81 119 fTOFGeometry(new AliTOFGeometry()),
120 fTOFdigits(source.fTOFdigits),
0275b7df 121 fTOFRawStream(source.fTOFRawStream)
e885fb81 122
e3bd5504 123{
124 // copy constructor
e3bd5504 125}
126//_____________________________________________________________________________
127
128AliTOFClusterFinderV1& AliTOFClusterFinderV1::operator=(const AliTOFClusterFinderV1 &source)
129{
130 // ass. op.
8a190ba2 131
132 if (this == &source)
133 return *this;
134
135 TObject::operator=(source);
136 fDigits=source.fDigits;
137 fRecPoints=source.fRecPoints;
138 fVerbose=source.fVerbose;
139 fDecoderVersion=source.fDecoderVersion;
140 fTOFcalib=source.fTOFcalib;
141 fTOFdigitMap=source.fTOFdigitMap;
e885fb81 142 fTOFGeometry=source.fTOFGeometry;
143 fTOFdigits=source.fTOFdigits;
0275b7df 144 fTOFRawStream=source.fTOFRawStream;
e3bd5504 145 return *this;
146
147}
148//_____________________________________________________________________________
149
150AliTOFClusterFinderV1::~AliTOFClusterFinderV1()
151{
152
153 //
154 // Destructor
155 //
156
157 if (fDigits)
158 {
159 fDigits->Delete();
160 delete fDigits;
161 fDigits=0;
162 }
163 if (fRecPoints)
164 {
165 fRecPoints->Delete();
166 delete fRecPoints;
167 fRecPoints=0;
168 }
169
170 delete fTOFdigitMap;
171
e885fb81 172 delete fTOFGeometry;
173
174 delete fTOFdigits;
175
e3bd5504 176}
177//_____________________________________________________________________________
178
179void AliTOFClusterFinderV1::Digits2RecPoints(TTree* digitsTree, TTree* clusterTree)
180{
181 //
182 // Converts digits to recPoints for TOF
183 //
184
185 TStopwatch stopwatch;
186 stopwatch.Start();
187
188 Int_t inholes = 0;
189
190 TClonesArray &aDigits = *fDigits;
191
192 if (digitsTree == 0x0)
193 AliFatal("Can not get TreeD for TOF");
194
195 TBranch *branch = digitsTree->GetBranch("TOF");
196 if (!branch) {
197 AliError("Can not get branch with the TOF digits !");
198 return;
199 }
200
201 TClonesArray staticDigits("AliTOFdigit",10000);
202 staticDigits.Clear();
203 TClonesArray *digits = &staticDigits;
204 branch->SetAddress(&digits);
205 digitsTree->GetEvent(0);
206 AliInfo(Form("Number of TOF digits: %d", digits->GetEntriesFast()));
207
208 AliTOFdigit *tofDigit;
209
210 Int_t jj = 0;
211 Int_t detectorIndex[5];
212 for (jj=0; jj<5; jj++) detectorIndex[jj] = -1;
213 Int_t info[4];
214 for (jj=0; jj<4; jj++) info[jj] = -1;
215 Int_t *tracks;
216 Int_t tdcCorr;
217 Int_t dummy = -1;
218 Int_t last = -1;
219
220 Bool_t status = kTRUE;
221
222 AliInfo(" Calibrating TOF Digits: ");
223 TString validity = (TString)fTOFcalib->GetOfflineValidity();
224 AliInfo(Form(" validity = %s", validity.Data()));
225 if (validity.CompareTo("valid")==0) {
226 AliInfo(" ...using offline calibration parameters");
227 }
228 else {
229 AliInfo(" ...using online calibration parameters");
230 }
231
232 Int_t ii = 0;
233 for (ii=0; ii<digits->GetEntriesFast(); ii++) {
234 tofDigit = (AliTOFdigit*)digits->UncheckedAt(ii);
235 detectorIndex[0] = tofDigit->GetSector();
236 detectorIndex[1] = tofDigit->GetPlate();
237 detectorIndex[2] = tofDigit->GetStrip();
238 detectorIndex[3] = tofDigit->GetPadz();
239 detectorIndex[4] = tofDigit->GetPadx();
240
241 if (detectorIndex[0]==13 || detectorIndex[0]==14 || detectorIndex[0]==15 ) { // sectors with holes
242 if (detectorIndex[1]==2) { // plate with holes
243 inholes++;
244 continue;
245 }
246 }
247
248 status = MakeSlewingCorrection(detectorIndex, tofDigit->GetToT(), tofDigit->GetTdc(), tdcCorr);
249
250 for (jj=0; jj<4; jj++) info[jj] = -1;
251 info[0] = tdcCorr;//tofDigit->GetTdc();
252 info[1] = tofDigit->GetAdc();
253 info[2] = tofDigit->GetToT();
90b234fe 254 info[3] = tofDigit->GetTdcND();//tofDigit->GetTdc();//
e3bd5504 255 tracks = tofDigit->GetTracks();
256
257 dummy = detectorIndex[3];
258 detectorIndex[3] = detectorIndex[4];//padx
259 detectorIndex[4] = dummy;//padz
260 last = fDigits->GetEntriesFast();
261 new (aDigits[last]) AliTOFdigit(tracks, detectorIndex, info);
262 if (status) fTOFdigitMap->AddDigit(detectorIndex, last);
263
e885fb81 264 AliDebug(2, Form(" Digits reading %2d -> %2d %1d %2d %1d %2d (%d, %d, %d)",
e3bd5504 265 last,
266 detectorIndex[0], detectorIndex[1], detectorIndex[2], detectorIndex[3], detectorIndex[4],
267 info[0], info[1], info[3]));
268
269 }
270
271 fNumberOfTofDigits = fDigits->GetEntriesFast();
272
273 ResetRecpoint();
274
275 Int_t bufsize = 32000;
276 clusterTree->Branch("TOF", &fRecPoints, bufsize);
277
278 FillRecPoint();
279 clusterTree->Fill();
280
281 AliInfo(Form("Number of found TOF clusters: %d", fNumberOfTofClusters));
282
283 ResetRecpoint();
284
285 fTOFdigitMap->Clear();
286
287 ResetDigits();
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 if (inholes) AliWarning(Form("Clusters in the TOF holes: %d",inholes));
293
294}
295//_____________________________________________________________________________
296
297void AliTOFClusterFinderV1::Digits2RecPoints(AliRawReader *rawReader, TTree *clustersTree)
298{
299 //
300 // Converts raw data to recPoints for TOF
301 //
302
303 TStopwatch stopwatch;
304 stopwatch.Start();
305
306
307 AliDebug(2, "TreeD re-creation");
e885fb81 308 //TTree *digitsTree = new TTree();
309 //Raw2Digits(rawReader, digitsTree);
e3bd5504 310
e885fb81 311 Raw2Digits(rawReader, fTOFdigits);
e3bd5504 312
313 AliDebug(2,Form("Number of TOF digits: %d", fNumberOfTofDigits));
314 ResetRecpoint();
315
316 Int_t bufsize = 32000;
317 clustersTree->Branch("TOF", &fRecPoints, bufsize);
318 FillRecPoint();
319
320 clustersTree->Fill();
321
e885fb81 322 AliInfo(Form("Number of found clusters: %d", fNumberOfTofClusters));
e3bd5504 323
324 ResetRecpoint();
325
326 fTOFdigitMap->Clear();
327
328 ResetDigits();
329
330 AliInfo(Form("Execution time to read TOF raw data and to write TOF clusters : R:%.4fs C:%.4fs",
331 stopwatch.RealTime(),stopwatch.CpuTime()));
332
333}
334
335//_____________________________________________________________________________
336
337void AliTOFClusterFinderV1::Raw2Digits(AliRawReader *rawReader, TTree* digitsTree)
338{
339 //
340 // Converts raw data to digits for TOF
341 //
342
343 TStopwatch stopwatch;
344 stopwatch.Start();
345
346 Int_t inholes = 0;
347
348 const Int_t kMaxNumberOfTracksPerDigit = 3;
349 const Int_t kDDL = AliDAQ::NumberOfDdls("TOF");
350
351 digitsTree->Branch("TOF", &fDigits);
352 TClonesArray &aDigits = *fDigits;
353
0275b7df 354 fTOFRawStream.Clear();
355 fTOFRawStream.SetRawReader(rawReader);
e3bd5504 356
357 ofstream ftxt;
358 if (fVerbose==2) ftxt.open("TOFdigitsRead.txt",ios::app);
359
360 TClonesArray staticRawData("AliTOFrawData",10000);
361 staticRawData.Clear();
362 TClonesArray * clonesRawData = &staticRawData;
363
364 Int_t dummy = -1;
365 Int_t detectorIndex[5] = {-1, -1, -1, -1, -1};
366 Int_t digit[4];
367 Int_t tracks[kMaxNumberOfTracksPerDigit];
368 for (Int_t ii=0; ii<kMaxNumberOfTracksPerDigit; ii++)
369 tracks[ii] = -1;
370 Int_t last = -1;
371 Int_t tdcCorr = 0;
372
373 Bool_t status = kTRUE;
374
375 AliInfo(" Calibrating TOF Digits: ");
376 TString validity = (TString)fTOFcalib->GetOfflineValidity();
377 AliInfo(Form(" validity = %s", validity.Data()));
378 if (validity.CompareTo("valid")==0) {
379 AliInfo(" ...using offline calibration parameters");
380 }
381 else {
382 AliInfo(" ...using online calibration parameters");
383 }
384
385 Int_t indexDDL = 0;
386 Int_t iRawData = 0;
387 for (indexDDL=0; indexDDL<kDDL; indexDDL++) {
388
389 rawReader->Reset();
390 if (fDecoderVersion) {
391 AliInfo("Using New Decoder \n");
0275b7df 392 fTOFRawStream.LoadRawDataBuffers(indexDDL,fVerbose);
e3bd5504 393 }
0275b7df 394 else fTOFRawStream.LoadRawData(indexDDL);
e3bd5504 395
0275b7df 396 clonesRawData = (TClonesArray*)fTOFRawStream.GetRawData();
e885fb81 397 if (clonesRawData->GetEntriesFast()!=0) AliInfo(Form(" TOF raw data number = %3d", clonesRawData->GetEntriesFast()));
e3bd5504 398 for (iRawData = 0; iRawData<clonesRawData->GetEntriesFast(); iRawData++) {
399
400 AliTOFrawData *tofRawDatum = (AliTOFrawData*)clonesRawData->UncheckedAt(iRawData);
401
402 //if (tofRawDatum->GetTOT()==-1 || tofRawDatum->GetTOF()==-1) continue;
403 if (tofRawDatum->GetTOF()==-1) continue;
404
0275b7df 405 fTOFRawStream.EquipmentId2VolumeId(indexDDL, tofRawDatum->GetTRM(), tofRawDatum->GetTRMchain(),
406 tofRawDatum->GetTDC(), tofRawDatum->GetTDCchannel(), detectorIndex);
e3bd5504 407
408 tdcCorr = 0;
409 dummy = detectorIndex[3];
410 detectorIndex[3] = detectorIndex[4];//padz
411 detectorIndex[4] = dummy;//padx
412 status = MakeSlewingCorrection(detectorIndex, tofRawDatum->GetTOT(), tofRawDatum->GetTOF(), tdcCorr);
413
414 digit[0] = tdcCorr;
415 digit[1] = tofRawDatum->GetTOT();
416 digit[2] = tofRawDatum->GetTOT();
e885fb81 417 digit[3] = -1;//tofRawDatum->GetTOF(); //tofND
e3bd5504 418
419 dummy = detectorIndex[3];
420 detectorIndex[3] = detectorIndex[4];//padx
421 detectorIndex[4] = dummy;//padz
422
423 // Do not reconstruct anything in the holes
424 if (detectorIndex[0]==13 || detectorIndex[0]==14 || detectorIndex[0]==15 ) { // sectors with holes
425 if (detectorIndex[1]==2) { // plate with holes
426 inholes++;
427 continue;
428 }
429 }
430
431 last = fDigits->GetEntriesFast();
432 new (aDigits[last]) AliTOFdigit(tracks, detectorIndex, digit);
433 if (status) fTOFdigitMap->AddDigit(detectorIndex, last);
434
435 if (fVerbose==2) {
436 if (indexDDL<10) ftxt << " " << indexDDL;
437 else ftxt << " " << indexDDL;
438 if (tofRawDatum->GetTRM()<10) ftxt << " " << tofRawDatum->GetTRM();
439 else ftxt << " " << tofRawDatum->GetTRM();
440 ftxt << " " << tofRawDatum->GetTRMchain();
441 if (tofRawDatum->GetTDC()<10) ftxt << " " << tofRawDatum->GetTDC();
442 else ftxt << " " << tofRawDatum->GetTDC();
443 ftxt << " " << tofRawDatum->GetTDCchannel();
444
445 if (detectorIndex[0]<10) ftxt << " -> " << detectorIndex[0];
446 else ftxt << " -> " << detectorIndex[0];
447 ftxt << " " << detectorIndex[1];
448 if (detectorIndex[2]<10) ftxt << " " << detectorIndex[2];
449 else ftxt << " " << detectorIndex[2];
450 ftxt << " " << detectorIndex[4];
451 if (detectorIndex[4]<10) ftxt << " " << detectorIndex[3];
452 else ftxt << " " << detectorIndex[3];
453
454 if (digit[1]<10)ftxt << " " << digit[1];
455 else if (digit[1]>=10 && digit[1]<100) ftxt << " " << digit[1];
456 else ftxt << " " << digit[1];
457 if (digit[0]<10) ftxt << " " << digit[0] << endl;
458 else if (digit[0]>=10 && digit[0]<100) ftxt << " " << digit[0] << endl;
459 else if (digit[0]>=100 && digit[0]<1000) ftxt << " " << digit[0] << endl;
460 else ftxt << " " << digit[3] << endl;
461 }
462
e885fb81 463 AliDebug(2, Form(" Raw data reading %2d -> %2d %1d %2d %1d %2d (%d, %d, %d)",
e3bd5504 464 last,
465 detectorIndex[0], detectorIndex[1], detectorIndex[2], detectorIndex[4], detectorIndex[3],
466 digit[0], digit[1], digit[3]));
467
468 } // while loop
469
470 clonesRawData->Clear();
471
472 } // DDL Loop
473
474 if (fVerbose==2) ftxt.close();
475
476 digitsTree->Fill();
477
478 fNumberOfTofDigits = fDigits->GetEntries();
479
480 AliDebug(1, Form("Got %d TOF digits", fNumberOfTofDigits));
481 AliDebug(1, Form("Execution time to read TOF raw data and fill TOF digit tree : R:%.2fs C:%.2fs",
482 stopwatch.RealTime(),stopwatch.CpuTime()));
483
484 if (inholes) AliWarning(Form("Clusters in the TOF holes: %d",inholes));
485
486}
487//_____________________________________________________________________________
488
489void AliTOFClusterFinderV1::FillRecPoint()
490{
491 //
492 // Fill the global TClonesArray of AliTOFcluster objects,
493 // i.e. fRecPoints
494 //
495
e885fb81 496 Int_t dummy4_1 = -1;
497 Int_t dummy3_1 = -1;
498 Int_t dummy2_1 = -1;
e3bd5504 499 Int_t dummy = -1;
500
e885fb81 501 for(Int_t iPlate=AliTOFGeometry::NPlates()-1; iPlate>=0; iPlate--) {
502 for(Int_t iStrip=AliTOFGeometry::NStrip(iPlate)-1; iStrip>=0; iStrip--) {
503 //for (Int_t iSector=AliTOFGeometry::NSectors()-1; iSector>=0; iSector--) {
e3bd5504 504 for (Int_t iSector=0; iSector<AliTOFGeometry::NSectors(); iSector++) {
e885fb81 505
506 if (!(fTOFdigitMap->StripDigitCheck(iSector,iPlate,iStrip))) continue;
507 FindClustersWithoutTOT(iSector, iPlate, iStrip); // clusters coming from digits without TOT measurement
508
509
e3bd5504 510 if (!(fTOFdigitMap->StripDigitCheck(iSector,iPlate,iStrip))) continue;
511 FindClustersPerStrip(iSector, iPlate, iStrip, 4); // 4 pads clusters
e3bd5504 512 if (!(fTOFdigitMap->StripDigitCheck(iSector,iPlate,iStrip))) continue;
e885fb81 513
514 dummy4_1 = fNumberOfTofClusters;
e3bd5504 515 FindClustersPerStrip(iSector, iPlate, iStrip, 4); // 4 pads clusters
516 if (fNumberOfTofClusters!=dummy4_1)
e885fb81 517 AliDebug(2, Form(" (4): n1= %5d, n2 = %5", dummy4_1, fNumberOfTofClusters));
518
519
e3bd5504 520 if (!(fTOFdigitMap->StripDigitCheck(iSector,iPlate,iStrip))) continue;
521 FindClustersPerStrip(iSector, iPlate, iStrip, 3); // 3 pads clusters
e3bd5504 522 if (!(fTOFdigitMap->StripDigitCheck(iSector,iPlate,iStrip))) continue;
e885fb81 523
524 dummy3_1 = fNumberOfTofClusters;
e3bd5504 525 FindClustersPerStrip(iSector, iPlate, iStrip, 3); // 3 pads clusters
526 if (fNumberOfTofClusters!=dummy3_1)
e885fb81 527 AliDebug(2, Form(" (3): n1= %5d, n2 = %5", dummy3_1, fNumberOfTofClusters));
528
529
e3bd5504 530 if (!(fTOFdigitMap->StripDigitCheck(iSector,iPlate,iStrip))) continue;
531 FindClustersPerStrip(iSector, iPlate, iStrip, 2); // 2 pads clusters
e3bd5504 532 if (!(fTOFdigitMap->StripDigitCheck(iSector,iPlate,iStrip))) continue;
e885fb81 533
534 dummy2_1 = fNumberOfTofClusters;
e3bd5504 535 FindClustersPerStrip(iSector, iPlate, iStrip, 2); // 2 pads clusters
536 if (fNumberOfTofClusters!=dummy2_1)
e885fb81 537 AliDebug(2, Form(" (2): n1= %5d, n2 =%5", dummy2_1, fNumberOfTofClusters));
538
539
e3bd5504 540 if (!(fTOFdigitMap->StripDigitCheck(iSector,iPlate,iStrip))) continue;
541 dummy = fNumberOfTofClusters;
542 FindClusters34(iSector, iPlate, iStrip); // 3 pads clusters between 4 hit pads
543 if (fNumberOfTofClusters!=dummy)
e885fb81 544 AliDebug(2, Form(" (3 between 4): n1 = %5d, n2 = %5d", fNumberOfTofClusters, dummy));
545
546
e3bd5504 547 if (!(fTOFdigitMap->StripDigitCheck(iSector,iPlate,iStrip))) continue;
548 dummy = fNumberOfTofClusters;
549 FindClusters23(iSector, iPlate, iStrip); // 2 pads clusters between 3 hit pads
550 if (fNumberOfTofClusters!=dummy)
e885fb81 551 AliDebug(2, Form(" (2 between 3): n1 = %5d, n2 = %5d", fNumberOfTofClusters, dummy));
e3bd5504 552
553 if (!(fTOFdigitMap->StripDigitCheck(iSector,iPlate,iStrip))) continue;
554 dummy = fNumberOfTofClusters;
555 FindClusters24(iSector, iPlate, iStrip); // 2 pads clusters between 4 hit pads
556 if (fNumberOfTofClusters!=dummy)
e885fb81 557 AliDebug(2, Form(" (2 between 4): n1 = %5d, n2 = %5d", fNumberOfTofClusters, dummy));
e3bd5504 558
559
560 if (!(fTOFdigitMap->StripDigitCheck(iSector,iPlate,iStrip))) continue;
561 dummy = fNumberOfTofClusters;
562 FindOnePadClusterPerStrip(iSector, iPlate, iStrip); // 1 pad clusters
563 if (fNumberOfTofClusters!=dummy)
e885fb81 564 AliDebug(2,Form(" (1): n1 = %5d, n2 = %5d", fNumberOfTofClusters, dummy));
e3bd5504 565
566 if (fTOFdigitMap->DigitInStrip(iSector,iPlate,iStrip)>0)
e885fb81 567 AliDebug(2, Form(" (1): number of clusters = %5d (remaining digit %2d), -%2d %1d %2d-",
568 fNumberOfTofClusters, fTOFdigitMap->DigitInStrip(iSector,iPlate,iStrip),
569 iSector, iPlate, iStrip));
e3bd5504 570
571 }
572 }
573 }
574
575
576 TClonesArray &lRecPoints = *fRecPoints;
577
578 Int_t ii, jj;
579
580 Int_t detectorIndex[5];
e885fb81 581 for (jj=0; jj<5; jj++) detectorIndex[jj] = -1;
e3bd5504 582 Int_t parTOF[5];
e885fb81 583 for (jj=0; jj<5; jj++) parTOF[jj] = -1;
e3bd5504 584 Int_t trackLabels[3];
e885fb81 585 for (jj=0; jj<3; jj++) trackLabels[jj] = -1;
e3bd5504 586 Int_t digitIndex = -1;
587 Bool_t status = kTRUE;
588 Float_t posClus[3];
589 for (ii=0; ii<3; ii++) posClus[ii] = 0.;
590 //Float_t covClus[6];
591 //for (ii=0; ii<6; ii++) covClus[ii] = 0.;
592 UShort_t volIdClus;
593
594 for (ii=0; ii<fNumberOfTofClusters; ii++) {
595
596 digitIndex = fTofClusters[ii]->GetIndex();
597 for(jj=0; jj<5; jj++) detectorIndex[jj] = fTofClusters[ii]->GetDetInd(jj);
e885fb81 598 volIdClus = fTOFGeometry->GetAliSensVolIndex(detectorIndex[0],detectorIndex[1],detectorIndex[2]);
599 //volIdClus = GetClusterVolIndex(detectorIndex);
e3bd5504 600 for(jj=0; jj<3; jj++) trackLabels[jj] = fTofClusters[ii]->GetLabel(jj);
601 parTOF[0] = fTofClusters[ii]->GetTDC(); // TDC
602 parTOF[1] = fTofClusters[ii]->GetToT(); // TOT
603 parTOF[2] = fTofClusters[ii]->GetADC(); // ADC=TOT
604 parTOF[3] = fTofClusters[ii]->GetTDCND(); // TDCND
605 parTOF[4] = fTofClusters[ii]->GetTDCRAW();//RAW
606 status = fTofClusters[ii]->GetStatus();
607
608 posClus[0] = fTofClusters[ii]->GetX();
609 posClus[1] = fTofClusters[ii]->GetY();
610 posClus[2] = fTofClusters[ii]->GetZ();
611
612 //for (jj=0; jj<6; jj++) covClus[jj] = 0.;
613 //((AliCluster*)fTofClusters[ii])->GetGlobalCov(covClus);
614
615 new(lRecPoints[ii]) AliTOFcluster(volIdClus, (Double_t)posClus[0], (Double_t)posClus[1], (Double_t)posClus[2],
616 (Double_t)(fTofClusters[ii]->GetSigmaX2()),
617 (Double_t)(fTofClusters[ii]->GetSigmaXY()),
618 (Double_t)(fTofClusters[ii]->GetSigmaXZ()),
619 (Double_t)(fTofClusters[ii]->GetSigmaY2()),
620 (Double_t)(fTofClusters[ii]->GetSigmaYZ()),
621 (Double_t)(fTofClusters[ii]->GetSigmaZ2()),
622 //(Double_t)covClus[0], (Double_t)covClus[1], (Double_t)covClus[2],
623 //(Double_t)covClus[3], (Double_t)covClus[4], (Double_t)covClus[5],
624 trackLabels, detectorIndex, parTOF, status, digitIndex);
625
e885fb81 626 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",
e3bd5504 627 ii, volIdClus, posClus[0], posClus[1], posClus[2],
628 fTofClusters[ii]->GetSigmaX2(),
629 fTofClusters[ii]->GetSigmaXY(),
630 fTofClusters[ii]->GetSigmaXZ(),
631 fTofClusters[ii]->GetSigmaY2(),
632 fTofClusters[ii]->GetSigmaYZ(),
633 fTofClusters[ii]->GetSigmaZ2(),
634 trackLabels[0], trackLabels[1], trackLabels[2],
635 detectorIndex[0], detectorIndex[1], detectorIndex[2], detectorIndex[3], detectorIndex[4],
636 parTOF[0], parTOF[1], parTOF[2], parTOF[3], parTOF[4],
637 status, digitIndex));
638
639
640 }
641
642 for (Int_t iSector=0; iSector<AliTOFGeometry::NSectors(); iSector++)
643 for(Int_t iPlate=0; iPlate<AliTOFGeometry::NPlates(); iPlate++) {
644 for(Int_t iStrip=0; iStrip<AliTOFGeometry::NStrip(iPlate); iStrip++) {
645 if (!(fTOFdigitMap->StripDigitCheck(iSector,iPlate,iStrip))) continue;
e885fb81 646 AliDebug(2, Form(" END %2d %1d %2d %5d",
e3bd5504 647 iSector, iPlate, iStrip, fTOFdigitMap->DigitInStrip(iSector,iPlate,iStrip)));
648 }
649 }
650
651}
652//_____________________________________________________________________________
653
654void AliTOFClusterFinderV1::FindOnePadClusterPerStrip(Int_t nSector,
655 Int_t nPlate,
656 Int_t nStrip)
657{
658 //
659 // This function searches the isolated digits (stored in the fDigits object),
660 // to perform clusters (stored in the fTofClusters array).
661 // This research has been made by checking the fTOFdigitMap object,
662 // filled at digits/raw-data reading time.
663 //
664
665 const Int_t kMaxNumberOfTracksPerDigit = 3;
666 const Int_t kMaxNumberOfDigitsPerVolume = 3;
667
668 Int_t jj = 0;
669
e3bd5504 670 Int_t det[5] = {nSector,nPlate,nStrip,-1,-1};//sector,plate,strip,padZ,padX
671 Int_t vol[5] = {nSector,nPlate,nStrip,-1,-1};//sector,plate,strip,padX,padZ
672 UShort_t volIdClus = 0;
673
674 Float_t pos[3];
675 for (jj=0; jj<3; jj++) pos[jj] = 0.;
676 Double_t posClus[3];
677 for (jj=0; jj<3; jj++) posClus[jj] = 0.;
678
679 Double_t covClus[6];
680 for (jj=0; jj<6; jj++) covClus[jj] = 0.;
681
682 Int_t parTOF[5];
683 for (jj=0; jj<5; jj++) parTOF[jj] = 0;
684
685 Bool_t status = kTRUE; //assume all sim channels ok in the beginning...
686
687 Int_t tracks[kMaxNumberOfTracksPerDigit];
688 for (jj=0; jj<3; jj++) tracks[jj] = -1;
689
690 Int_t dummyCounter=-1;
e3bd5504 691
692 AliTOFdigit *digitInteresting;
693
694 Int_t iPadX = -1;
695 Int_t iPadZ = -1;
696 for (iPadX=0; iPadX<AliTOFGeometry::NpadX(); iPadX++) {
697 for (iPadZ=0; iPadZ<AliTOFGeometry::NpadZ(); iPadZ++) {
698 vol[4] = iPadZ , vol[3] = iPadX;
699
e885fb81 700 AliDebug(3, Form(" %1d %2d\n", iPadZ, iPadX));
e3bd5504 701
702 if (fTOFdigitMap->GetNumberOfDigits(vol)==0) continue;
703
704 for(Int_t digIndex=0; digIndex<kMaxNumberOfDigitsPerVolume; digIndex++) {
705 if (fTOFdigitMap->GetDigitIndex(vol,digIndex)<0) continue;
706 digitInteresting = (AliTOFdigit*)fDigits->UncheckedAt(fTOFdigitMap->GetDigitIndex(vol,digIndex));
707
e885fb81 708 AliDebug(2, Form(" %3d %5d %2d %1d %2d %1d %2d %d %d %d %5d %5d %5d %5d",
709 fTOFdigitMap->GetNumberOfDigits(vol), digIndex,
e3bd5504 710 vol[0], vol[1], vol[2] ,vol[4], vol[3],
711 digitInteresting->GetTdc(), digitInteresting->GetAdc(),
712 digitInteresting->GetToT(),
713 fTOFdigitMap->GetDigitIndex(vol,digIndex),
714 digitInteresting->GetTrack(0), digitInteresting->GetTrack(1), digitInteresting->GetTrack(2)));
715
e885fb81 716 det[3] = vol[4]; // padz
717 det[4] = vol[3]; // padx
718 fTOFGeometry->GetPosPar(det,pos);
e3bd5504 719 AliDebug(1,Form(" %f %f %f", pos[0], pos[1], pos[2]));
720
721 //insert cluster
722 for (jj=0; jj<3; jj++) posClus[jj] = pos[jj];
723
724 parTOF[0] = Int_t(digitInteresting->GetTdc());
e885fb81 725 parTOF[1] = Int_t(digitInteresting->GetToT());
726 parTOF[2] = Int_t(digitInteresting->GetAdc());
727 parTOF[3] = Int_t(digitInteresting->GetTdcND());
e3bd5504 728 parTOF[4] = Int_t(digitInteresting->GetTdc());
729
e885fb81 730 volIdClus = fTOFGeometry->GetAliSensVolIndex(det[0],det[1],det[2]);
731 //volIdClus = GetClusterVolIndex(det);
e3bd5504 732
733 for (jj=0; jj<6; jj++) covClus[jj] = 0.;
734 GetClusterPars(det, posClus, covClus);
735
736 // To fill the track index array
737 dummyCounter=-1;
738 for (jj=0; jj<kMaxNumberOfTracksPerDigit; jj++) tracks[jj] = -1;
739 for (jj=0; jj<kMaxNumberOfTracksPerDigit; jj++) { // three is the max number of tracks associated to one digit
740 if (digitInteresting->GetTrack(jj)==-1) continue;
741 else {
742 dummyCounter++;
743 tracks[dummyCounter] = digitInteresting->GetTrack(jj);
744 }
745 }
746
747 AliTOFcluster *tofCluster =
748 new AliTOFcluster(volIdClus, posClus[0], posClus[1], posClus[2],
749 covClus[0], covClus[1], covClus[2], covClus[3], covClus[4], covClus[5],
750 tracks, det, parTOF, status, fTOFdigitMap->GetDigitIndex(vol,digIndex));
751 InsertCluster(tofCluster);
752
e885fb81 753 AliDebug(2, Form(" %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",
e3bd5504 754 volIdClus, posClus[0], posClus[1], posClus[2],
755 covClus[0], covClus[1], covClus[2], covClus[3], covClus[4], covClus[5],
756 tracks[0], tracks[1], tracks[2],
757 det[0], det[1], det[2], det[3], det[4],
758 parTOF[0], parTOF[1], parTOF[2], parTOF[3], parTOF[4],
759 status, fTOFdigitMap->GetDigitIndex(vol,digIndex)));
760
761 AliDebug(2, Form(" %f %f %f", pos[0], pos[1], pos[2]));
e885fb81 762 AliDebug(2, Form(" %d %d", parTOF[0], parTOF[2]));
763
764 fTOFdigitMap->ResetDigit(vol, digIndex);
765
766 }
767
768 }
769 }
770
771}
772//_____________________________________________________________________________
773
774void AliTOFClusterFinderV1::FindClustersWithoutTOT(Int_t nSector,
775 Int_t nPlate,
776 Int_t nStrip)
777{
778 //
779 // This function searches the isolated digits without TOT
780 // measurement (stored in the fDigits object), to perform clusters
781 // (stored in the fTofClusters array). This research has been made
782 // by checking the fTOFdigitMap object, filled at digits/raw-data
783 // reading time.
784 //
785
786 const Int_t kMaxNumberOfTracksPerDigit = 3;
787 const Int_t kMaxNumberOfDigitsPerVolume = 3;
788
789 Int_t jj = 0;
790
791 Int_t det[5] = {nSector,nPlate,nStrip,-1,-1};//sector,plate,strip,padZ,padX
792 Int_t vol[5] = {nSector,nPlate,nStrip,-1,-1};//sector,plate,strip,padX,padZ
793 UShort_t volIdClus = 0;
794
795 Float_t pos[3];
796 for (jj=0; jj<3; jj++) pos[jj] = 0.;
797 Double_t posClus[3];
798 for (jj=0; jj<3; jj++) posClus[jj] = 0.;
799
800 Double_t covClus[6];
801 for (jj=0; jj<6; jj++) covClus[jj] = 0.;
802
803 Int_t parTOF[5];
804 for (jj=0; jj<5; jj++) parTOF[jj] = 0;
805
806 Bool_t status = kTRUE; //assume all sim channels ok in the beginning...
807 Int_t tracks[kMaxNumberOfTracksPerDigit];
808 for (jj=0; jj<3; jj++) tracks[jj] = -1;
809
810 Int_t dummyCounter=-1;
811
812 AliTOFdigit *digitInteresting;
813
814 Int_t iPadX = -1;
815 Int_t iPadZ = -1;
816 for (iPadX=0; iPadX<AliTOFGeometry::NpadX(); iPadX++) {
817 for (iPadZ=0; iPadZ<AliTOFGeometry::NpadZ(); iPadZ++) {
818 vol[4] = iPadZ , vol[3] = iPadX;
819
820 AliDebug(3, Form(" %1d %2d\n", iPadZ, iPadX));
821
822 if (fTOFdigitMap->GetNumberOfDigits(vol)==0) continue;
823
824 for(Int_t digIndex=0; digIndex<kMaxNumberOfDigitsPerVolume; digIndex++) {
825 if (fTOFdigitMap->GetDigitIndex(vol,digIndex)<0) continue;
826 digitInteresting = (AliTOFdigit*)fDigits->UncheckedAt(fTOFdigitMap->GetDigitIndex(vol,digIndex));
827 if (digitInteresting->GetToT()>0) continue; // AdC
828
829 AliDebug(2, Form(" %3d %5d %2d %1d %2d %1d %2d %d %d %d %5d %5d %5d %5d",
830 fTOFdigitMap->GetNumberOfDigits(vol), digIndex,
831 vol[0], vol[1], vol[2] ,vol[4], vol[3],
832 digitInteresting->GetTdc(), digitInteresting->GetAdc(),
833 digitInteresting->GetToT(),
834 fTOFdigitMap->GetDigitIndex(vol,digIndex),
835 digitInteresting->GetTrack(0), digitInteresting->GetTrack(1), digitInteresting->GetTrack(2)));
836
837 det[3] = vol[4]; // padz
838 det[4] = vol[3]; // padx
839 fTOFGeometry->GetPosPar(det,pos);
840 AliDebug(1,Form(" %f %f %f", pos[0], pos[1], pos[2]));
841
842 //insert cluster
843 for (jj=0; jj<3; jj++) posClus[jj] = pos[jj];
844
845 parTOF[0] = Int_t(digitInteresting->GetTdc());
846 parTOF[1] = Int_t(digitInteresting->GetToT());
847 parTOF[2] = Int_t(digitInteresting->GetAdc());
848 parTOF[3] = Int_t(digitInteresting->GetTdcND());
849 parTOF[4] = Int_t(digitInteresting->GetTdc());
850
851 volIdClus = fTOFGeometry->GetAliSensVolIndex(det[0],det[1],det[2]);
852 //volIdClus = GetClusterVolIndex(det);
853
854 for (jj=0; jj<6; jj++) covClus[jj] = 0.;
855 GetClusterPars(det, posClus, covClus);
856
857 // To fill the track index array
858 dummyCounter=-1;
859 for (jj=0; jj<kMaxNumberOfTracksPerDigit; jj++) tracks[jj] = -1;
860 for (jj=0; jj<kMaxNumberOfTracksPerDigit; jj++) { // three is the max number of tracks associated to one digit
861 if (digitInteresting->GetTrack(jj)==-1) continue;
862 else {
863 dummyCounter++;
864 tracks[dummyCounter] = digitInteresting->GetTrack(jj);
865 }
866 }
867
868 AliTOFcluster *tofCluster =
869 new AliTOFcluster(volIdClus, posClus[0], posClus[1], posClus[2],
870 covClus[0], covClus[1], covClus[2], covClus[3], covClus[4], covClus[5],
871 tracks, det, parTOF, status, fTOFdigitMap->GetDigitIndex(vol,digIndex));
872 InsertCluster(tofCluster);
873
874 AliDebug(2, Form(" %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",
875 volIdClus, posClus[0], posClus[1], posClus[2],
876 covClus[0], covClus[1], covClus[2], covClus[3], covClus[4], covClus[5],
877 tracks[0], tracks[1], tracks[2],
878 det[0], det[1], det[2], det[3], det[4],
879 parTOF[0], parTOF[1], parTOF[2], parTOF[3], parTOF[4],
880 status, fTOFdigitMap->GetDigitIndex(vol,digIndex)));
881
882 AliDebug(2, Form(" %f %f %f", pos[0], pos[1], pos[2]));
883 AliDebug(2, Form(" %d %d", parTOF[0], parTOF[2]));
e3bd5504 884
e3bd5504 885 fTOFdigitMap->ResetDigit(vol, digIndex);
886
887 }
888
889 }
890 }
891
892}
893//_____________________________________________________________________________
894
895void AliTOFClusterFinderV1::FindClusters34(Int_t nSector,
896 Int_t nPlate,
897 Int_t nStrip)
898{
899 //
900 // This function searches the neighbouring digits (stored in the fDigits object),
901 // to perform clusters (stored in the fTofClusters array).
902 //
903 // This research has been made by checking the fTOFdigitMap object,
904 // filled at digits/raw-data reading time.
905 //
906
907 const Int_t kMaxNumberOfInterestingPads = 4;
908 const Int_t kMaxNumberOfTracksPerDigit = 3;
909 const Int_t kMaxNumberOfDigitsPerVolume = 3;
910
911 Int_t ii = 0;
912
913 Int_t digitsInVolumeIndices[kMaxNumberOfDigitsPerVolume];
914 for (ii=0; ii<kMaxNumberOfDigitsPerVolume; ii++)
915 digitsInVolumeIndices[ii] = -1;
916
e3bd5504 917 Int_t vol[5] = {nSector,nPlate,nStrip,-1,-1};
918
919 Float_t pos[3] = {0.,0.,0.};
920
921 Int_t jj = 0;
922 Int_t interestingPadX[kMaxNumberOfInterestingPads];
923 for (jj=0; jj<kMaxNumberOfInterestingPads; jj++) interestingPadX[jj] = -1;
924 Int_t interestingPadZ[kMaxNumberOfInterestingPads];
925 for (jj=0; jj<kMaxNumberOfInterestingPads; jj++) interestingPadZ[jj] = -1;
926 Double_t interestingTOT[kMaxNumberOfInterestingPads];
927 for (jj=0; jj<kMaxNumberOfInterestingPads; jj++) interestingTOT[jj] = 0;
928 Double_t interestingADC[kMaxNumberOfInterestingPads];
929 for (jj=0; jj<kMaxNumberOfInterestingPads; jj++) interestingADC[jj] = 0;
930 Double_t interestingTOF[kMaxNumberOfInterestingPads];
931 for (jj=0; jj<kMaxNumberOfInterestingPads; jj++) interestingTOF[jj] = 0;
932 Double_t interestingWeight[kMaxNumberOfInterestingPads];
933 for (jj=0; jj<kMaxNumberOfInterestingPads; jj++) interestingWeight[jj] = 0;
934
935 Float_t interestingX[kMaxNumberOfInterestingPads];
936 for (jj=0; jj<kMaxNumberOfInterestingPads; jj++) interestingX[jj] = 0;
937 Float_t interestingY[kMaxNumberOfInterestingPads];
938 for (jj=0; jj<kMaxNumberOfInterestingPads; jj++) interestingY[jj] = 0;
939 Float_t interestingZ[kMaxNumberOfInterestingPads];
940 for (jj=0; jj<kMaxNumberOfInterestingPads; jj++) interestingZ[jj] = 0;
941
942 Float_t interDigit[kMaxNumberOfInterestingPads];
943 for (jj=0; jj<kMaxNumberOfInterestingPads; jj++) interDigit[jj] = 0;
944
945 Int_t padsCluster[11];
946 padsCluster[0] = nSector;
947 padsCluster[1] = nPlate;
948 padsCluster[2] = nStrip;
949 for (jj=3; jj<11; jj++) padsCluster[jj] = -1;
950
951 Int_t interestingCounter=-1;
e885fb81 952 Int_t digitIndexLocal=-1; // AdC
e3bd5504 953 Int_t iPad = -1;
954 Int_t iPadX = -1;
955 Int_t iPadZ = -1;
956
957 Int_t parTOF[5];
958 for (jj=0; jj<5; jj++) parTOF[jj] = 0;
959 Double_t posClus[3];
960 for (jj=0; jj<3; jj++) posClus[jj] = 0.;
961 Int_t det[5];
962 for (jj=0; jj<5; jj++) det[jj] = -1;
963 Float_t posF[3];
964 for (jj=0; jj<3; jj++) posF[jj] = 0.;
965 UShort_t volIdClus = 0;
966 Bool_t check = kFALSE;
967 Bool_t status = kTRUE; //assume all sim channels ok in the beginning...
968 Double_t covClus[6];
969 for (jj=0; jj<6; jj++) covClus[jj] = 0.;
970 Int_t tracks[kMaxNumberOfTracksPerDigit];
971 for (jj=0; jj<3; jj++) tracks[jj] = -1;
972 Int_t dummyCounter=-1;
973 Bool_t alreadyStored = kFALSE;
974
975 AliTOFselectedDigit ***selectedDigit = new AliTOFselectedDigit**[kMaxNumberOfInterestingPads];
976 for (ii=0; ii<kMaxNumberOfInterestingPads; ii++)
977 selectedDigit[ii] = new AliTOFselectedDigit*[kMaxNumberOfDigitsPerVolume];
978
979 for (ii=0; ii<kMaxNumberOfInterestingPads; ii++)
980 for (jj=0; jj<kMaxNumberOfDigitsPerVolume; jj++) selectedDigit[ii][jj] = 0x0;
981
982 AliTOFdigit *digitInteresting;
983
984 for (iPad=0; iPad<AliTOFGeometry::NpadZ()*AliTOFGeometry::NpadX()-3; iPad+=2) {
985
986 iPadZ = iPad%AliTOFGeometry::NpadZ(); //iPad%2;
987 iPadX = iPad/AliTOFGeometry::NpadZ(); //iPad/2;
988
e885fb81 989 AliDebug(3, Form("%2d %1d %2d\n", iPad, iPadZ, iPadX));
e3bd5504 990
991
992
993
994
995
996 interestingCounter=-1;
997
998 vol[4] = iPadZ , vol[3] = iPadX;
999 if (fTOFdigitMap->GetNumberOfDigits(vol)>0)
1000 interestingCounter++;
1001
1002 vol[4] = iPadZ, vol[3] = iPadX+1;
1003 if (fTOFdigitMap->GetNumberOfDigits(vol)>0)
1004 interestingCounter++;
1005
1006 vol[4] = AliTOFGeometry::NpadZ()-(iPadZ+1), vol[3] = iPadX;
1007 if (fTOFdigitMap->GetNumberOfDigits(vol)>0)
1008 interestingCounter++;
1009
1010 vol[4] = AliTOFGeometry::NpadZ()-(iPadZ+1), vol[3] = iPadX+1;
1011 if (fTOFdigitMap->GetNumberOfDigits(vol)>0)
1012 interestingCounter++;
1013
1014 if (interestingCounter+1!=4) continue; // the hit pads have to be 4
1015 else interestingCounter=-1;
1016
1017
1018 for (ii=0; ii<kMaxNumberOfInterestingPads; ii++)
1019 for (jj=0; jj<kMaxNumberOfDigitsPerVolume; jj++)
1020 selectedDigit[ii][jj] = 0x0;
1021
1022
1023 vol[4] = iPadZ, vol[3] = iPadX;
1024
1025 if (fTOFdigitMap->GetNumberOfDigits(vol)>0) {
1026 interestingCounter++;
1027 for (ii=0; ii<kMaxNumberOfDigitsPerVolume; ii++)
1028 digitsInVolumeIndices[ii] = -1;
1029 fTOFdigitMap->GetDigitIndex(vol, digitsInVolumeIndices);
e885fb81 1030 digitIndexLocal=-1; // AdC
e3bd5504 1031 for(Int_t digIndex=0; digIndex<kMaxNumberOfDigitsPerVolume; digIndex++) {
1032 if (digitsInVolumeIndices[digIndex]<0) continue;
1033 digitInteresting = (AliTOFdigit*)fDigits->UncheckedAt(digitsInVolumeIndices[digIndex]);
e885fb81 1034 if (digitInteresting->GetToT()<=0) continue; // AdC
1035 digitIndexLocal++; // AdC
e3bd5504 1036
e885fb81 1037 AliDebug(1,Form(" %2d %1d %2d %1d %2d %f %f %f %f %5d %5d %5d %5d",
e3bd5504 1038 vol[0], vol[1], vol[2] ,vol[4], vol[3],
1039 digitInteresting->GetTdc(), digitInteresting->GetAdc(),
1040 digitInteresting->GetToT(), digitInteresting->GetToT()*digitInteresting->GetToT(),
1041 digitsInVolumeIndices[digIndex],
1042 digitInteresting->GetTrack(0), digitInteresting->GetTrack(1), digitInteresting->GetTrack(2)));
1043
1044
e885fb81 1045 selectedDigit[interestingCounter][digitIndexLocal] = new // AdC
e3bd5504 1046 AliTOFselectedDigit(vol, digitInteresting->GetTdc(),
1047 digitInteresting->GetAdc(), digitInteresting->GetToT(),
1048 digitInteresting->GetToT()*digitInteresting->GetToT(),
1049 digitsInVolumeIndices[digIndex],
1050 digitInteresting->GetTracks());
1051 }
e885fb81 1052 if (digitIndexLocal==-1) interestingCounter--; // AdC
e3bd5504 1053 }
1054
1055
1056 vol[4] = iPadZ, vol[3] = iPadX+1;
1057
1058 if (fTOFdigitMap->GetNumberOfDigits(vol)>0) {
1059 interestingCounter++;
1060 for (ii=0; ii<kMaxNumberOfDigitsPerVolume; ii++)
1061 digitsInVolumeIndices[ii] = -1;
1062 fTOFdigitMap->GetDigitIndex(vol, digitsInVolumeIndices);
e885fb81 1063 digitIndexLocal=-1; // AdC
e3bd5504 1064 for(Int_t digIndex=0; digIndex<kMaxNumberOfDigitsPerVolume; digIndex++) {
1065 if (digitsInVolumeIndices[digIndex]<0) continue;
1066 digitInteresting = (AliTOFdigit*)fDigits->UncheckedAt(digitsInVolumeIndices[digIndex]);
e885fb81 1067 if (digitInteresting->GetToT()<=0) continue; // AdC
1068 digitIndexLocal++; // AdC
e3bd5504 1069
e885fb81 1070 AliDebug(1,Form(" %2d %1d %2d %1d %2d %f %f %f %f %5d %5d %5d %5d",
e3bd5504 1071 vol[0], vol[1], vol[2] ,vol[4], vol[3],
1072 digitInteresting->GetTdc(), digitInteresting->GetAdc(),
1073 digitInteresting->GetToT(), digitInteresting->GetToT()*digitInteresting->GetToT(),
1074 digitsInVolumeIndices[digIndex],
1075 digitInteresting->GetTrack(0), digitInteresting->GetTrack(1), digitInteresting->GetTrack(2)));
1076
1077
e885fb81 1078 selectedDigit[interestingCounter][digitIndexLocal] = new // AdC
e3bd5504 1079 AliTOFselectedDigit(vol, digitInteresting->GetTdc(),
1080 digitInteresting->GetAdc(), digitInteresting->GetToT(),
1081 digitInteresting->GetToT()*digitInteresting->GetToT(),
1082 digitsInVolumeIndices[digIndex],
1083 digitInteresting->GetTracks());
1084 }
e885fb81 1085 if (digitIndexLocal==-1) interestingCounter--; // AdC
e3bd5504 1086 }
1087
1088
1089 vol[4] = AliTOFGeometry::NpadZ()-(iPadZ+1), vol[3] = iPadX;
1090
1091 if (fTOFdigitMap->GetNumberOfDigits(vol)>0) {
1092 interestingCounter++;
1093 for (ii=0; ii<kMaxNumberOfDigitsPerVolume; ii++)
1094 digitsInVolumeIndices[ii] = -1;
1095 fTOFdigitMap->GetDigitIndex(vol, digitsInVolumeIndices);
e885fb81 1096 digitIndexLocal=-1; // AdC
e3bd5504 1097 for(Int_t digIndex=0; digIndex<kMaxNumberOfDigitsPerVolume; digIndex++) {
1098 if (digitsInVolumeIndices[digIndex]<0) continue;
1099 digitInteresting = (AliTOFdigit*)fDigits->UncheckedAt(digitsInVolumeIndices[digIndex]);
e885fb81 1100 if (digitInteresting->GetToT()<=0) continue; // AdC
1101 digitIndexLocal++; // AdC
e3bd5504 1102
e885fb81 1103 AliDebug(1,Form(" %2d %1d %2d %1d %2d %f %f %f %f %5d %5d %5d %5d",
e3bd5504 1104 vol[0], vol[1], vol[2] ,vol[4], vol[3],
1105 digitInteresting->GetTdc(), digitInteresting->GetAdc(),
1106 digitInteresting->GetToT(), digitInteresting->GetToT()*digitInteresting->GetToT(),
1107 digitsInVolumeIndices[digIndex],
1108 digitInteresting->GetTrack(0), digitInteresting->GetTrack(1), digitInteresting->GetTrack(2)));
1109
1110
e885fb81 1111 selectedDigit[interestingCounter][digitIndexLocal] = new // AdC
e3bd5504 1112 AliTOFselectedDigit(vol, digitInteresting->GetTdc(),
1113 digitInteresting->GetAdc(), digitInteresting->GetToT(),
1114 digitInteresting->GetToT()*digitInteresting->GetToT(),
1115 digitsInVolumeIndices[digIndex],
1116 digitInteresting->GetTracks());
1117 }
e885fb81 1118 if (digitIndexLocal==-1) interestingCounter--; // AdC
e3bd5504 1119 }
1120
1121
1122 vol[4] = AliTOFGeometry::NpadZ()-(iPadZ+1), vol[3] = iPadX+1;
1123
1124 if (fTOFdigitMap->GetNumberOfDigits(vol)>0) {
1125 interestingCounter++;
1126 for (ii=0; ii<kMaxNumberOfDigitsPerVolume; ii++)
1127 digitsInVolumeIndices[ii] = -1;
1128 fTOFdigitMap->GetDigitIndex(vol, digitsInVolumeIndices);
e885fb81 1129 digitIndexLocal=-1;
e3bd5504 1130 for(Int_t digIndex=0; digIndex<kMaxNumberOfDigitsPerVolume; digIndex++) {
1131 if (digitsInVolumeIndices[digIndex]<0) continue;
1132 digitInteresting = (AliTOFdigit*)fDigits->UncheckedAt(digitsInVolumeIndices[digIndex]);
e885fb81 1133 if (digitInteresting->GetToT()<=0) continue; // AdC
1134 digitIndexLocal++; // AdC
e3bd5504 1135
e885fb81 1136 AliDebug(1,Form(" %2d %1d %2d %1d %2d %f %f %f %f %5d %5d %5d %5d",
e3bd5504 1137 vol[0], vol[1], vol[2] ,vol[4], vol[3],
1138 digitInteresting->GetTdc(), digitInteresting->GetAdc(),
1139 digitInteresting->GetToT(), digitInteresting->GetToT()*digitInteresting->GetToT(),
1140 digitsInVolumeIndices[digIndex],
1141 digitInteresting->GetTrack(0), digitInteresting->GetTrack(1), digitInteresting->GetTrack(2)));
1142
e885fb81 1143 selectedDigit[interestingCounter][digitIndexLocal] = new // AdC
e3bd5504 1144 AliTOFselectedDigit(vol, digitInteresting->GetTdc(),
1145 digitInteresting->GetAdc(), digitInteresting->GetToT(),
1146 digitInteresting->GetToT()*digitInteresting->GetToT(),
1147 digitsInVolumeIndices[digIndex],
1148 digitInteresting->GetTracks());
1149 }
e885fb81 1150 if (digitIndexLocal==-1) interestingCounter--; // AdC
e3bd5504 1151 }
1152
e885fb81 1153 AliDebug(1,Form(" e adesso %1d", interestingCounter+1));
e3bd5504 1154
1155 for (Int_t adesso1=0; adesso1<interestingCounter+1; adesso1++) {
1156 for (Int_t firstIndex=0; firstIndex<kMaxNumberOfDigitsPerVolume; firstIndex++) {
1157 if (selectedDigit[adesso1][firstIndex]==0x0) continue;
1158
1159 for (Int_t adesso2=adesso1+1; adesso2<interestingCounter+1; adesso2++) {
1160 for (Int_t secondIndex=0; secondIndex<kMaxNumberOfDigitsPerVolume; secondIndex++) {
1161 if (selectedDigit[adesso2][secondIndex]==0x0) continue;
1162
1163 for (Int_t adesso3=adesso2+1; adesso3<interestingCounter+1; adesso3++) {
1164 for (Int_t thirdIndex=0; thirdIndex<kMaxNumberOfDigitsPerVolume; thirdIndex++) {
1165 if (selectedDigit[adesso3][thirdIndex]==0x0) continue;
1166
1167
1168 if (TMath::Abs(selectedDigit[adesso1][firstIndex]->GetTDC()-selectedDigit[adesso2][secondIndex]->GetTDC())>fMaxDeltaTime
1169 ||
1170 TMath::Abs(selectedDigit[adesso1][firstIndex]->GetTDC()-selectedDigit[adesso3][thirdIndex]->GetTDC())>fMaxDeltaTime
1171 ||
1172 TMath::Abs(selectedDigit[adesso2][secondIndex]->GetTDC()-selectedDigit[adesso3][thirdIndex]->GetTDC())>fMaxDeltaTime) continue;
1173
1174 interestingTOF[0] = selectedDigit[adesso1][firstIndex]->GetTDC();
1175 interestingTOT[0] = selectedDigit[adesso1][firstIndex]->GetTOT();
1176 interestingADC[0] = selectedDigit[adesso1][firstIndex]->GetADC();
1177 interestingWeight[0] = selectedDigit[adesso1][firstIndex]->GetWeight();
1178 Int_t vol1[5]; for(jj=0; jj<5; jj++) vol1[jj] = selectedDigit[adesso1][firstIndex]->GetDetectorIndex(jj);
e885fb81 1179 AliDebug(1,Form(" %2d %1d %2d %1d %2d", vol1[0], vol1[1], vol1[2], vol1[4], vol1[3]));
e3bd5504 1180 Int_t volDum = vol1[3];
1181 vol1[3] = vol1[4];
1182 vol1[4] = volDum;
e885fb81 1183 fTOFGeometry->GetPosPar(vol1,pos);
e3bd5504 1184 interestingX[0] = pos[0];
1185 interestingY[0] = pos[1];
1186 interestingZ[0] = pos[2];
1187
1188 interestingTOF[1] = selectedDigit[adesso2][secondIndex]->GetTDC();
1189 interestingTOT[1] = selectedDigit[adesso2][secondIndex]->GetTOT();
1190 interestingADC[1] = selectedDigit[adesso2][secondIndex]->GetADC();
1191 interestingWeight[1] = selectedDigit[adesso2][secondIndex]->GetWeight();
1192 Int_t vol2[5]; for(jj=0; jj<5; jj++) vol2[jj] = selectedDigit[adesso2][secondIndex]->GetDetectorIndex(jj);
e885fb81 1193 AliDebug(1,Form(" %2d %1d %2d %1d %2d", vol2[0], vol2[1], vol2[2], vol2[4], vol2[3]));
e3bd5504 1194 volDum = vol2[3];
1195 vol2[3] = vol2[4];
1196 vol2[4] = volDum;
e885fb81 1197 fTOFGeometry->GetPosPar(vol2,pos);
e3bd5504 1198 interestingX[1] = pos[0];
1199 interestingY[1] = pos[1];
1200 interestingZ[1] = pos[2];
1201
1202 interestingTOF[2] = selectedDigit[adesso3][thirdIndex]->GetTDC();
1203 interestingTOT[2] = selectedDigit[adesso3][thirdIndex]->GetTOT();
1204 interestingADC[2] = selectedDigit[adesso3][thirdIndex]->GetADC();
1205 interestingWeight[2] = selectedDigit[adesso3][thirdIndex]->GetWeight();
1206 Int_t vol3[5]; for(jj=0; jj<5; jj++) vol3[jj] = selectedDigit[adesso3][thirdIndex]->GetDetectorIndex(jj);
e885fb81 1207 AliDebug(1,Form(" %2d %1d %2d %1d %2d", vol3[0], vol3[1], vol3[2], vol3[4], vol3[3]));
e3bd5504 1208 volDum = vol3[3];
1209 vol3[3] = vol3[4];
1210 vol3[4] = volDum;
e885fb81 1211 fTOFGeometry->GetPosPar(vol3,pos);
e3bd5504 1212 interestingX[2] = pos[0];
1213 interestingY[2] = pos[1];
1214 interestingZ[2] = pos[2];
1215
1216
1217 AverageCalculations(3, interestingX, interestingY, interestingZ,
1218 interestingTOF, interestingTOT, interestingADC,
1219 interestingWeight,
1220 parTOF, posClus, check);
1221
1222
1223 for (jj=0; jj<5; jj++) det[jj] = -1;
1224 for (jj=0; jj<3; jj++) posF[jj] = posClus[jj];
e885fb81 1225 fTOFGeometry->GetDetID(posF, det);
e3bd5504 1226
e885fb81 1227 volIdClus = fTOFGeometry->GetAliSensVolIndex(det[0],det[1],det[2]);
1228 //volIdClus = GetClusterVolIndex(det);
e3bd5504 1229
1230 for (jj=3; jj<11; jj++) padsCluster[jj] = -1;
1231 padsCluster[3] = selectedDigit[adesso1][firstIndex]->GetDetectorIndex(4);
1232 padsCluster[4] = selectedDigit[adesso1][firstIndex]->GetDetectorIndex(3);
1233 padsCluster[5] = selectedDigit[adesso2][secondIndex]->GetDetectorIndex(4);
1234 padsCluster[6] = selectedDigit[adesso2][secondIndex]->GetDetectorIndex(3);
1235 padsCluster[7] = selectedDigit[adesso3][thirdIndex]->GetDetectorIndex(4);
1236 padsCluster[8] = selectedDigit[adesso3][thirdIndex]->GetDetectorIndex(3);
1237
1238 for (jj=0; jj<6; jj++) covClus[jj] = 0.;
1239 Int_t ** indDet = new Int_t*[3];
1240 for (jj=0; jj<3; jj++) indDet[jj] = new Int_t [5];
1241 for (jj=0; jj<3; jj++) indDet[jj][0] = nSector;
1242 for (jj=0; jj<3; jj++) indDet[jj][1] = nPlate;
1243 for (jj=0; jj<3; jj++) indDet[jj][2] = nStrip;
1244 for (jj=0; jj<3; jj++) indDet[jj][3] = padsCluster[2*jj+3];
1245 for (jj=0; jj<3; jj++) indDet[jj][4] = padsCluster[2*jj+1+3];
e885fb81 1246 GetClusterPars(/*check,*/ 3, indDet, interestingWeight, posClus, covClus);
e3bd5504 1247 for (jj=0; jj<3; jj++) delete [] indDet[jj];
1248
1249 // To fill the track index array
1250 dummyCounter=-1;
1251 for (jj=0; jj<kMaxNumberOfTracksPerDigit; jj++) tracks[jj] = -1;
1252 for (Int_t kk=0; kk<kMaxNumberOfTracksPerDigit; kk++) { // three is the max number of tracks associated to one digit
1253 if (selectedDigit[adesso1][firstIndex]->GetTrackLabel(kk)==-1) continue;
1254 else {
1255 dummyCounter++;
1256 tracks[dummyCounter] = selectedDigit[adesso1][firstIndex]->GetTrackLabel(kk);
1257 }
1258 }
1259 for (Int_t kk=0; kk<kMaxNumberOfTracksPerDigit; kk++) { // three is the max number of tracks associated to one digit
1260 if (selectedDigit[adesso2][secondIndex]->GetTrackLabel(kk)==-1) continue;
1261 else {
1262
1263 alreadyStored = kFALSE;
1264 for (jj=0; jj<dummyCounter+1; jj++)
1265 alreadyStored = alreadyStored || (tracks[jj]!=-1 && tracks[jj]==selectedDigit[adesso2][secondIndex]->GetTrackLabel(kk));
1266
1267 if (alreadyStored) continue;
1268 if (dummyCounter==2) { // three is the max number of tracks associated to one cluster
1269 AliWarning(" Siamo al limite!");
1270 continue;
1271 }
1272
1273 dummyCounter++;
1274 tracks[dummyCounter] = selectedDigit[adesso2][secondIndex]->GetTrackLabel(kk);
1275
1276 }
1277
1278 }
1279 for (Int_t kk=0; kk<kMaxNumberOfTracksPerDigit; kk++) { // three is the max number of tracks associated to one digit
1280 if (selectedDigit[adesso3][thirdIndex]->GetTrackLabel(kk)==-1) continue;
1281 else {
1282
1283 alreadyStored = kFALSE;
1284 for (jj=0; jj<dummyCounter+1; jj++)
1285 alreadyStored = alreadyStored || (tracks[jj]!=-1 && tracks[jj]==selectedDigit[adesso3][thirdIndex]->GetTrackLabel(kk));
1286
1287 if (alreadyStored) continue;
1288 if (dummyCounter==2) { // three is the max number of tracks associated to one cluster
1289 AliWarning(" Siamo al limite!");
1290 continue;
1291 }
1292
1293 dummyCounter++;
1294 tracks[dummyCounter] = selectedDigit[adesso3][thirdIndex]->GetTrackLabel(kk);
1295
1296 }
1297
1298 }
1299
1300
1301 AliTOFcluster *tofCluster =
1302 new AliTOFcluster(volIdClus, posClus[0], posClus[1], posClus[2],
1303 covClus[0], covClus[1], covClus[2], covClus[3], covClus[4], covClus[5],
1304 tracks, det, parTOF, status, selectedDigit[adesso1][firstIndex]->GetIndex()); // to be updated
1305 InsertCluster(tofCluster);
1306
e885fb81 1307 AliDebug(2, Form(" %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",
e3bd5504 1308 volIdClus, posClus[0], posClus[1], posClus[2],
1309 covClus[0], covClus[1], covClus[2], covClus[3], covClus[4], covClus[5],
1310 tracks[0], tracks[1], tracks[2],
1311 det[0], det[1], det[2], det[3], det[4],
1312 parTOF[0], parTOF[1], parTOF[2], parTOF[3], parTOF[4],
1313 status, selectedDigit[adesso1][firstIndex]->GetIndex()));
1314
1315
1316 volDum = vol1[3];
1317 vol1[3] = vol1[4];
1318 vol1[4] = volDum;
1319 fTOFdigitMap->ResetDigitNumber(vol1,selectedDigit[adesso1][firstIndex]->GetIndex());
1320 volDum = vol2[3];
1321 vol2[3] = vol2[4];
1322 vol2[4] = volDum;
1323 fTOFdigitMap->ResetDigitNumber(vol2,selectedDigit[adesso2][secondIndex]->GetIndex());
1324 volDum = vol3[3];
1325 vol3[3] = vol3[4];
1326 vol3[4] = volDum;
1327 fTOFdigitMap->ResetDigitNumber(vol3,selectedDigit[adesso3][thirdIndex]->GetIndex());
1328
1329
1330 } // close loop on third digit
1331 } // close loop on adesso3
1332
1333 } // close loop on second digit
1334 } // close loop on adesso2
1335
1336 } // close loop on first digit
1337 } // close loop on adesso1
1338
1339 for (ii=0; ii<kMaxNumberOfInterestingPads; ii++)
1340 for (jj=0; jj<kMaxNumberOfDigitsPerVolume; jj++)
1341 selectedDigit[ii][jj] = 0x0;
1342
1343 } // loop on iPad
1344
1345 for (ii=0; ii<kMaxNumberOfInterestingPads; ii++)
1346 for (jj=0; jj<kMaxNumberOfDigitsPerVolume; jj++) {
1347 delete selectedDigit[ii][jj];
1348 selectedDigit[ii][jj] = 0x0;
1349 }
1350
1351
1352}
1353//_____________________________________________________________________________
1354
1355void AliTOFClusterFinderV1::FindClusters23(Int_t nSector,
1356 Int_t nPlate,
1357 Int_t nStrip)
1358{
1359 //
1360 // This function searches the neighbouring digits (stored in the fDigits object),
1361 // to perform clusters (stored in the fTofClusters array).
1362 //
1363 // This research has been made by checking the fTOFdigitMap object,
1364 // filled at digits/raw-data reading time.
1365 //
1366
1367 const Int_t kMaxNumberOfInterestingPads = 4;
1368 const Int_t kMaxNumberOfTracksPerDigit = 3;
1369 const Int_t kMaxNumberOfDigitsPerVolume = 3;
1370
1371 Int_t ii = 0;
1372
1373 Int_t digitsInVolumeIndices[kMaxNumberOfDigitsPerVolume];
1374 for (ii=0; ii<kMaxNumberOfDigitsPerVolume; ii++)
1375 digitsInVolumeIndices[ii] = -1;
1376
e3bd5504 1377 Int_t vol[5] = {nSector,nPlate,nStrip,-1,-1};
1378
1379 Float_t pos[3] = {0.,0.,0.};
1380
1381 Int_t jj = 0;
1382 Int_t interestingPadX[kMaxNumberOfInterestingPads];
1383 for (jj=0; jj<kMaxNumberOfInterestingPads; jj++) interestingPadX[jj] = -1;
1384 Int_t interestingPadZ[kMaxNumberOfInterestingPads];
1385 for (jj=0; jj<kMaxNumberOfInterestingPads; jj++) interestingPadZ[jj] = -1;
1386 Double_t interestingTOT[kMaxNumberOfInterestingPads];
1387 for (jj=0; jj<kMaxNumberOfInterestingPads; jj++) interestingTOT[jj] = 0;
1388 Double_t interestingADC[kMaxNumberOfInterestingPads];
1389 for (jj=0; jj<kMaxNumberOfInterestingPads; jj++) interestingADC[jj] = 0;
1390 Double_t interestingTOF[kMaxNumberOfInterestingPads];
1391 for (jj=0; jj<kMaxNumberOfInterestingPads; jj++) interestingTOF[jj] = 0;
1392 Double_t interestingWeight[kMaxNumberOfInterestingPads];
1393 for (jj=0; jj<kMaxNumberOfInterestingPads; jj++) interestingWeight[jj] = 0;
1394
1395 Float_t interestingX[kMaxNumberOfInterestingPads];
1396 for (jj=0; jj<kMaxNumberOfInterestingPads; jj++) interestingX[jj] = 0;
1397 Float_t interestingY[kMaxNumberOfInterestingPads];
1398 for (jj=0; jj<kMaxNumberOfInterestingPads; jj++) interestingY[jj] = 0;
1399 Float_t interestingZ[kMaxNumberOfInterestingPads];
1400 for (jj=0; jj<kMaxNumberOfInterestingPads; jj++) interestingZ[jj] = 0;
1401
1402 Float_t interDigit[kMaxNumberOfInterestingPads];
1403 for (jj=0; jj<kMaxNumberOfInterestingPads; jj++) interDigit[jj] = 0;
1404
1405 Int_t padsCluster[11];
1406 padsCluster[0] = nSector;
1407 padsCluster[1] = nPlate;
1408 padsCluster[2] = nStrip;
1409 for (jj=3; jj<11; jj++) padsCluster[jj] = -1;
1410
1411 Int_t interestingCounter=-1;
e885fb81 1412 Int_t digitIndexLocal = -1;
e3bd5504 1413 Int_t iPad = -1;
1414 Int_t iPadX = -1;
1415 Int_t iPadZ = -1;
1416
1417 Bool_t check = kFALSE;
1418 Int_t parTOF[5];
1419 for (jj=0; jj<5; jj++) parTOF[jj] = 0;
1420 Double_t posClus[3];
1421 for (jj=0; jj<3; jj++) posClus[jj] = 0.;
1422 Int_t det[5];
1423 for (jj=0; jj<5; jj++) det[jj] = -1;
1424 Float_t posF[3];
1425 for (jj=0; jj<3; jj++) posF[jj] = 0.;
1426 UShort_t volIdClus = 0;
1427 Bool_t status = kTRUE; //assume all sim channels ok in the beginning...
1428 Double_t covClus[6];
1429 for (jj=0; jj<6; jj++) covClus[jj] = 0.;
1430 Int_t tracks[kMaxNumberOfTracksPerDigit];
1431 for (jj=0; jj<3; jj++) tracks[jj] = -1;
1432 Int_t dummyCounter=-1;
1433 Bool_t alreadyStored = kFALSE;
1434
1435 AliTOFselectedDigit ***selectedDigit = new AliTOFselectedDigit**[kMaxNumberOfInterestingPads];
1436 for (ii=0; ii<kMaxNumberOfInterestingPads; ii++)
1437 selectedDigit[ii] = new AliTOFselectedDigit*[kMaxNumberOfDigitsPerVolume];
1438
1439 for (ii=0; ii<kMaxNumberOfInterestingPads; ii++)
1440 for (jj=0; jj<kMaxNumberOfDigitsPerVolume; jj++) selectedDigit[ii][jj] = 0x0;
1441
1442 AliTOFdigit *digitInteresting;
1443
1444 for (iPad=0; iPad<AliTOFGeometry::NpadZ()*AliTOFGeometry::NpadX()-3; iPad+=2) {
1445
1446 iPadZ = iPad%AliTOFGeometry::NpadZ(); //iPad%2;
1447 iPadX = iPad/AliTOFGeometry::NpadZ(); //iPad/2;
1448
e885fb81 1449 AliDebug(3, Form("%2d %1d %2d\n", iPad, iPadZ, iPadX));
e3bd5504 1450
1451
1452
1453
1454
1455
1456 interestingCounter=-1;
1457
1458 vol[4] = iPadZ , vol[3] = iPadX;
1459 if (fTOFdigitMap->GetNumberOfDigits(vol)>0)
1460 interestingCounter++;
1461
1462 vol[4] = iPadZ, vol[3] = iPadX+1;
1463 if (fTOFdigitMap->GetNumberOfDigits(vol)>0)
1464 interestingCounter++;
1465
1466 vol[4] = AliTOFGeometry::NpadZ()-(iPadZ+1), vol[3] = iPadX;
1467 if (fTOFdigitMap->GetNumberOfDigits(vol)>0)
1468 interestingCounter++;
1469
1470 vol[4] = AliTOFGeometry::NpadZ()-(iPadZ+1), vol[3] = iPadX+1;
1471 if (fTOFdigitMap->GetNumberOfDigits(vol)>0)
1472 interestingCounter++;
1473
1474 if (interestingCounter+1!=3) continue; // the hit pads have to be 3
1475 else interestingCounter=-1;
1476
1477
1478 for (ii=0; ii<kMaxNumberOfInterestingPads; ii++)
1479 for (jj=0; jj<kMaxNumberOfDigitsPerVolume; jj++)
1480 selectedDigit[ii][jj] = 0x0;
1481
1482
1483 vol[4] = iPadZ, vol[3] = iPadX;
1484
1485 if (fTOFdigitMap->GetNumberOfDigits(vol)>0) {
1486 interestingCounter++;
1487 for (ii=0; ii<kMaxNumberOfDigitsPerVolume; ii++)
1488 digitsInVolumeIndices[ii] = -1;
1489 fTOFdigitMap->GetDigitIndex(vol, digitsInVolumeIndices);
e885fb81 1490 digitIndexLocal=-1;
e3bd5504 1491 for(Int_t digIndex=0; digIndex<kMaxNumberOfDigitsPerVolume; digIndex++) {
1492 if (digitsInVolumeIndices[digIndex]<0) continue;
1493 digitInteresting = (AliTOFdigit*)fDigits->UncheckedAt(digitsInVolumeIndices[digIndex]);
e885fb81 1494 if (digitInteresting->GetToT()<=0) continue; // AdC
1495 digitIndexLocal++; // AdC
e3bd5504 1496
e885fb81 1497 AliDebug(1,Form(" %2d %1d %2d %1d %2d %f %f %f %f %5d %5d %5d %5d",
e3bd5504 1498 vol[0], vol[1], vol[2] ,vol[4], vol[3],
1499 digitInteresting->GetTdc(), digitInteresting->GetAdc(),
1500 digitInteresting->GetToT(), digitInteresting->GetToT()*digitInteresting->GetToT(),
1501 digitsInVolumeIndices[digIndex],
1502 digitInteresting->GetTrack(0), digitInteresting->GetTrack(1), digitInteresting->GetTrack(2)));
1503
e885fb81 1504 selectedDigit[interestingCounter][digitIndexLocal] = new // AdC
e3bd5504 1505 AliTOFselectedDigit(vol, digitInteresting->GetTdc(),
1506 digitInteresting->GetAdc(), digitInteresting->GetToT(),
1507 digitInteresting->GetToT()*digitInteresting->GetToT(),
1508 digitsInVolumeIndices[digIndex],
1509 digitInteresting->GetTracks());
1510 }
e885fb81 1511 if (digitIndexLocal==-1) interestingCounter--; // AdC
e3bd5504 1512 }
1513
1514
1515 vol[4] = iPadZ, vol[3] = iPadX+1;
1516
1517 if (fTOFdigitMap->GetNumberOfDigits(vol)>0) {
1518 interestingCounter++;
1519 for (ii=0; ii<kMaxNumberOfDigitsPerVolume; ii++)
1520 digitsInVolumeIndices[ii] = -1;
1521 fTOFdigitMap->GetDigitIndex(vol, digitsInVolumeIndices);
e885fb81 1522 digitIndexLocal=-1; // AdC
e3bd5504 1523 for(Int_t digIndex=0; digIndex<kMaxNumberOfDigitsPerVolume; digIndex++) {
1524 if (digitsInVolumeIndices[digIndex]<0) continue;
1525 digitInteresting = (AliTOFdigit*)fDigits->UncheckedAt(digitsInVolumeIndices[digIndex]);
e885fb81 1526 if (digitInteresting->GetToT()<=0) continue; // AdC
1527 digitIndexLocal++; // AdC
e3bd5504 1528
e885fb81 1529 AliDebug(1,Form(" %2d %1d %2d %1d %2d %f %f %f %f %5d %5d %5d %5d",
e3bd5504 1530 vol[0], vol[1], vol[2] ,vol[4], vol[3],
1531 digitInteresting->GetTdc(), digitInteresting->GetAdc(),
1532 digitInteresting->GetToT(), digitInteresting->GetToT()*digitInteresting->GetToT(),
1533 digitsInVolumeIndices[digIndex],
1534 digitInteresting->GetTrack(0), digitInteresting->GetTrack(1), digitInteresting->GetTrack(2)));
1535
e885fb81 1536 selectedDigit[interestingCounter][digitIndexLocal] = new // AdC
e3bd5504 1537 AliTOFselectedDigit(vol, digitInteresting->GetTdc(),
1538 digitInteresting->GetAdc(), digitInteresting->GetToT(),
1539 digitInteresting->GetToT()*digitInteresting->GetToT(),
1540 digitsInVolumeIndices[digIndex],
1541 digitInteresting->GetTracks());
1542 }
e885fb81 1543 if (digitIndexLocal==-1) interestingCounter--; // AdC
e3bd5504 1544 }
1545
1546
1547 vol[4] = AliTOFGeometry::NpadZ()-(iPadZ+1), vol[3] = iPadX;
1548
1549 if (fTOFdigitMap->GetNumberOfDigits(vol)>0) {
1550 interestingCounter++;
1551 for (ii=0; ii<kMaxNumberOfDigitsPerVolume; ii++)
1552 digitsInVolumeIndices[ii] = -1;
1553 fTOFdigitMap->GetDigitIndex(vol, digitsInVolumeIndices);
e885fb81 1554 digitIndexLocal=-1; // AdC
e3bd5504 1555 for(Int_t digIndex=0; digIndex<kMaxNumberOfDigitsPerVolume; digIndex++) {
1556 if (digitsInVolumeIndices[digIndex]<0) continue;
1557 digitInteresting = (AliTOFdigit*)fDigits->UncheckedAt(digitsInVolumeIndices[digIndex]);
e885fb81 1558 if (digitInteresting->GetToT()<=0) continue; // AdC
1559 digitIndexLocal++; // AdC
e3bd5504 1560
e885fb81 1561 AliDebug(1,Form(" %2d %1d %2d %1d %2d %f %f %f %f %5d %5d %5d %5d",
e3bd5504 1562 vol[0], vol[1], vol[2] ,vol[4], vol[3],
1563 digitInteresting->GetTdc(), digitInteresting->GetAdc(),
1564 digitInteresting->GetToT(), digitInteresting->GetToT()*digitInteresting->GetToT(),
1565 digitsInVolumeIndices[digIndex],
1566 digitInteresting->GetTrack(0), digitInteresting->GetTrack(1), digitInteresting->GetTrack(2)));
1567
e885fb81 1568 selectedDigit[interestingCounter][digitIndexLocal] = new // AdC
e3bd5504 1569 AliTOFselectedDigit(vol, digitInteresting->GetTdc(),
1570 digitInteresting->GetAdc(), digitInteresting->GetToT(),
1571 digitInteresting->GetToT()*digitInteresting->GetToT(),
1572 digitsInVolumeIndices[digIndex],
1573 digitInteresting->GetTracks());
1574 }
e885fb81 1575 if (digitIndexLocal==-1) interestingCounter--; // AdC
e3bd5504 1576 }
1577
1578
1579 vol[4] = AliTOFGeometry::NpadZ()-(iPadZ+1), vol[3] = iPadX+1;
1580
1581 if (fTOFdigitMap->GetNumberOfDigits(vol)>0) {
1582 interestingCounter++;
1583 for (ii=0; ii<kMaxNumberOfDigitsPerVolume; ii++)
1584 digitsInVolumeIndices[ii] = -1;
1585 fTOFdigitMap->GetDigitIndex(vol, digitsInVolumeIndices);
e885fb81 1586 digitIndexLocal=-1; // AdC
e3bd5504 1587 for(Int_t digIndex=0; digIndex<kMaxNumberOfDigitsPerVolume; digIndex++) {
1588 if (digitsInVolumeIndices[digIndex]<0) continue;
1589 digitInteresting = (AliTOFdigit*)fDigits->UncheckedAt(digitsInVolumeIndices[digIndex]);
e885fb81 1590 if (digitInteresting->GetToT()<=0) continue; // AdC
1591 digitIndexLocal++; // AdC
e3bd5504 1592
e885fb81 1593 AliDebug(1,Form(" %2d %1d %2d %1d %2d %f %f %f %f %5d %5d %5d %5d",
e3bd5504 1594 vol[0], vol[1], vol[2] ,vol[4], vol[3],
1595 digitInteresting->GetTdc(), digitInteresting->GetAdc(),
1596 digitInteresting->GetToT(), digitInteresting->GetToT()*digitInteresting->GetToT(),
1597 digitsInVolumeIndices[digIndex],
1598 digitInteresting->GetTrack(0), digitInteresting->GetTrack(1), digitInteresting->GetTrack(2)));
1599
e885fb81 1600 selectedDigit[interestingCounter][digitIndexLocal] = new // AdC
e3bd5504 1601 AliTOFselectedDigit(vol, digitInteresting->GetTdc(),
1602 digitInteresting->GetAdc(), digitInteresting->GetToT(),
1603 digitInteresting->GetToT()*digitInteresting->GetToT(),
1604 digitsInVolumeIndices[digIndex],
1605 digitInteresting->GetTracks());
1606 }
e885fb81 1607 if (digitIndexLocal==-1) interestingCounter--; // AdC
e3bd5504 1608 }
1609
e885fb81 1610 AliDebug(1,Form(" e adesso %1d", interestingCounter+1));
e3bd5504 1611
1612 for (Int_t adesso1=0; adesso1<interestingCounter+1; adesso1++) {
1613 for (Int_t firstIndex=0; firstIndex<kMaxNumberOfDigitsPerVolume; firstIndex++) {
1614 if (selectedDigit[adesso1][firstIndex]==0x0) continue;
1615
1616 for (Int_t adesso2=adesso1+1; adesso2<interestingCounter+1; adesso2++) {
1617 for (Int_t secondIndex=0; secondIndex<kMaxNumberOfDigitsPerVolume; secondIndex++) {
1618 if (selectedDigit[adesso2][secondIndex]==0x0) continue;
1619
1620 if (TMath::Abs(selectedDigit[adesso1][firstIndex]->GetTDC()-selectedDigit[adesso2][secondIndex]->GetTDC())>fMaxDeltaTime) continue;
1621
1622 interestingTOF[0] = selectedDigit[adesso1][firstIndex]->GetTDC();
1623 interestingTOT[0] = selectedDigit[adesso1][firstIndex]->GetTOT();
1624 interestingADC[0] = selectedDigit[adesso1][firstIndex]->GetADC();
1625 interestingWeight[0] = selectedDigit[adesso1][firstIndex]->GetWeight();
1626 Int_t vol1[5]; for(jj=0; jj<5; jj++) vol1[jj] = selectedDigit[adesso1][firstIndex]->GetDetectorIndex(jj);
e885fb81 1627 AliDebug(1,Form(" %2d %1d %2d %1d %2d", vol1[0], vol1[1], vol1[2], vol1[4], vol1[3]));
e3bd5504 1628 Int_t volDum = vol1[3];
1629 vol1[3] = vol1[4];
1630 vol1[4] = volDum;
e885fb81 1631 fTOFGeometry->GetPosPar(vol1,pos);
e3bd5504 1632 interestingX[0] = pos[0];
1633 interestingY[0] = pos[1];
1634 interestingZ[0] = pos[2];
1635
1636 interestingTOF[1] = selectedDigit[adesso2][secondIndex]->GetTDC();
1637 interestingTOT[1] = selectedDigit[adesso2][secondIndex]->GetTOT();
1638 interestingADC[1] = selectedDigit[adesso2][secondIndex]->GetADC();
1639 interestingWeight[1] = selectedDigit[adesso2][secondIndex]->GetWeight();
1640 Int_t vol2[5]; for(jj=0; jj<5; jj++) vol2[jj] = selectedDigit[adesso2][secondIndex]->GetDetectorIndex(jj);
e885fb81 1641 AliDebug(1,Form(" %2d %1d %2d %1d %2d", vol2[0], vol2[1], vol2[2], vol2[4], vol2[3]));
e3bd5504 1642 volDum = vol2[3];
1643 vol2[3] = vol2[4];
1644 vol2[4] = volDum;
e885fb81 1645 fTOFGeometry->GetPosPar(vol2,pos);
e3bd5504 1646 interestingX[1] = pos[0];
1647 interestingY[1] = pos[1];
1648 interestingZ[1] = pos[2];
1649
1650 AverageCalculations(2, interestingX, interestingY, interestingZ,
1651 interestingTOF, interestingTOT, interestingADC,
1652 interestingWeight,
1653 parTOF, posClus, check);
1654
1655 for (jj=0; jj<5; jj++) det[jj] = -1;
1656 for (jj=0; jj<3; jj++) posF[jj] = posClus[jj];
e885fb81 1657 fTOFGeometry->GetDetID(posF, det);
e3bd5504 1658
e885fb81 1659 volIdClus = fTOFGeometry->GetAliSensVolIndex(det[0],det[1],det[2]);
1660 //volIdClus = GetClusterVolIndex(det);
e3bd5504 1661
1662 for (jj=3; jj<11; jj++) padsCluster[jj] = -1;
1663 padsCluster[3] = selectedDigit[adesso1][firstIndex]->GetDetectorIndex(4);
1664 padsCluster[4] = selectedDigit[adesso1][firstIndex]->GetDetectorIndex(3);
1665 padsCluster[5] = selectedDigit[adesso2][secondIndex]->GetDetectorIndex(4);
1666 padsCluster[6] = selectedDigit[adesso2][secondIndex]->GetDetectorIndex(3);
1667
1668 for (jj=0; jj<6; jj++) covClus[jj] = 0.;
1669 Int_t ** indDet = new Int_t*[2];
1670 for (jj=0; jj<2; jj++) indDet[jj] = new Int_t [5];
1671 for (jj=0; jj<2; jj++) indDet[jj][0] = nSector;
1672 for (jj=0; jj<2; jj++) indDet[jj][1] = nPlate;
1673 for (jj=0; jj<2; jj++) indDet[jj][2] = nStrip;
1674 for (jj=0; jj<2; jj++) indDet[jj][3] = padsCluster[2*jj+3];
1675 for (jj=0; jj<2; jj++) indDet[jj][4] = padsCluster[2*jj+1+3];
e885fb81 1676 GetClusterPars(/*check,*/ 2, indDet, interestingWeight, posClus, covClus);
e3bd5504 1677 for (jj=0; jj<2; jj++) delete [] indDet[jj];
1678
1679 // To fill the track index array
1680 dummyCounter=-1;
1681 for (jj=0; jj<kMaxNumberOfTracksPerDigit; jj++) tracks[jj] = -1;
1682 for (Int_t kk=0; kk<kMaxNumberOfTracksPerDigit; kk++) { // three is the max number of tracks associated to one digit
1683 if (selectedDigit[adesso1][firstIndex]->GetTrackLabel(kk)==-1) continue;
1684 else {
1685 dummyCounter++;
1686 tracks[dummyCounter] = selectedDigit[adesso1][firstIndex]->GetTrackLabel(kk);
1687 }
1688 }
1689 for (Int_t kk=0; kk<kMaxNumberOfTracksPerDigit; kk++) { // three is the max number of tracks associated to one digit
1690 if (selectedDigit[adesso2][secondIndex]->GetTrackLabel(kk)==-1) continue;
1691 else {
1692
1693 alreadyStored = kFALSE;
1694 for (jj=0; jj<dummyCounter+1; jj++)
1695 alreadyStored = alreadyStored || (tracks[jj]!=-1 && tracks[jj]==selectedDigit[adesso2][secondIndex]->GetTrackLabel(kk));
1696
1697 if (alreadyStored) continue;
1698 if (dummyCounter==2) { // three is the max number of tracks associated to one cluster
1699 AliWarning(" Siamo al limite!");
1700 continue;
1701 }
1702
1703 dummyCounter++;
1704 tracks[dummyCounter] = selectedDigit[adesso2][secondIndex]->GetTrackLabel(kk);
1705
1706 }
1707
1708 }
1709
1710
1711 AliTOFcluster *tofCluster =
1712 new AliTOFcluster(volIdClus, posClus[0], posClus[1], posClus[2],
1713 covClus[0], covClus[1], covClus[2], covClus[3], covClus[4], covClus[5],
1714 tracks, det, parTOF, status, selectedDigit[adesso1][firstIndex]->GetIndex()); // to be updated
1715 InsertCluster(tofCluster);
1716
e885fb81 1717 AliDebug(2, Form(" %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",
e3bd5504 1718 volIdClus, posClus[0], posClus[1], posClus[2],
1719 covClus[0], covClus[1], covClus[2], covClus[3], covClus[4], covClus[5],
1720 tracks[0], tracks[1], tracks[2],
1721 det[0], det[1], det[2], det[3], det[4],
1722 parTOF[0], parTOF[1], parTOF[2], parTOF[3], parTOF[4],
1723 status, selectedDigit[adesso1][firstIndex]->GetIndex()));
1724
1725 volDum = vol1[3];
1726 vol1[3] = vol1[4];
1727 vol1[4] = volDum;
1728 fTOFdigitMap->ResetDigitNumber(vol1,selectedDigit[adesso1][firstIndex]->GetIndex());
1729 volDum = vol2[3];
1730 vol2[3] = vol2[4];
1731 vol2[4] = volDum;
1732 fTOFdigitMap->ResetDigitNumber(vol2,selectedDigit[adesso2][secondIndex]->GetIndex());
1733
1734
1735 } // close loop on second digit
1736 } // close loop on adesso2
1737
1738 } // close loop on first digit
1739 } // close loop on adesso1
1740
1741 for (ii=0; ii<kMaxNumberOfInterestingPads; ii++)
1742 for (jj=0; jj<kMaxNumberOfDigitsPerVolume; jj++)
1743 selectedDigit[ii][jj] = 0x0;
1744
1745 } // loop on iPad
1746
1747 for (ii=0; ii<kMaxNumberOfInterestingPads; ii++)
1748 for (jj=0; jj<kMaxNumberOfDigitsPerVolume; jj++) {
1749 delete selectedDigit[ii][jj];
1750 selectedDigit[ii][jj] = 0x0;
1751 }
1752
1753
1754}
1755//_____________________________________________________________________________
1756
1757void AliTOFClusterFinderV1::FindClusters24(Int_t nSector,
1758 Int_t nPlate,
1759 Int_t nStrip)
1760{
1761 //
1762 // This function searches the neighbouring digits (stored in the fDigits object),
1763 // to perform clusters (stored in the fTofClusters array).
1764 //
1765 // This research has been made by checking the fTOFdigitMap object,
1766 // filled at digits/raw-data reading time.
1767 //
1768
1769 const Int_t kMaxNumberOfInterestingPads = 4;
1770 const Int_t kMaxNumberOfTracksPerDigit = 3;
1771 const Int_t kMaxNumberOfDigitsPerVolume = 3;
1772
1773 Int_t ii = 0;
1774
1775 Int_t digitsInVolumeIndices[kMaxNumberOfDigitsPerVolume];
1776 for (ii=0; ii<kMaxNumberOfDigitsPerVolume; ii++)
1777 digitsInVolumeIndices[ii] = -1;
1778
e3bd5504 1779 Int_t vol[5] = {nSector,nPlate,nStrip,-1,-1};
1780
1781 Float_t pos[3] = {0.,0.,0.};
1782
1783 Int_t jj = 0;
1784 Int_t interestingPadX[kMaxNumberOfInterestingPads];
1785 for (jj=0; jj<kMaxNumberOfInterestingPads; jj++) interestingPadX[jj] = -1;
1786 Int_t interestingPadZ[kMaxNumberOfInterestingPads];
1787 for (jj=0; jj<kMaxNumberOfInterestingPads; jj++) interestingPadZ[jj] = -1;
1788 Double_t interestingTOT[kMaxNumberOfInterestingPads];
1789 for (jj=0; jj<kMaxNumberOfInterestingPads; jj++) interestingTOT[jj] = 0;
1790 Double_t interestingADC[kMaxNumberOfInterestingPads];
1791 for (jj=0; jj<kMaxNumberOfInterestingPads; jj++) interestingADC[jj] = 0;
1792 Double_t interestingTOF[kMaxNumberOfInterestingPads];
1793 for (jj=0; jj<kMaxNumberOfInterestingPads; jj++) interestingTOF[jj] = 0;
1794 Double_t interestingWeight[kMaxNumberOfInterestingPads];
1795 for (jj=0; jj<kMaxNumberOfInterestingPads; jj++) interestingWeight[jj] = 0;
1796
1797 Float_t interestingX[kMaxNumberOfInterestingPads];
1798 for (jj=0; jj<kMaxNumberOfInterestingPads; jj++) interestingX[jj] = 0;
1799 Float_t interestingY[kMaxNumberOfInterestingPads];
1800 for (jj=0; jj<kMaxNumberOfInterestingPads; jj++) interestingY[jj] = 0;
1801 Float_t interestingZ[kMaxNumberOfInterestingPads];
1802 for (jj=0; jj<kMaxNumberOfInterestingPads; jj++) interestingZ[jj] = 0;
1803
1804 Float_t interDigit[kMaxNumberOfInterestingPads];
1805 for (jj=0; jj<kMaxNumberOfInterestingPads; jj++) interDigit[jj] = 0;
1806
1807 Int_t padsCluster[11];
1808 padsCluster[0] = nSector;
1809 padsCluster[1] = nPlate;
1810 padsCluster[2] = nStrip;
1811 for (jj=3; jj<11; jj++) padsCluster[jj] = -1;
1812
1813 Int_t interestingCounter=-1;
e885fb81 1814 Int_t digitIndexLocal = -1;
e3bd5504 1815 Int_t iPad = -1;
1816 Int_t iPadX = -1;
1817 Int_t iPadZ = -1;
1818
1819 Bool_t check = kFALSE;
1820 Int_t parTOF[5];
1821 for (jj=0; jj<5; jj++) parTOF[jj] = 0;
1822 Double_t posClus[3];
1823 for (jj=0; jj<3; jj++) posClus[jj] = 0.;
1824 Int_t det[5];
1825 for (jj=0; jj<5; jj++) det[jj] = -1;
1826 Float_t posF[3];
1827 for (jj=0; jj<3; jj++) posF[jj] = 0.;
1828 UShort_t volIdClus = 0;
1829 Bool_t status = kTRUE; //assume all sim channels ok in the beginning...
1830 Double_t covClus[6];
1831 for (jj=0; jj<6; jj++) covClus[jj] = 0.;
1832 Int_t tracks[kMaxNumberOfTracksPerDigit];
1833 for (jj=0; jj<3; jj++) tracks[jj] = -1;
1834 Int_t dummyCounter=-1;
1835 Bool_t alreadyStored = kFALSE;
1836
1837 AliTOFselectedDigit ***selectedDigit = new AliTOFselectedDigit**[kMaxNumberOfInterestingPads];
1838 for (ii=0; ii<kMaxNumberOfInterestingPads; ii++)
1839 selectedDigit[ii] = new AliTOFselectedDigit*[kMaxNumberOfDigitsPerVolume];
1840
1841 for (ii=0; ii<kMaxNumberOfInterestingPads; ii++)
1842 for (jj=0; jj<kMaxNumberOfDigitsPerVolume; jj++) selectedDigit[ii][jj] = 0x0;
1843
1844 AliTOFdigit *digitInteresting;
1845
1846 for (iPad=0; iPad<AliTOFGeometry::NpadZ()*AliTOFGeometry::NpadX()-3; iPad+=2) {
1847
1848 iPadZ = iPad%AliTOFGeometry::NpadZ(); //iPad%2;
1849 iPadX = iPad/AliTOFGeometry::NpadZ(); //iPad/2;
1850
e885fb81 1851 AliDebug(3, Form("%2d %1d %2d\n", iPad, iPadZ, iPadX));
e3bd5504 1852
1853
1854
1855
1856
1857
1858 interestingCounter=-1;
1859
1860 vol[4] = iPadZ , vol[3] = iPadX;
1861 if (fTOFdigitMap->GetNumberOfDigits(vol)>0)
1862 interestingCounter++;
1863
1864 vol[4] = iPadZ, vol[3] = iPadX+1;
1865 if (fTOFdigitMap->GetNumberOfDigits(vol)>0)
1866 interestingCounter++;
1867
1868 vol[4] = AliTOFGeometry::NpadZ()-(iPadZ+1), vol[3] = iPadX;
1869 if (fTOFdigitMap->GetNumberOfDigits(vol)>0)
1870 interestingCounter++;
1871
1872 vol[4] = AliTOFGeometry::NpadZ()-(iPadZ+1), vol[3] = iPadX+1;
1873 if (fTOFdigitMap->GetNumberOfDigits(vol)>0)
1874 interestingCounter++;
1875
1876 if (interestingCounter+1!=4) continue; // the hit pads have to be 4
1877 else interestingCounter=-1;
1878
1879
1880 for (ii=0; ii<kMaxNumberOfInterestingPads; ii++)
1881 for (jj=0; jj<kMaxNumberOfDigitsPerVolume; jj++)
1882 selectedDigit[ii][jj] = 0x0;
1883
1884
1885 vol[4] = iPadZ, vol[3] = iPadX;
1886
1887 if (fTOFdigitMap->GetNumberOfDigits(vol)>0) {
1888 interestingCounter++;
1889 for (ii=0; ii<kMaxNumberOfDigitsPerVolume; ii++)
1890 digitsInVolumeIndices[ii] = -1;
1891 fTOFdigitMap->GetDigitIndex(vol, digitsInVolumeIndices);
e885fb81 1892 digitIndexLocal=-1; // AdC
e3bd5504 1893 for(Int_t digIndex=0; digIndex<kMaxNumberOfDigitsPerVolume; digIndex++) {
1894 if (digitsInVolumeIndices[digIndex]<0) continue;
1895 digitInteresting = (AliTOFdigit*)fDigits->UncheckedAt(digitsInVolumeIndices[digIndex]);
e885fb81 1896 if (digitInteresting->GetToT()<=0) continue; // AdC
1897 digitIndexLocal++; // AdC
e3bd5504 1898
e885fb81 1899 AliDebug(1,Form(" %2d %1d %2d %1d %2d %f %f %f %f %5d %5d %5d %5d",
e3bd5504 1900 vol[0], vol[1], vol[2] ,vol[4], vol[3],
1901 digitInteresting->GetTdc(), digitInteresting->GetAdc(),
1902 digitInteresting->GetToT(), digitInteresting->GetToT()*digitInteresting->GetToT(),
1903 digitsInVolumeIndices[digIndex],
1904 digitInteresting->GetTrack(0), digitInteresting->GetTrack(1), digitInteresting->GetTrack(2)));
1905
e885fb81 1906 selectedDigit[interestingCounter][digitIndexLocal] = new // AdC
e3bd5504 1907 AliTOFselectedDigit(vol, digitInteresting->GetTdc(),
1908 digitInteresting->GetAdc(), digitInteresting->GetToT(),
1909 digitInteresting->GetToT()*digitInteresting->GetToT(),
1910 digitsInVolumeIndices[digIndex],
1911 digitInteresting->GetTracks());
1912 }
e885fb81 1913 if (digitIndexLocal==-1) interestingCounter--; // AdC
e3bd5504 1914 }
1915
1916
1917 vol[4] = iPadZ, vol[3] = iPadX+1;
1918
1919 if (fTOFdigitMap->GetNumberOfDigits(vol)>0) {
1920 interestingCounter++;
1921 for (ii=0; ii<kMaxNumberOfDigitsPerVolume; ii++)
1922 digitsInVolumeIndices[ii] = -1;
1923 fTOFdigitMap->GetDigitIndex(vol, digitsInVolumeIndices);
e885fb81 1924 digitIndexLocal=-1; // AdC
e3bd5504 1925 for(Int_t digIndex=0; digIndex<kMaxNumberOfDigitsPerVolume; digIndex++) {
1926 if (digitsInVolumeIndices[digIndex]<0) continue;
1927 digitInteresting = (AliTOFdigit*)fDigits->UncheckedAt(digitsInVolumeIndices[digIndex]);
e885fb81 1928 if (digitInteresting->GetToT()<=0) continue; // AdC
1929 digitIndexLocal++; // AdC
e3bd5504 1930
e885fb81 1931 AliDebug(1,Form(" %2d %1d %2d %1d %2d %f %f %f %f %5d %5d %5d %5d",
e3bd5504 1932 vol[0], vol[1], vol[2] ,vol[4], vol[3],
1933 digitInteresting->GetTdc(), digitInteresting->GetAdc(),
1934 digitInteresting->GetToT(), digitInteresting->GetToT()*digitInteresting->GetToT(),
1935 digitsInVolumeIndices[digIndex],
1936 digitInteresting->GetTrack(0), digitInteresting->GetTrack(1), digitInteresting->GetTrack(2)));
1937
e885fb81 1938 selectedDigit[interestingCounter][digitIndexLocal] = new // AdC
e3bd5504 1939 AliTOFselectedDigit(vol, digitInteresting->GetTdc(),
1940 digitInteresting->GetAdc(), digitInteresting->GetToT(),
1941 digitInteresting->GetToT()*digitInteresting->GetToT(),
1942 digitsInVolumeIndices[digIndex],
1943 digitInteresting->GetTracks());
1944 }
e885fb81 1945 if (digitIndexLocal==-1) interestingCounter--; // AdC
e3bd5504 1946 }
1947
1948
1949 vol[4] = AliTOFGeometry::NpadZ()-(iPadZ+1), vol[3] = iPadX;
1950
1951 if (fTOFdigitMap->GetNumberOfDigits(vol)>0) {
1952 interestingCounter++;
1953 for (ii=0; ii<kMaxNumberOfDigitsPerVolume; ii++)
1954 digitsInVolumeIndices[ii] = -1;
1955 fTOFdigitMap->GetDigitIndex(vol, digitsInVolumeIndices);
e885fb81 1956 digitIndexLocal=-1; // AdC
e3bd5504 1957 for(Int_t digIndex=0; digIndex<kMaxNumberOfDigitsPerVolume; digIndex++) {
1958 if (digitsInVolumeIndices[digIndex]<0) continue;
1959 digitInteresting = (AliTOFdigit*)fDigits->UncheckedAt(digitsInVolumeIndices[digIndex]);
e885fb81 1960 if (digitInteresting->GetToT()<=0) continue; // AdC
1961 digitIndexLocal++; // AdC
e3bd5504 1962
e885fb81 1963 AliDebug(1,Form(" %2d %1d %2d %1d %2d %f %f %f %f %5d %5d %5d %5d",
e3bd5504 1964 vol[0], vol[1], vol[2] ,vol[4], vol[3],
1965 digitInteresting->GetTdc(), digitInteresting->GetAdc(),
1966 digitInteresting->GetToT(), digitInteresting->GetToT()*digitInteresting->GetToT(),
1967 digitsInVolumeIndices[digIndex],
1968 digitInteresting->GetTrack(0), digitInteresting->GetTrack(1), digitInteresting->GetTrack(2)));
1969
e885fb81 1970 selectedDigit[interestingCounter][digitIndexLocal] = new // AdC
e3bd5504 1971 AliTOFselectedDigit(vol, digitInteresting->GetTdc(),
1972 digitInteresting->GetAdc(), digitInteresting->GetToT(),
1973 digitInteresting->GetToT()*digitInteresting->GetToT(),
1974 digitsInVolumeIndices[digIndex],
1975 digitInteresting->GetTracks());
1976 }
e885fb81 1977 if (digitIndexLocal==-1) interestingCounter--; // AdC
e3bd5504 1978 }
1979
1980
1981 vol[4] = AliTOFGeometry::NpadZ()-(iPadZ+1), vol[3] = iPadX+1;
1982
1983 if (fTOFdigitMap->GetNumberOfDigits(vol)>0) {
1984 interestingCounter++;
1985 for (ii=0; ii<kMaxNumberOfDigitsPerVolume; ii++)
1986 digitsInVolumeIndices[ii] = -1;
1987 fTOFdigitMap->GetDigitIndex(vol, digitsInVolumeIndices);
e885fb81 1988 digitIndexLocal=-1; // AdC
e3bd5504 1989 for(Int_t digIndex=0; digIndex<kMaxNumberOfDigitsPerVolume; digIndex++) {
1990 if (digitsInVolumeIndices[digIndex]<0) continue;
1991 digitInteresting = (AliTOFdigit*)fDigits->UncheckedAt(digitsInVolumeIndices[digIndex]);
e885fb81 1992 if (digitInteresting->GetToT()<=0) continue; // AdC
1993 digitIndexLocal++; // AdC
e3bd5504 1994
e885fb81 1995 AliDebug(1,Form(" %2d %1d %2d %1d %2d %f %f %f %f %5d %5d %5d %5d",
e3bd5504 1996 vol[0], vol[1], vol[2] ,vol[4], vol[3],
1997 digitInteresting->GetTdc(), digitInteresting->GetAdc(),
1998 digitInteresting->GetToT(), digitInteresting->GetToT()*digitInteresting->GetToT(),
1999 digitsInVolumeIndices[digIndex],
2000 digitInteresting->GetTrack(0), digitInteresting->GetTrack(1), digitInteresting->GetTrack(2)));
2001
e885fb81 2002 selectedDigit[interestingCounter][digitIndexLocal] = new // AdC
e3bd5504 2003 AliTOFselectedDigit(vol, digitInteresting->GetTdc(),
2004 digitInteresting->GetAdc(), digitInteresting->GetToT(),
2005 digitInteresting->GetToT()*digitInteresting->GetToT(),
2006 digitsInVolumeIndices[digIndex],
2007 digitInteresting->GetTracks());
2008 }
e885fb81 2009 if (digitIndexLocal==-1) interestingCounter--; // AdC
e3bd5504 2010 }
2011
e885fb81 2012 AliDebug(1,Form(" e adesso %1d", interestingCounter+1));
e3bd5504 2013
2014 for (Int_t adesso1=0; adesso1<interestingCounter+1; adesso1++) {
2015 for (Int_t firstIndex=0; firstIndex<kMaxNumberOfDigitsPerVolume; firstIndex++) {
2016 if (selectedDigit[adesso1][firstIndex]==0x0) continue;
2017
2018 for (Int_t adesso2=adesso1+1; adesso2<interestingCounter+1; adesso2++) {
2019 for (Int_t secondIndex=0; secondIndex<kMaxNumberOfDigitsPerVolume; secondIndex++) {
2020 if (selectedDigit[adesso2][secondIndex]==0x0) continue;
2021
2022 if (TMath::Abs(selectedDigit[adesso1][firstIndex]->GetTDC()-selectedDigit[adesso2][secondIndex]->GetTDC())>fMaxDeltaTime) continue;
2023
2024 interestingTOF[0] = selectedDigit[adesso1][firstIndex]->GetTDC();
2025 interestingTOT[0] = selectedDigit[adesso1][firstIndex]->GetTOT();
2026 interestingADC[0] = selectedDigit[adesso1][firstIndex]->GetADC();
2027 interestingWeight[0] = selectedDigit[adesso1][firstIndex]->GetWeight();
2028 Int_t vol1[5]; for(jj=0; jj<5; jj++) vol1[jj] = selectedDigit[adesso1][firstIndex]->GetDetectorIndex(jj);
e885fb81 2029 AliDebug(1,Form(" %2d %1d %2d %1d %2d", vol1[0], vol1[1], vol1[2], vol1[4], vol1[3]));
e3bd5504 2030 Int_t volDum = vol1[3];
2031 vol1[3] = vol1[4];
2032 vol1[4] = volDum;
e885fb81 2033 fTOFGeometry->GetPosPar(vol1,pos);
e3bd5504 2034 interestingX[0] = pos[0];
2035 interestingY[0] = pos[1];
2036 interestingZ[0] = pos[2];
2037
2038 interestingTOF[1] = selectedDigit[adesso2][secondIndex]->GetTDC();
2039 interestingTOT[1] = selectedDigit[adesso2][secondIndex]->GetTOT();
2040 interestingADC[1] = selectedDigit[adesso2][secondIndex]->GetADC();
2041 interestingWeight[1] = selectedDigit[adesso2][secondIndex]->GetWeight();
2042 Int_t vol2[5]; for(jj=0; jj<5; jj++) vol2[jj] = selectedDigit[adesso2][secondIndex]->GetDetectorIndex(jj);
e885fb81 2043 AliDebug(1,Form(" %2d %1d %2d %1d %2d", vol2[0], vol2[1], vol2[2], vol2[4], vol2[3]));
e3bd5504 2044 volDum = vol2[3];
2045 vol2[3] = vol2[4];
2046 vol2[4] = volDum;
e885fb81 2047 fTOFGeometry->GetPosPar(vol2,pos);
e3bd5504 2048 interestingX[1] = pos[0];
2049 interestingY[1] = pos[1];
2050 interestingZ[1] = pos[2];
2051
2052
2053 AverageCalculations(2, interestingX, interestingY, interestingZ,
2054 interestingTOF, interestingTOT, interestingADC,
2055 interestingWeight,
2056 parTOF, posClus, check);
2057
2058 for (jj=0; jj<5; jj++) det[jj] = -1;
2059 for (jj=0; jj<3; jj++) posF[jj] = posClus[jj];
e885fb81 2060 fTOFGeometry->GetDetID(posF, det);
e3bd5504 2061
e885fb81 2062 volIdClus = fTOFGeometry->GetAliSensVolIndex(det[0],det[1],det[2]);
2063 //volIdClus = GetClusterVolIndex(det);
e3bd5504 2064
2065 for (jj=3; jj<11; jj++) padsCluster[jj] = -1;
2066 padsCluster[3] = selectedDigit[adesso1][firstIndex]->GetDetectorIndex(4);
2067 padsCluster[4] = selectedDigit[adesso1][firstIndex]->GetDetectorIndex(3);
2068 padsCluster[5] = selectedDigit[adesso2][secondIndex]->GetDetectorIndex(4);
2069 padsCluster[6] = selectedDigit[adesso2][secondIndex]->GetDetectorIndex(3);
2070
2071 for (jj=0; jj<6; jj++) covClus[jj] = 0.;
2072 Int_t ** indDet = new Int_t*[2];
2073 for (jj=0; jj<2; jj++) indDet[jj] = new Int_t [5];
2074 for (jj=0; jj<2; jj++) indDet[jj][0] = nSector;
2075 for (jj=0; jj<2; jj++) indDet[jj][1] = nPlate;
2076 for (jj=0; jj<2; jj++) indDet[jj][2] = nStrip;
2077 for (jj=0; jj<2; jj++) indDet[jj][3] = padsCluster[2*jj+3];
2078 for (jj=0; jj<2; jj++) indDet[jj][4] = padsCluster[2*jj+1+3];
e885fb81 2079 GetClusterPars(/*check,*/ 2, indDet, interestingWeight, posClus, covClus);
e3bd5504 2080 for (jj=0; jj<2; jj++) delete [] indDet[jj];
2081
2082 // To fill the track index array
2083 dummyCounter=-1;
2084 for (jj=0; jj<kMaxNumberOfTracksPerDigit; jj++) tracks[jj] = -1;
2085 for (Int_t kk=0; kk<kMaxNumberOfTracksPerDigit; kk++) { // three is the max number of tracks associated to one digit
2086 if (selectedDigit[adesso1][firstIndex]->GetTrackLabel(kk)==-1) continue;
2087 else {
2088 dummyCounter++;
2089 tracks[dummyCounter] = selectedDigit[adesso1][firstIndex]->GetTrackLabel(kk);
2090 }
2091 }
2092 for (Int_t kk=0; kk<kMaxNumberOfTracksPerDigit; kk++) { // three is the max number of tracks associated to one digit
2093 if (selectedDigit[adesso2][secondIndex]->GetTrackLabel(kk)==-1) continue;
2094 else {
2095
2096 alreadyStored = kFALSE;
2097 for (jj=0; jj<dummyCounter+1; jj++)
2098 alreadyStored = alreadyStored || (tracks[jj]!=-1 && tracks[jj]==selectedDigit[adesso2][secondIndex]->GetTrackLabel(kk));
2099
2100 if (alreadyStored) continue;
2101 if (dummyCounter==2) { // three is the max number of tracks associated to one cluster
2102 AliWarning(" Siamo al limite!");
2103 continue;
2104 }
2105
2106 dummyCounter++;
2107 tracks[dummyCounter] = selectedDigit[adesso2][secondIndex]->GetTrackLabel(kk);
2108
2109 }
2110
2111 }
2112
2113
2114 AliTOFcluster *tofCluster =
2115 new AliTOFcluster(volIdClus, posClus[0], posClus[1], posClus[2],
2116 covClus[0], covClus[1], covClus[2], covClus[3], covClus[4], covClus[5],
2117 tracks, det, parTOF, status, selectedDigit[adesso1][firstIndex]->GetIndex()); // to be updated
2118 InsertCluster(tofCluster);
2119
e885fb81 2120 AliDebug(2, Form(" %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",
e3bd5504 2121 volIdClus, posClus[0], posClus[1], posClus[2],
2122 covClus[0], covClus[1], covClus[2], covClus[3], covClus[4], covClus[5],
2123 tracks[0], tracks[1], tracks[2],
2124 det[0], det[1], det[2], det[3], det[4],
2125 parTOF[0], parTOF[1], parTOF[2], parTOF[3], parTOF[4],
2126 status, selectedDigit[adesso1][firstIndex]->GetIndex()));
2127
2128 volDum = vol1[3];
2129 vol1[3] = vol1[4];
2130 vol1[4] = volDum;
2131 fTOFdigitMap->ResetDigitNumber(vol1,selectedDigit[adesso1][firstIndex]->GetIndex());
2132 volDum = vol2[3];
2133 vol2[3] = vol2[4];
2134 vol2[4] = volDum;
2135 fTOFdigitMap->ResetDigitNumber(vol2,selectedDigit[adesso2][secondIndex]->GetIndex());
2136
2137
2138 } // close loop on second digit
2139 } // close loop on adesso2
2140
2141 } // close loop on first digit
2142 } // close loop on adesso1
2143
2144 for (ii=0; ii<kMaxNumberOfInterestingPads; ii++)
2145 for (jj=0; jj<kMaxNumberOfDigitsPerVolume; jj++)
2146 selectedDigit[ii][jj] = 0x0;
2147
2148 } // loop on iPad
2149
2150 for (ii=0; ii<kMaxNumberOfInterestingPads; ii++)
2151 for (jj=0; jj<kMaxNumberOfDigitsPerVolume; jj++) {
2152 delete selectedDigit[ii][jj];
2153 selectedDigit[ii][jj] = 0x0;
2154 }
2155
2156
2157}
2158//_____________________________________________________________________________
2159
2160void AliTOFClusterFinderV1::FindClustersPerStrip(Int_t nSector,
2161 Int_t nPlate,
2162 Int_t nStrip,
2163 Int_t group)
2164{
2165 //
2166 // This function searches the neighbouring digits (stored in the fDigits object),
2167 // to perform clusters (stored in the fTofClusters array).
2168 //
2169 // Each strip is read four times:
2170 // - 1st time: it searches possible clusters formed by four
2171 // neighbouring digits;
2172 // - 2nd time: it searches possible clusters formed by three
2173 // neighbouring digits;
2174 // - 3rd time: it searches possible clusters formed by two
2175 // neighbouring digits;
2176 // - 4th time: the remaining isolated digits have been transformed
2177 // in clusters.
2178 // This research has been made by checking the fTOFdigitMap object,
2179 // filled at digits/raw-data reading time.
2180 //
2181
2182 const Int_t kMaxNumberOfInterestingPads = 4;
2183 const Int_t kMaxNumberOfTracksPerDigit = 3;
2184 const Int_t kMaxNumberOfDigitsPerVolume = 3;
2185
2186 Int_t ii = 0;
2187
2188 Int_t digitsInVolumeIndices[kMaxNumberOfDigitsPerVolume];
2189 for (ii=0; ii<kMaxNumberOfDigitsPerVolume; ii++)
2190 digitsInVolumeIndices[ii] = -1;
2191
e3bd5504 2192 Int_t vol[5] = {nSector,nPlate,nStrip,-1,-1};
2193
2194 Float_t pos[3] = {0.,0.,0.};
2195
2196 Int_t jj = 0;
2197 Int_t interestingPadX[kMaxNumberOfInterestingPads];
2198 for (jj=0; jj<kMaxNumberOfInterestingPads; jj++) interestingPadX[jj] = -1;
2199 Int_t interestingPadZ[kMaxNumberOfInterestingPads];
2200 for (jj=0; jj<kMaxNumberOfInterestingPads; jj++) interestingPadZ[jj] = -1;
2201 Double_t interestingTOT[kMaxNumberOfInterestingPads];
2202 for (jj=0; jj<kMaxNumberOfInterestingPads; jj++) interestingTOT[jj] = 0;
2203 Double_t interestingADC[kMaxNumberOfInterestingPads];
2204 for (jj=0; jj<kMaxNumberOfInterestingPads; jj++) interestingADC[jj] = 0;
2205 Double_t interestingTOF[kMaxNumberOfInterestingPads];
2206 for (jj=0; jj<kMaxNumberOfInterestingPads; jj++) interestingTOF[jj] = 0;
2207 Double_t interestingWeight[kMaxNumberOfInterestingPads];
2208 for (jj=0; jj<kMaxNumberOfInterestingPads; jj++) interestingWeight[jj] = 0;
2209
2210 Float_t interestingX[kMaxNumberOfInterestingPads];
2211 for (jj=0; jj<kMaxNumberOfInterestingPads; jj++) interestingX[jj] = 0;
2212 Float_t interestingY[kMaxNumberOfInterestingPads];
2213 for (jj=0; jj<kMaxNumberOfInterestingPads; jj++) interestingY[jj] = 0;
2214 Float_t interestingZ[kMaxNumberOfInterestingPads];
2215 for (jj=0; jj<kMaxNumberOfInterestingPads; jj++) interestingZ[jj] = 0;
2216
2217 Float_t interDigit[kMaxNumberOfInterestingPads];
2218 for (jj=0; jj<kMaxNumberOfInterestingPads; jj++) interDigit[jj] = 0;
2219
2220 Int_t padsCluster[11];
2221 padsCluster[0] = nSector;
2222 padsCluster[1] = nPlate;
2223 padsCluster[2] = nStrip;
2224 for (jj=3; jj<11; jj++) padsCluster[jj] = -1;
2225
2226 Int_t interestingCounter=-1;
e885fb81 2227 Int_t digitIndexLocal = -1;
e3bd5504 2228 Int_t iPad = -1;
2229 Int_t iPadX = -1;
2230 Int_t iPadZ = -1;
2231
2232 Bool_t check = kFALSE;
2233 Int_t parTOF[5];
2234 for (jj=0; jj<5; jj++) parTOF[jj] = 0;
2235 Double_t posClus[3];
2236 for (jj=0; jj<3; jj++) posClus[jj] = 0.;
2237 Int_t det[5];
2238 for (jj=0; jj<5; jj++) det[jj] = -1;
2239 Float_t posF[3];
2240 for (jj=0; jj<3; jj++) posF[jj] = 0.;
2241 UShort_t volIdClus = 0;
2242 Bool_t status = kTRUE; //assume all sim channels ok in the beginning...
2243 Double_t covClus[6];
2244 for (jj=0; jj<6; jj++) covClus[jj] = 0.;
2245 Int_t tracks[kMaxNumberOfTracksPerDigit];
2246 for (jj=0; jj<3; jj++) tracks[jj] = -1;
2247 Int_t dummyCounter=-1;
2248 Bool_t alreadyStored = kFALSE;
2249
2250 AliTOFselectedDigit ***selectedDigit = new AliTOFselectedDigit**[kMaxNumberOfInterestingPads];
2251 for (ii=0; ii<kMaxNumberOfInterestingPads; ii++)
2252 selectedDigit[ii] = new AliTOFselectedDigit*[kMaxNumberOfDigitsPerVolume];
2253
2254 for (ii=0; ii<kMaxNumberOfInterestingPads; ii++)
2255 for (jj=0; jj<kMaxNumberOfDigitsPerVolume; jj++) selectedDigit[ii][jj] = 0x0;
2256
2257 AliTOFdigit *digitInteresting;
2258
2259 group = group-1;
2260
2261 for (iPad=0; iPad<AliTOFGeometry::NpadZ()*AliTOFGeometry::NpadX()-3; iPad+=2) {
2262
2263 iPadZ = iPad%AliTOFGeometry::NpadZ(); //iPad%2;
2264 iPadX = iPad/AliTOFGeometry::NpadZ(); //iPad/2;
2265
e885fb81 2266 AliDebug(3, Form("%2d %1d %2d\n", iPad, iPadZ, iPadX));
e3bd5504 2267
2268
2269
2270
2271
2272
2273 interestingCounter=-1;
2274
2275 vol[4] = iPadZ , vol[3] = iPadX;
2276 if (fTOFdigitMap->GetNumberOfDigits(vol)>0)
2277 interestingCounter++;
2278
2279 vol[4] = iPadZ, vol[3] = iPadX+1;
2280 if (fTOFdigitMap->GetNumberOfDigits(vol)>0)
2281 interestingCounter++;
2282
2283 vol[4] = AliTOFGeometry::NpadZ()-(iPadZ+1), vol[3] = iPadX;
2284 if (fTOFdigitMap->GetNumberOfDigits(vol)>0)
2285 interestingCounter++;
2286
2287 vol[4] = AliTOFGeometry::NpadZ()-(iPadZ+1), vol[3] = iPadX+1;
2288 if (fTOFdigitMap->GetNumberOfDigits(vol)>0)
2289 interestingCounter++;
2290
2291 if (interestingCounter!=group) continue;
2292 else interestingCounter=-1;
2293
2294
2295 for (ii=0; ii<kMaxNumberOfInterestingPads; ii++)
2296 for (jj=0; jj<kMaxNumberOfDigitsPerVolume; jj++)
2297 selectedDigit[ii][jj] = 0x0;
2298
2299
2300 vol[4] = iPadZ, vol[3] = iPadX;
2301
2302 if (fTOFdigitMap->GetNumberOfDigits(vol)>0) {
2303 interestingCounter++;
2304 for (ii=0; ii<kMaxNumberOfDigitsPerVolume; ii++)
2305 digitsInVolumeIndices[ii] = -1;
2306 fTOFdigitMap->GetDigitIndex(vol, digitsInVolumeIndices);
e885fb81 2307 digitIndexLocal=-1; // AdC
e3bd5504 2308 for(Int_t digIndex=0; digIndex<kMaxNumberOfDigitsPerVolume; digIndex++) {
2309 if (digitsInVolumeIndices[digIndex]<0) continue;
2310 digitInteresting = (AliTOFdigit*)fDigits->UncheckedAt(digitsInVolumeIndices[digIndex]);
e885fb81 2311 if (digitInteresting->GetToT()<=0) continue; // AdC
2312 digitIndexLocal++; // AdC
e3bd5504 2313
e885fb81 2314 AliDebug(1,Form(" %2d %1d %2d %1d %2d %d %d %d %d %5d %5d %5d %5d",
e3bd5504 2315 vol[0], vol[1], vol[2] ,vol[4], vol[3],
2316 digitInteresting->GetTdc(), digitInteresting->GetAdc(),
2317 digitInteresting->GetToT(), digitInteresting->GetToT()*digitInteresting->GetToT(),
2318 digitsInVolumeIndices[digIndex],
2319 digitInteresting->GetTrack(0), digitInteresting->GetTrack(1), digitInteresting->GetTrack(2)));
e885fb81 2320 AliDebug(1,Form(" to try %d %d ",digIndex, interestingCounter));
e3bd5504 2321
e885fb81 2322 selectedDigit[interestingCounter][digitIndexLocal] = new // AdC
e3bd5504 2323 AliTOFselectedDigit(vol, digitInteresting->GetTdc(),
2324 digitInteresting->GetAdc(), digitInteresting->GetToT(),
2325 digitInteresting->GetToT()*digitInteresting->GetToT(),
2326 digitsInVolumeIndices[digIndex],
2327 digitInteresting->GetTracks());
2328 }
e885fb81 2329 if (digitIndexLocal==-1) interestingCounter--; // AdC
e3bd5504 2330 }
2331
2332
2333 vol[4] = iPadZ, vol[3] = iPadX+1;
2334
2335 if (fTOFdigitMap->GetNumberOfDigits(vol)>0) {
2336 interestingCounter++;
2337 for (ii=0; ii<kMaxNumberOfDigitsPerVolume; ii++)
2338 digitsInVolumeIndices[ii] = -1;
2339 fTOFdigitMap->GetDigitIndex(vol, digitsInVolumeIndices);
e885fb81 2340 digitIndexLocal=-1; // AdC
e3bd5504 2341 for(Int_t digIndex=0; digIndex<kMaxNumberOfDigitsPerVolume; digIndex++) {
2342 if (digitsInVolumeIndices[digIndex]<0) continue;
2343 digitInteresting = (AliTOFdigit*)fDigits->UncheckedAt(digitsInVolumeIndices[digIndex]);
e885fb81 2344 if (digitInteresting->GetToT()<=0) continue; // AdC
2345 digitIndexLocal++; // AdC
e3bd5504 2346
e885fb81 2347 AliDebug(1,Form(" %2d %1d %2d %1d %2d %d %d %d %d %5d %5d %5d %5d",
e3bd5504 2348 vol[0], vol[1], vol[2] ,vol[4], vol[3],
2349 digitInteresting->GetTdc(), digitInteresting->GetAdc(),
2350 digitInteresting->GetToT(), digitInteresting->GetToT()*digitInteresting->GetToT(),
2351 digitsInVolumeIndices[digIndex],
2352 digitInteresting->GetTrack(0), digitInteresting->GetTrack(1), digitInteresting->GetTrack(2)));
e885fb81 2353 AliDebug(1,Form(" to try %d %d ",digIndex, interestingCounter));
e3bd5504 2354
e885fb81 2355 selectedDigit[interestingCounter][digitIndexLocal] = new // AdC
e3bd5504 2356 AliTOFselectedDigit(vol, digitInteresting->GetTdc(),
2357 digitInteresting->GetAdc(), digitInteresting->GetToT(),
2358 digitInteresting->GetToT()*digitInteresting->GetToT(),
2359 digitsInVolumeIndices[digIndex],
2360 digitInteresting->GetTracks());
2361 }
e885fb81 2362 if (digitIndexLocal==-1) interestingCounter--; // AdC
e3bd5504 2363 }
2364
2365
2366 vol[4] = AliTOFGeometry::NpadZ()-(iPadZ+1), vol[3] = iPadX;
2367
2368 if (fTOFdigitMap->GetNumberOfDigits(vol)>0) {
2369 interestingCounter++;
2370 for (ii=0; ii<kMaxNumberOfDigitsPerVolume; ii++)
2371 digitsInVolumeIndices[ii] = -1;
2372 fTOFdigitMap->GetDigitIndex(vol, digitsInVolumeIndices);
e885fb81 2373 digitIndexLocal=-1; // AdC
e3bd5504 2374 for(Int_t digIndex=0; digIndex<kMaxNumberOfDigitsPerVolume; digIndex++) {
2375 if (digitsInVolumeIndices[digIndex]<0) continue;
2376 digitInteresting = (AliTOFdigit*)fDigits->UncheckedAt(digitsInVolumeIndices[digIndex]);
e885fb81 2377 if (digitInteresting->GetToT()<=0) continue; // AdC
2378 digitIndexLocal++; // AdC
e3bd5504 2379
e885fb81 2380 AliDebug(1,Form(" %2d %1d %2d %1d %2d %d %d %d %d %5d %5d %5d %5d",
e3bd5504 2381 vol[0], vol[1], vol[2] ,vol[4], vol[3],
2382 digitInteresting->GetTdc(), digitInteresting->GetAdc(),
2383 digitInteresting->GetToT(), digitInteresting->GetToT()*digitInteresting->GetToT(),
2384 digitsInVolumeIndices[digIndex],
2385 digitInteresting->GetTrack(0), digitInteresting->GetTrack(1), digitInteresting->GetTrack(2)));
e885fb81 2386 AliDebug(1,Form(" to try %d %d ",digIndex, interestingCounter));
e3bd5504 2387
e885fb81 2388 selectedDigit[interestingCounter][digitIndexLocal] = new // AdC
e3bd5504 2389 AliTOFselectedDigit(vol, digitInteresting->GetTdc(),
2390 digitInteresting->GetAdc(), digitInteresting->GetToT(),
2391 digitInteresting->GetToT()*digitInteresting->GetToT(),
2392 digitsInVolumeIndices[digIndex],
2393 digitInteresting->GetTracks());
2394 }
e885fb81 2395 if (digitIndexLocal==-1) interestingCounter--; // AdC
e3bd5504 2396 }
2397
2398
2399 vol[4] = AliTOFGeometry::NpadZ()-(iPadZ+1), vol[3] = iPadX+1;
2400
2401 if (fTOFdigitMap->GetNumberOfDigits(vol)>0) {
2402 interestingCounter++;
2403 for (ii=0; ii<kMaxNumberOfDigitsPerVolume; ii++)
2404 digitsInVolumeIndices[ii] = -1;
2405 fTOFdigitMap->GetDigitIndex(vol, digitsInVolumeIndices);
e885fb81 2406 digitIndexLocal=-1; // AdC
e3bd5504 2407 for(Int_t digIndex=0; digIndex<kMaxNumberOfDigitsPerVolume; digIndex++) {
2408 if (digitsInVolumeIndices[digIndex]<0) continue;
2409 digitInteresting = (AliTOFdigit*)fDigits->UncheckedAt(digitsInVolumeIndices[digIndex]);
e885fb81 2410 if (digitInteresting->GetToT()<=0) continue; // AdC
2411 digitIndexLocal++; // AdC
e3bd5504 2412
e885fb81 2413 AliDebug(1,Form(" %2d %1d %2d %1d %2d %d %d %d %d %5d %5d %5d %5d",
e3bd5504 2414 vol[0], vol[1], vol[2] ,vol[4], vol[3],
2415 digitInteresting->GetTdc(), digitInteresting->GetAdc(),
2416 digitInteresting->GetToT(), digitInteresting->GetToT()*digitInteresting->GetToT(),
2417 digitsInVolumeIndices[digIndex],
2418 digitInteresting->GetTrack(0), digitInteresting->GetTrack(1), digitInteresting->GetTrack(2)));
e885fb81 2419 AliDebug(1,Form(" to try %d %d ",digIndex, interestingCounter));
e3bd5504 2420
e885fb81 2421 selectedDigit[interestingCounter][digitIndexLocal] = new // AdC
e3bd5504 2422 AliTOFselectedDigit(vol, digitInteresting->GetTdc(),
2423 digitInteresting->GetAdc(), digitInteresting->GetToT(),
2424 digitInteresting->GetToT()*digitInteresting->GetToT(),
2425 digitsInVolumeIndices[digIndex],
2426 digitInteresting->GetTracks());
2427 }
e885fb81 2428 if (digitIndexLocal==-1) interestingCounter--; // AdC
e3bd5504 2429 }
2430
e885fb81 2431 AliDebug(1,Form(" e adesso %1d", interestingCounter+1));
e3bd5504 2432
2433 switch(interestingCounter+1) {
2434
2435 case 2:
2436
2437 for (Int_t adesso1=0; adesso1<interestingCounter+1; adesso1++) {
2438 for (Int_t firstIndex=0; firstIndex<kMaxNumberOfDigitsPerVolume; firstIndex++) {
2439 if (selectedDigit[adesso1][firstIndex]==0x0) continue;
2440
2441 for (Int_t adesso2=adesso1+1; adesso2<interestingCounter+1; adesso2++) {
2442 for (Int_t secondIndex=0; secondIndex<kMaxNumberOfDigitsPerVolume; secondIndex++) {
2443 if (selectedDigit[adesso2][secondIndex]==0x0) continue;
2444
2445 if (TMath::Abs(selectedDigit[adesso1][firstIndex]->GetTDC()-selectedDigit[adesso2][secondIndex]->GetTDC())>fMaxDeltaTime) continue;
2446
e885fb81 2447 AliDebug(1, Form(" %1d %1d (0x%x) %1d %1d (0x%x)", adesso1, firstIndex,selectedDigit[adesso1][firstIndex],
e3bd5504 2448 adesso2, secondIndex,selectedDigit[adesso2][secondIndex]));
2449
2450 interestingTOF[0] = selectedDigit[adesso1][firstIndex]->GetTDC();
2451 interestingTOT[0] = selectedDigit[adesso1][firstIndex]->GetTOT();
2452 interestingADC[0] = selectedDigit[adesso1][firstIndex]->GetADC();
2453 interestingWeight[0] = selectedDigit[adesso1][firstIndex]->GetWeight();
2454 Int_t vol1[5]; for(jj=0; jj<5; jj++) vol1[jj] = selectedDigit[adesso1][firstIndex]->GetDetectorIndex(jj);
e885fb81 2455 AliDebug(1,Form(" %2d %1d %2d %1d %2d", vol1[0], vol1[1], vol1[2], vol1[4], vol1[3]));
e3bd5504 2456 Int_t volDum = vol1[3];
2457 vol1[3] = vol1[4];
2458 vol1[4] = volDum;
e885fb81 2459 fTOFGeometry->GetPosPar(vol1,pos);
e3bd5504 2460 AliDebug(1,Form(" %f %f %f", pos[0], pos[1], pos[2]));
2461 interestingX[0] = pos[0];
2462 interestingY[0] = pos[1];
2463 interestingZ[0] = pos[2];
2464
2465 interestingTOF[1] = selectedDigit[adesso2][secondIndex]->GetTDC();
2466 interestingTOT[1] = selectedDigit[adesso2][secondIndex]->GetTOT();
2467 interestingADC[1] = selectedDigit[adesso2][secondIndex]->GetADC();
2468 interestingWeight[1] = selectedDigit[adesso2][secondIndex]->GetWeight();
2469 Int_t vol2[5]; for(jj=0; jj<5; jj++) vol2[jj] = selectedDigit[adesso2][secondIndex]->GetDetectorIndex(jj);
e885fb81 2470 AliDebug(1,Form(" %2d %1d %2d %1d %2d", vol2[0], vol2[1], vol2[2], vol2[4], vol2[3]));
e3bd5504 2471 volDum = vol2[3];
2472 vol2[3] = vol2[4];
2473 vol2[4] = volDum;
e885fb81 2474 fTOFGeometry->GetPosPar(vol2,pos);
e3bd5504 2475 AliDebug(1,Form(" %f %f %f", pos[0], pos[1], pos[2]));
2476 interestingX[1] = pos[0];
2477 interestingY[1] = pos[1];
2478 interestingZ[1] = pos[2];
2479
2480
2481 AverageCalculations(interestingCounter+1,
2482 interestingX, interestingY, interestingZ,
2483 interestingTOF, interestingTOT, interestingADC,
2484 interestingWeight,
2485 parTOF, posClus, check);
2486
2487 for (jj=0; jj<5; jj++) det[jj] = -1;
2488 for (jj=0; jj<3; jj++) posF[jj] = posClus[jj];
2489
2490 AliDebug(1,Form(" %f %f %f", posF[0], posF[1], posF[2]));
e885fb81 2491 fTOFGeometry->GetDetID(posF, det);
2492 AliDebug(1,Form(" %2d %1d %2d %1d %2d", det[0], det[1], det[2], det[3], det[4]));
e3bd5504 2493
e885fb81 2494 volIdClus = fTOFGeometry->GetAliSensVolIndex(det[0],det[1],det[2]);
2495 //volIdClus = GetClusterVolIndex(det);
e3bd5504 2496
2497 for (jj=3; jj<11; jj++) padsCluster[jj] = -1;
2498 padsCluster[3] = selectedDigit[adesso1][firstIndex]->GetDetectorIndex(4);
2499 padsCluster[4] = selectedDigit[adesso1][firstIndex]->GetDetectorIndex(3);
2500 padsCluster[5] = selectedDigit[adesso2][secondIndex]->GetDetectorIndex(4);
2501 padsCluster[6] = selectedDigit[adesso2][secondIndex]->GetDetectorIndex(3);
2502
2503 for (jj=0; jj<6; jj++) covClus[jj] = 0.;
2504 Int_t ** indDet = new Int_t*[interestingCounter+1];
2505 for (jj=0; jj<interestingCounter+1; jj++) indDet[jj] = new Int_t [5];
2506 for (jj=0; jj<interestingCounter+1; jj++) indDet[jj][0] = nSector;
2507 for (jj=0; jj<interestingCounter+1; jj++) indDet[jj][1] = nPlate;
2508 for (jj=0; jj<interestingCounter+1; jj++) indDet[jj][2] = nStrip;
2509 for (jj=0; jj<interestingCounter+1; jj++) indDet[jj][3] = padsCluster[2*jj+3];
2510 for (jj=0; jj<interestingCounter+1; jj++) indDet[jj][4] = padsCluster[2*jj+1+3];
e885fb81 2511 GetClusterPars(/*check,*/ interestingCounter+1, indDet, interestingWeight, posClus, covClus);
e3bd5504 2512 for (jj=0; jj<interestingCounter+1; jj++) delete [] indDet[jj];
2513
2514 // To fill the track index array
2515 dummyCounter=-1;
2516 for (jj=0; jj<kMaxNumberOfTracksPerDigit; jj++) tracks[jj] = -1;
2517 for (Int_t kk=0; kk<kMaxNumberOfTracksPerDigit; kk++) { // three is the max number of tracks associated to one digit
2518 if (selectedDigit[adesso1][firstIndex]->GetTrackLabel(kk)==-1) continue;
2519 else {
2520 dummyCounter++;
2521 tracks[dummyCounter] = selectedDigit[adesso1][firstIndex]->GetTrackLabel(kk);
2522 }
2523 }
2524 for (Int_t kk=0; kk<kMaxNumberOfTracksPerDigit; kk++) { // three is the max number of tracks associated to one digit
2525 if (selectedDigit[adesso2][secondIndex]->GetTrackLabel(kk)==-1) continue;
2526 else {
2527
2528 alreadyStored = kFALSE;
2529 for (jj=0; jj<dummyCounter+1; jj++)
2530 alreadyStored = alreadyStored || (tracks[jj]!=-1 && tracks[jj]==selectedDigit[adesso2][secondIndex]->GetTrackLabel(kk));
2531
2532 if (alreadyStored) continue;
2533 if (dummyCounter==2) { // three is the max number of tracks associated to one cluster
2534 AliWarning(" Siamo al limite!");
2535 continue;
2536 }
2537
2538 dummyCounter++;
2539 tracks[dummyCounter] = selectedDigit[adesso2][secondIndex]->GetTrackLabel(kk);
2540
2541 }
2542
2543 }
2544
2545
2546 AliTOFcluster *tofCluster =
2547 new AliTOFcluster(volIdClus, posClus[0], posClus[1], posClus[2],
2548 covClus[0], covClus[1], covClus[2], covClus[3], covClus[4], covClus[5],
2549 tracks, det, parTOF, status, selectedDigit[adesso1][firstIndex]->GetIndex()); //to updated
2550 InsertCluster(tofCluster);
2551
e885fb81 2552 AliDebug(2, Form(" %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",
e3bd5504 2553 volIdClus, posClus[0], posClus[1], posClus[2],
2554 covClus[0], covClus[1], covClus[2], covClus[3], covClus[4], covClus[5],
2555 tracks[0], tracks[1], tracks[2],
2556 det[0], det[1], det[2], det[3], det[4],
2557 parTOF[0], parTOF[1], parTOF[2], parTOF[3], parTOF[4],
2558 status, selectedDigit[adesso1][firstIndex]->GetIndex()));
2559
2560 volDum = vol1[3];
2561 vol1[3] = vol1[4];
2562 vol1[4] = volDum;
2563 fTOFdigitMap->ResetDigitNumber(vol1,selectedDigit[adesso1][firstIndex]->GetIndex());
2564 volDum = vol2[3];
2565 vol2[3] = vol2[4];
2566 vol2[4] = volDum;
2567 fTOFdigitMap->ResetDigitNumber(vol2,selectedDigit[adesso2][secondIndex]->GetIndex());
2568
2569
2570 } // close loop on second digit
2571 } // close loop on adesso2
2572
2573 } // close loop on first digit
2574 } // close loop on adesso1
2575
2576
2577 break;
2578
2579 case 3:
2580
2581 for (Int_t adesso1=0; adesso1<interestingCounter+1; adesso1++) {
2582 for (Int_t firstIndex=0; firstIndex<kMaxNumberOfDigitsPerVolume; firstIndex++) {
2583 if (selectedDigit[adesso1][firstIndex]==0x0) continue;
2584
2585 for (Int_t adesso2=adesso1+1; adesso2<interestingCounter+1; adesso2++) {
2586 for (Int_t secondIndex=0; secondIndex<kMaxNumberOfDigitsPerVolume; secondIndex++) {
2587 if (selectedDigit[adesso2][secondIndex]==0x0) continue;
2588
2589 for (Int_t adesso3=adesso2+1; adesso3<interestingCounter+1; adesso3++) {
2590 for (Int_t thirdIndex=0; thirdIndex<kMaxNumberOfDigitsPerVolume; thirdIndex++) {
2591 if (selectedDigit[adesso3][thirdIndex]==0x0) continue;
2592
2593
2594 if (TMath::Abs(selectedDigit[adesso1][firstIndex]->GetTDC()-selectedDigit[adesso2][secondIndex]->GetTDC())>fMaxDeltaTime
2595 ||
2596 TMath::Abs(selectedDigit[adesso1][firstIndex]->GetTDC()-selectedDigit[adesso3][thirdIndex]->GetTDC())>fMaxDeltaTime
2597 ||
2598 TMath::Abs(selectedDigit[adesso2][secondIndex]->GetTDC()-selectedDigit[adesso3][thirdIndex]->GetTDC())>fMaxDeltaTime) continue;
2599
2600 interestingTOF[0] = selectedDigit[adesso1][firstIndex]->GetTDC();
2601 interestingTOT[0] = selectedDigit[adesso1][firstIndex]->GetTOT();
2602 interestingADC[0] = selectedDigit[adesso1][firstIndex]->GetADC();
2603 interestingWeight[0] = selectedDigit[adesso1][firstIndex]->GetWeight();
2604 Int_t vol1[5]; for(jj=0; jj<5; jj++) vol1[jj] = selectedDigit[adesso1][firstIndex]->GetDetectorIndex(jj);
e885fb81 2605 AliDebug(1,Form(" %2d %1d %2d %1d %2d", vol1[0], vol1[1], vol1[2], vol1[4], vol1[3]));
e3bd5504 2606 Int_t volDum = vol1[3];
2607 vol1[3] = vol1[4];
2608 vol1[4] = volDum;
e885fb81 2609 fTOFGeometry->GetPosPar(vol1,pos);
e3bd5504 2610 interestingX[0] = pos[0];
2611 interestingY[0] = pos[1];
2612 interestingZ[0] = pos[2];
2613
2614 interestingTOF[1] = selectedDigit[adesso2][secondIndex]->GetTDC();
2615 interestingTOT[1] = selectedDigit[adesso2][secondIndex]->GetTOT();
2616 interestingADC[1] = selectedDigit[adesso2][secondIndex]->GetADC();
2617 interestingWeight[1] = selectedDigit[adesso2][secondIndex]->GetWeight();
2618 Int_t vol2[5]; for(jj=0; jj<5; jj++) vol2[jj] = selectedDigit[adesso2][secondIndex]->GetDetectorIndex(jj);
e885fb81 2619 AliDebug(1,Form(" %2d %1d %2d %1d %2d", vol2[0], vol2[1], vol2[2], vol2[4], vol2[3]));
e3bd5504 2620 volDum = vol2[3];
2621 vol2[3] = vol2[4];
2622 vol2[4] = volDum;
e885fb81 2623 fTOFGeometry->GetPosPar(vol2,pos);
e3bd5504 2624 interestingX[1] = pos[0];
2625 interestingY[1] = pos[1];
2626 interestingZ[1] = pos[2];
2627
2628 interestingTOF[2] = selectedDigit[adesso3][thirdIndex]->GetTDC();
2629 interestingTOT[2] = selectedDigit[adesso3][thirdIndex]->GetTOT();
2630 interestingADC[2] = selectedDigit[adesso3][thirdIndex]->GetADC();
2631 interestingWeight[2] = selectedDigit[adesso3][thirdIndex]->GetWeight();
2632 Int_t vol3[5]; for(jj=0; jj<5; jj++) vol3[jj] = selectedDigit[adesso3][thirdIndex]->GetDetectorIndex(jj);
e885fb81 2633 AliDebug(1,Form(" %2d %1d %2d %1d %2d", vol3[0], vol3[1], vol3[2], vol3[4], vol3[3]));
e3bd5504 2634 volDum = vol3[3];
2635 vol3[3] = vol3[4];
2636 vol3[4] = volDum;
e885fb81 2637 fTOFGeometry->GetPosPar(vol3,pos);
e3bd5504 2638 interestingX[2] = pos[0];
2639 interestingY[2] = pos[1];
2640 interestingZ[2] = pos[2];
2641
2642
2643 AverageCalculations(interestingCounter+1,
2644 interestingX, interestingY, interestingZ,
2645 interestingTOF, interestingTOT, interestingADC,
2646 interestingWeight,
2647 parTOF, posClus, check);
2648
2649 for (jj=0; jj<5; jj++) det[jj] = -1;
2650 for (jj=0; jj<3; jj++) posF[jj] = posClus[jj];
e885fb81 2651 fTOFGeometry->GetDetID(posF, det);
e3bd5504 2652
e885fb81 2653 volIdClus = fTOFGeometry->GetAliSensVolIndex(det[0],det[1],det[2]);
2654 //volIdClus = GetClusterVolIndex(det);
e3bd5504 2655
2656 for (jj=3; jj<11; jj++) padsCluster[jj] = -1;
2657 padsCluster[3] = selectedDigit[adesso1][firstIndex]->GetDetectorIndex(4);
2658 padsCluster[4] = selectedDigit[adesso1][firstIndex]->GetDetectorIndex(3);
2659 padsCluster[5] = selectedDigit[adesso2][secondIndex]->GetDetectorIndex(4);
2660 padsCluster[6] = selectedDigit[adesso2][secondIndex]->GetDetectorIndex(3);
2661 padsCluster[7] = selectedDigit[adesso3][thirdIndex]->GetDetectorIndex(4);
2662 padsCluster[8] = selectedDigit[adesso3][thirdIndex]->GetDetectorIndex(3);
2663
2664 for (jj=0; jj<6; jj++) covClus[jj] = 0.;
2665 Int_t ** indDet = new Int_t*[interestingCounter+1];
2666 for (jj=0; jj<interestingCounter+1; jj++) indDet[jj] = new Int_t [5];
2667 for (jj=0; jj<interestingCounter+1; jj++) indDet[jj][0] = nSector;
2668 for (jj=0; jj<interestingCounter+1; jj++) indDet[jj][1] = nPlate;
2669 for (jj=0; jj<interestingCounter+1; jj++) indDet[jj][2] = nStrip;
2670 for (jj=0; jj<interestingCounter+1; jj++) indDet[jj][3] = padsCluster[2*jj+3];
2671 for (jj=0; jj<interestingCounter+1; jj++) indDet[jj][4] = padsCluster[2*jj+1+3];
e885fb81 2672 GetClusterPars(/*check,*/ interestingCounter+1, indDet, interestingWeight, posClus, covClus);
e3bd5504 2673 for (jj=0; jj<interestingCounter+1; jj++) delete [] indDet[jj];
2674
2675 // To fill the track index array
2676 dummyCounter=-1;
2677 for (jj=0; jj<kMaxNumberOfTracksPerDigit; jj++) tracks[jj] = -1;
2678 for (Int_t kk=0; kk<kMaxNumberOfTracksPerDigit; kk++) { // three is the max number of tracks associated to one digit
2679 if (selectedDigit[adesso1][firstIndex]->GetTrackLabel(kk)==-1) continue;
2680 else {
2681 dummyCounter++;
2682 tracks[dummyCounter] = selectedDigit[adesso1][firstIndex]->GetTrackLabel(kk);
2683 }
2684 }
2685 for (Int_t kk=0; kk<kMaxNumberOfTracksPerDigit; kk++) { // three is the max number of tracks associated to one digit
2686 if (selectedDigit[adesso2][secondIndex]->GetTrackLabel(kk)==-1) continue;
2687 else {
2688
2689 alreadyStored = kFALSE;
2690 for (jj=0; jj<dummyCounter+1; jj++)
2691 alreadyStored = alreadyStored || (tracks[jj]!=-1 && tracks[jj]==selectedDigit[adesso2][secondIndex]->GetTrackLabel(kk));
2692
2693 if (alreadyStored) continue;
2694 if (dummyCounter==2) { // three is the max number of tracks associated to one cluster
2695 AliWarning(" Siamo al limite!");
2696 continue;
2697 }
2698
2699 dummyCounter++;
2700 tracks[dummyCounter] = selectedDigit[adesso2][secondIndex]->GetTrackLabel(kk);
2701
2702 }
2703
2704 }
2705 for (Int_t kk=0; kk<kMaxNumberOfTracksPerDigit; kk++) { // three is the max number of tracks associated to one digit
2706 if (selectedDigit[adesso3][thirdIndex]->GetTrackLabel(kk)==-1) continue;
2707 else {
2708
2709 alreadyStored = kFALSE;
2710 for (jj=0; jj<dummyCounter+1; jj++)
2711 alreadyStored = alreadyStored || (tracks[jj]!=-1 && tracks[jj]==selectedDigit[adesso3][thirdIndex]->GetTrackLabel(kk));
2712
2713 if (alreadyStored) continue;
2714 if (dummyCounter==2) { // three is the max number of tracks associated to one cluster
2715 AliWarning(" Siamo al limite!");
2716 continue;
2717 }
2718
2719 dummyCounter++;
2720 tracks[dummyCounter] = selectedDigit[adesso3][thirdIndex]->GetTrackLabel(kk);
2721
2722 }
2723
2724 }
2725
2726
2727 AliTOFcluster *tofCluster =
2728 new AliTOFcluster(volIdClus, posClus[0], posClus[1], posClus[2],
2729 covClus[0], covClus[1], covClus[2], covClus[3], covClus[4], covClus[5],
2730 tracks, det, parTOF, status, selectedDigit[adesso1][firstIndex]->GetIndex()); // to be updated
2731 InsertCluster(tofCluster);
2732
e885fb81 2733 AliDebug(2, Form(" %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",
e3bd5504 2734 volIdClus, posClus[0], posClus[1], posClus[2],
2735 covClus[0], covClus[1], covClus[2], covClus[3], covClus[4], covClus[5],
2736 tracks[0], tracks[1], tracks[2],
2737 det[0], det[1], det[2], det[3], det[4],
2738 parTOF[0], parTOF[1], parTOF[2], parTOF[3], parTOF[4],
2739 status, selectedDigit[adesso1][firstIndex]->GetIndex()));
2740
2741 volDum = vol1[3];
2742 vol1[3] = vol1[4];
2743 vol1[4] = volDum;
2744 fTOFdigitMap->ResetDigitNumber(vol1,selectedDigit[adesso1][firstIndex]->GetIndex());
2745 volDum = vol2[3];
2746 vol2[3] = vol2[4];
2747 vol2[4] = volDum;
2748 fTOFdigitMap->ResetDigitNumber(vol2,selectedDigit[adesso2][secondIndex]->GetIndex());
2749 volDum = vol3[3];
2750 vol3[3] = vol3[4];
2751 vol3[4] = volDum;
2752 fTOFdigitMap->ResetDigitNumber(vol3,selectedDigit[adesso3][thirdIndex]->GetIndex());
2753
2754
2755 } // close loop on third digit
2756 } // close loop on adesso3
2757
2758 } // close loop on second digit
2759 } // close loop on adesso2
2760
2761 } // close loop on first digit
2762 } // close loop on adesso1
2763
2764
2765 break;
2766
2767 case 4:
2768
2769 Int_t adesso1 = 0;
2770 for (Int_t firstIndex=0; firstIndex<kMaxNumberOfDigitsPerVolume; firstIndex++) {
2771 if (selectedDigit[adesso1][firstIndex]==0x0) continue;
2772
2773 Int_t adesso2 = 1;
2774 for (Int_t secondIndex=0; secondIndex<kMaxNumberOfDigitsPerVolume; secondIndex++) {
2775 if (selectedDigit[adesso2][secondIndex]==0x0) continue;
2776
2777 Int_t adesso3 = 2;
2778 for (Int_t thirdIndex=0; thirdIndex<kMaxNumberOfDigitsPerVolume; thirdIndex++) {
2779 if (selectedDigit[adesso3][thirdIndex]==0x0) continue;
2780
2781 Int_t adesso4 = 3;
2782 for (Int_t fourthIndex=0; fourthIndex<kMaxNumberOfDigitsPerVolume; fourthIndex++) {
2783 if (selectedDigit[adesso4][fourthIndex]==0x0) continue;
2784
2785
2786 if (TMath::Abs(selectedDigit[adesso1][firstIndex]->GetTDC()-selectedDigit[adesso2][secondIndex]->GetTDC())>fMaxDeltaTime
2787 ||
2788 TMath::Abs(selectedDigit[adesso1][firstIndex]->GetTDC()-selectedDigit[adesso3][thirdIndex]->GetTDC())>fMaxDeltaTime
2789 ||
2790 TMath::Abs(selectedDigit[adesso1][firstIndex]->GetTDC()-selectedDigit[adesso4][fourthIndex]->GetTDC())>fMaxDeltaTime
2791 ||
2792 TMath::Abs(selectedDigit[adesso2][secondIndex]->GetTDC()-selectedDigit[adesso3][thirdIndex]->GetTDC())>fMaxDeltaTime
2793 ||
2794 TMath::Abs(selectedDigit[adesso2][secondIndex]->GetTDC()-selectedDigit[adesso4][fourthIndex]->GetTDC())>fMaxDeltaTime
2795 ||
2796 TMath::Abs(selectedDigit[adesso3][thirdIndex]->GetTDC()-selectedDigit[adesso4][fourthIndex]->GetTDC())>fMaxDeltaTime) continue;
2797
2798 interestingTOF[0] = selectedDigit[adesso1][firstIndex]->GetTDC();
2799 interestingTOT[0] = selectedDigit[adesso1][firstIndex]->GetTOT();
2800 interestingADC[0] = selectedDigit[adesso1][firstIndex]->GetADC();
2801 interestingWeight[0] = selectedDigit[adesso1][firstIndex]->GetWeight();
2802 Int_t vol1[5]; for(jj=0; jj<5; jj++) vol1[jj] = selectedDigit[adesso1][firstIndex]->GetDetectorIndex(jj);
e885fb81 2803 AliDebug(1,Form(" %2d %1d %2d %1d %2d", vol1[0], vol1[1], vol1[2], vol1[4], vol1[3]));
e3bd5504 2804 Int_t volDum = vol1[3];
2805 vol1[3] = vol1[4];
2806 vol1[4] = volDum;
e885fb81 2807 fTOFGeometry->GetPosPar(vol1,pos);
e3bd5504 2808 interestingX[0] = pos[0];
2809 interestingY[0] = pos[1];
2810 interestingZ[0] = pos[2];
2811
2812 interestingTOF[1] = selectedDigit[adesso2][secondIndex]->GetTDC();
2813 interestingTOT[1] = selectedDigit[adesso2][secondIndex]->GetTOT();
2814 interestingADC[1] = selectedDigit[adesso2][secondIndex]->GetADC();
2815 interestingWeight[1] = selectedDigit[adesso2][secondIndex]->GetWeight();
2816 Int_t vol2[5]; for(jj=0; jj<5; jj++) vol2[jj] = selectedDigit[adesso2][secondIndex]->GetDetectorIndex(jj);
e885fb81 2817 AliDebug(1,Form(" %2d %1d %2d %1d %2d", vol2[0], vol2[1], vol2[2], vol2[4], vol2[3]));
e3bd5504 2818 volDum = vol2[3];
2819 vol2[3] = vol2[4];
2820 vol2[4] = volDum;
e885fb81 2821 fTOFGeometry->GetPosPar(vol2,pos);
e3bd5504 2822 interestingX[1] = pos[0];
2823 interestingY[1] = pos[1];
2824 interestingZ[1] = pos[2];
2825
2826 interestingTOF[2] = selectedDigit[adesso3][thirdIndex]->GetTDC();
2827 interestingTOT[2] = selectedDigit[adesso3][thirdIndex]->GetTOT();
2828 interestingADC[2] = selectedDigit[adesso3][thirdIndex]->GetADC();
2829 interestingWeight[2] = selectedDigit[adesso3][thirdIndex]->GetWeight();
2830 Int_t vol3[5]; for(jj=0; jj<5; jj++) vol3[jj] = selectedDigit[adesso3][thirdIndex]->GetDetectorIndex(jj);
e885fb81 2831 AliDebug(1,Form(" %2d %1d %2d %1d %2d", vol3[0], vol3[1], vol3[2], vol3[4], vol3[3]));
e3bd5504 2832 volDum = vol3[3];
2833 vol3[3] = vol3[4];
2834 vol3[4] = volDum;
e885fb81 2835 fTOFGeometry->GetPosPar(vol3,pos);
e3bd5504 2836 interestingX[2] = pos[0];
2837 interestingY[2] = pos[1];
2838 interestingZ[2] = pos[2];
2839
2840 interestingTOF[3] = selectedDigit[adesso4][fourthIndex]->GetTDC();
2841 interestingTOT[3] = selectedDigit[adesso4][fourthIndex]->GetTOT();
2842 interestingADC[3] = selectedDigit[adesso4][fourthIndex]->GetADC();
2843 interestingWeight[3] = selectedDigit[adesso4][fourthIndex]->GetWeight();
2844 Int_t vol4[5]; for(jj=0; jj<5; jj++) vol4[jj] = selectedDigit[adesso4][fourthIndex]->GetDetectorIndex(jj);
e885fb81 2845 AliDebug(1,Form(" %2d %1d %2d %1d %2d", vol4[0], vol4[1], vol4[2], vol4[4], vol4[3]));
e3bd5504 2846 volDum = vol4[3];
2847 vol4[3] = vol4[4];
2848 vol4[4] = volDum;
e885fb81 2849 fTOFGeometry->GetPosPar(vol4,pos);
e3bd5504 2850 interestingX[3] = pos[0];
2851 interestingY[3] = pos[1];
2852 interestingZ[3] = pos[2];
2853
2854
2855 AverageCalculations(interestingCounter+1,
2856 interestingX, interestingY, interestingZ,
2857 interestingTOF, interestingTOT, interestingADC,
2858 interestingWeight,
2859 parTOF, posClus, check);
2860
2861 for (jj=0; jj<5; jj++) det[jj] = -1;
2862 for (jj=0; jj<3; jj++) posF[jj] = posClus[jj];
e885fb81 2863 fTOFGeometry->GetDetID(posF, det);
e3bd5504 2864
e885fb81 2865 volIdClus = fTOFGeometry->GetAliSensVolIndex(det[0],det[1],det[2]);
2866 //volIdClus = GetClusterVolIndex(det);
e3bd5504 2867
2868 for (jj=3; jj<11; jj++) padsCluster[jj] = -1;
2869 padsCluster[3] = selectedDigit[adesso1][firstIndex]->GetDetectorIndex(4);
2870 padsCluster[4] = selectedDigit[adesso1][firstIndex]->GetDetectorIndex(3);
2871 padsCluster[5] = selectedDigit[adesso2][secondIndex]->GetDetectorIndex(4);
2872 padsCluster[6] = selectedDigit[adesso2][secondIndex]->GetDetectorIndex(3);
2873 padsCluster[7] = selectedDigit[adesso3][thirdIndex]->GetDetectorIndex(4);
2874 padsCluster[8] = selectedDigit[adesso3][thirdIndex]->GetDetectorIndex(3);
2875 padsCluster[9] = selectedDigit[adesso4][fourthIndex]->GetDetectorIndex(4);
2876 padsCluster[10] = selectedDigit[adesso4][fourthIndex]->GetDetectorIndex(3);
2877
2878 for (jj=0; jj<6; jj++) covClus[jj] = 0.;
2879 Int_t ** indDet = new Int_t*[interestingCounter+1];
2880 for (jj=0; jj<interestingCounter+1; jj++) indDet[jj] = new Int_t [5];
2881 for (jj=0; jj<interestingCounter+1; jj++) indDet[jj][0] = nSector;
2882 for (jj=0; jj<interestingCounter+1; jj++) indDet[jj][1] = nPlate;
2883 for (jj=0; jj<interestingCounter+1; jj++) indDet[jj][2] = nStrip;
2884 for (jj=0; jj<interestingCounter+1; jj++) indDet[jj][3] = padsCluster[2*jj+3];
2885 for (jj=0; jj<interestingCounter+1; jj++) indDet[jj][4] = padsCluster[2*jj+1+3];
e885fb81 2886 GetClusterPars(/*check,*/ interestingCounter+1, indDet, interestingWeight, posClus, covClus);
e3bd5504 2887 for (jj=0; jj<interestingCounter+1; jj++) delete [] indDet[jj];
2888
2889 // To fill the track index array
2890 dummyCounter=-1;
2891 for (jj=0; jj<kMaxNumberOfTracksPerDigit; jj++) tracks[jj] = -1;
2892 for (Int_t kk=0; kk<kMaxNumberOfTracksPerDigit; kk++) { // three is the max number of tracks associated to one digit
2893 if (selectedDigit[adesso1][firstIndex]->GetTrackLabel(kk)==-1) continue;
2894 else {
2895 dummyCounter++;
2896 tracks[dummyCounter] = selectedDigit[adesso1][firstIndex]->GetTrackLabel(kk);
2897 }
2898 }
2899 for (Int_t kk=0; kk<kMaxNumberOfTracksPerDigit; kk++) { // three is the max number of tracks associated to one digit
2900 if (selectedDigit[adesso2][secondIndex]->GetTrackLabel(kk)==-1) continue;
2901 else {
2902
2903 alreadyStored = kFALSE;
2904 for (jj=0; jj<dummyCounter+1; jj++)
2905 alreadyStored = alreadyStored || (tracks[jj]!=-1 && tracks[jj]==selectedDigit[adesso2][secondIndex]->GetTrackLabel(kk));
2906
2907 if (alreadyStored) continue;
2908 if (dummyCounter==2) { // three is the max number of tracks associated to one cluster
2909 AliWarning(" Siamo al limite!");
2910 continue;
2911 }
2912
2913 dummyCounter++;
2914 tracks[dummyCounter] = selectedDigit[adesso2][secondIndex]->GetTrackLabel(kk);
2915
2916 }
2917
2918 }
2919 for (Int_t kk=0; kk<kMaxNumberOfTracksPerDigit; kk++) { // three is the max number of tracks associated to one digit
2920 if (selectedDigit[adesso3][thirdIndex]->GetTrackLabel(kk)==-1) continue;
2921 else {
2922
2923 alreadyStored = kFALSE;
2924 for (jj=0; jj<dummyCounter+1; jj++)
2925 alreadyStored = alreadyStored || (tracks[jj]!=-1 && tracks[jj]==selectedDigit[adesso3][thirdIndex]->GetTrackLabel(kk));
2926
2927 if (alreadyStored) continue;
2928 if (dummyCounter==2) { // three is the max number of tracks associated to one cluster
2929 AliWarning(" Siamo al limite!");
2930 continue;
2931 }
2932
2933 dummyCounter++;
2934 tracks[dummyCounter] = selectedDigit[adesso3][thirdIndex]->GetTrackLabel(kk);
2935
2936 }
2937
2938 }
2939 for (Int_t kk=0; kk<kMaxNumberOfTracksPerDigit; kk++) { // three is the max number of tracks associated to one digit
2940 if (selectedDigit[adesso4][fourthIndex]->GetTrackLabel(kk)==-1) continue;
2941 else {
2942
2943 alreadyStored = kFALSE;
2944 for (jj=0; jj<dummyCounter+1; jj++)
2945 alreadyStored = alreadyStored || (tracks[jj]!=-1 && tracks[jj]==selectedDigit[adesso4][fourthIndex]->GetTrackLabel(kk));
2946
2947 if (alreadyStored) continue;
2948 if (dummyCounter==2) { // three is the max number of tracks associated to one cluster
2949 AliWarning(" Siamo al limite!");
2950 continue;
2951 }
2952
2953 dummyCounter++;
2954 tracks[dummyCounter] = selectedDigit[adesso4][fourthIndex]->GetTrackLabel(kk);
2955
2956 }
2957
2958 }
2959
2960
2961 AliTOFcluster *tofCluster =
2962 new AliTOFcluster(volIdClus, posClus[0], posClus[1], posClus[2],
2963 covClus[0], covClus[1], covClus[2], covClus[3], covClus[4], covClus[5],
2964 tracks, det, parTOF, status, selectedDigit[adesso1][firstIndex]->GetIndex()); // to be updated
2965 InsertCluster(tofCluster);
2966
e885fb81 2967 AliDebug(2, Form(" %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",
e3bd5504 2968 volIdClus, posClus[0], posClus[1], posClus[2],
2969 covClus[0], covClus[1], covClus[2], covClus[3], covClus[4], covClus[5],
2970 tracks[0], tracks[1], tracks[2],
2971 det[0], det[1], det[2], det[3], det[4],
2972 parTOF[0], parTOF[1], parTOF[2], parTOF[3], parTOF[4],
2973 status, selectedDigit[adesso1][firstIndex]->GetIndex()));
2974
2975 volDum = vol1[3];
2976 vol1[3] = vol1[4];
2977 vol1[4] = volDum;
2978 fTOFdigitMap->ResetDigitNumber(vol1,selectedDigit[adesso1][firstIndex]->GetIndex());
2979 volDum = vol2[3];
2980 vol2[3] = vol2[4];
2981 vol2[4] = volDum;
2982 fTOFdigitMap->ResetDigitNumber(vol2,selectedDigit[adesso2][secondIndex]->GetIndex());
2983 volDum = vol3[3];
2984 vol3[3] = vol3[4];
2985 vol3[4] = volDum;
2986 fTOFdigitMap->ResetDigitNumber(vol3,selectedDigit[adesso3][thirdIndex]->GetIndex());
2987 volDum = vol4[3];
2988 vol4[3] = vol4[4];
2989 vol4[4] = volDum;
2990 fTOFdigitMap->ResetDigitNumber(vol4,selectedDigit[adesso4][fourthIndex]->GetIndex());
2991
2992
2993 } // close loop on fourth digit
2994
2995 } // close loop on third digit
2996
2997 } // close loop on second digit
2998
2999 } // close loop on first digit
3000
3001 break;
3002
3003 }
3004
3005 for (ii=0; ii<kMaxNumberOfInterestingPads; ii++)
3006 for (jj=0; jj<kMaxNumberOfDigitsPerVolume; jj++)
3007 selectedDigit[ii][jj] = 0x0;
3008
3009 } // loop on iPad
3010
3011 for (ii=0; ii<kMaxNumberOfInterestingPads; ii++)
3012 for (jj=0; jj<kMaxNumberOfDigitsPerVolume; jj++) {
3013 delete selectedDigit[ii][jj];
3014 selectedDigit[ii][jj] = 0x0;
3015 }
3016
3017}
3018//_____________________________________________________________________________
3019
3020Int_t AliTOFClusterFinderV1::InsertCluster(AliTOFcluster *tofCluster)
3021{
3022 //
3023 // This function adds a TOF cluster to the array of TOF clusters
3024 // sorted in Z, i.e. fTofClusters
3025 //
3026
3027 if (fNumberOfTofClusters==kTofMaxCluster) {
3028 AliError("Too many clusters !");
3029 return 1;
3030 }
3031
3032 if (fNumberOfTofClusters==0) {
3033 fTofClusters[fNumberOfTofClusters++] = tofCluster;
3034 return 0;
3035 }
3036
3037 Int_t ii = FindClusterIndex(tofCluster->GetZ());
3038 memmove(fTofClusters+ii+1 ,fTofClusters+ii,(fNumberOfTofClusters-ii)*sizeof(AliTOFcluster*));
3039 fTofClusters[ii] = tofCluster;
3040 fNumberOfTofClusters++;
3041
3042 return 0;
3043
3044}
3045//_____________________________________________________________________________
3046
3047Int_t AliTOFClusterFinderV1::FindClusterIndex(Double_t z) const
3048{
3049 //
3050 // This function returns the index of the nearest cluster in z
3051 //
3052
3053 if (fNumberOfTofClusters==0) return 0;
3054 if (z <= fTofClusters[0]->GetZ()) return 0;
3055 if (z > fTofClusters[fNumberOfTofClusters-1]->GetZ()) return fNumberOfTofClusters;
3056 Int_t b = 0, e = fNumberOfTofClusters-1, m = (b+e)/2;
3057 for (; b<e; m=(b+e)/2) {
3058 if (z > fTofClusters[m]->GetZ()) b=m+1;
3059 else e=m;
3060 }
3061
3062 return m;
3063
3064}
3065//_____________________________________________________________________________
3066
3067void AliTOFClusterFinderV1::ResetRecpoint()
3068{
3069 //
3070 // Clear the list of reconstructed points
3071 //
3072
3073 fNumberOfTofClusters = 0;
3074 if (fRecPoints) fRecPoints->Clear();
3075
3076}
3077//_____________________________________________________________________________
3078
3079void AliTOFClusterFinderV1::ResetDigits()
3080{
3081 //
3082 // Clear the list of digits
3083 //
3084
3085 fNumberOfTofDigits = 0;
3086 if (fDigits) fDigits->Clear();
3087
3088}
3089//_____________________________________________________________________________
e885fb81 3090//UShort_t AliTOFClusterFinderV1::GetClusterVolIndex(Int_t *ind) const
3091//{
e3bd5504 3092 //
3093 // Get the volume ID to retrieve the l2t transformation
3094 //
3095
3096 // Detector numbering scheme
e885fb81 3097/*
e3bd5504 3098 Int_t nSector = AliTOFGeometry::NSectors();
3099 Int_t nPlate = AliTOFGeometry::NPlates();
3100 Int_t nStripA = AliTOFGeometry::NStripA();
3101 Int_t nStripB = AliTOFGeometry::NStripB();
3102 Int_t nStripC = AliTOFGeometry::NStripC();
3103
3104 Int_t isector =ind[0];
3105 if (isector >= nSector)
3106 AliError(Form("Wrong sector number in TOF (%d) !", isector));
3107 Int_t iplate = ind[1];
3108 if (iplate >= nPlate)
3109 AliError(Form("Wrong plate number in TOF (%d) !", iplate));
3110 Int_t istrip = ind[2];
3111
3112 Int_t stripOffset = 0;
3113 switch (iplate) {
3114 case 0:
3115 stripOffset = 0;
3116 break;
3117 case 1:
3118 stripOffset = nStripC;
3119 break;
3120 case 2:
3121 stripOffset = nStripC+nStripB;
3122 break;
3123 case 3:
3124 stripOffset = nStripC+nStripB+nStripA;
3125 break;
3126 case 4:
3127 stripOffset = nStripC+nStripB+nStripA+nStripB;
3128 break;
3129 default:
3130 AliError(Form("Wrong plate number in TOF (%d) !", iplate));
3131 break;
3132 };
3133
3134 Int_t index= (2*(nStripC+nStripB)+nStripA)*isector +
3135 stripOffset +
3136 istrip;
3137
3138 UShort_t volIndex = AliGeomManager::LayerToVolUID(AliGeomManager::kTOF, index);
3139 return volIndex;
3140
3141}
e885fb81 3142*/
e3bd5504 3143//_____________________________________________________________________________
3144
3145void AliTOFClusterFinderV1::GetClusterPars(Int_t *ind, Double_t* pos, Double_t* cov) const
3146{
3147 //
3148 // Starting from the volume indices (ind[5]), for a cluster coming from
3149 // a isolated digits, this function returns:
3150 // the cluster position (pos),
3151 // the cluster covariance matrix elements (cov)
3152 //
3153
3154 //
3155 //we now go in the system of the strip: determine the local coordinates
3156 //
3157 //
3158 // 47---------------------------------------------------0 ^ z
3159 // | | | | | | | | | | | | | | | | | | | | | | | | | | | 1 |
3160 // ----------------------------------------------------- | y going outwards
3161 // | | | | | | | | | | | | | | | | | | | | | | | | | | | 0 | par[0]=0;
3162
3163 // ----------------------------------------------------- |
3164 // x <-----------------------------------------------------
3165
3166 //move to the tracking ref system
3167 Double_t lpos[3] = { (ind[4]-23.5)*AliTOFGeometry::XPad(),
3168 0.,
3169 (ind[3]- 0.5)*AliTOFGeometry::ZPad() };
3170 AliDebug(1, Form(" %f %f %f", lpos[0], lpos[1], lpos[2]));
3171
3172 // Volume ID
e885fb81 3173 UShort_t volIndex = fTOFGeometry->GetAliSensVolIndex(ind[0],ind[1],ind[2]);
3174 //UShort_t volIndex = GetClusterVolIndex(ind);
e3bd5504 3175 const TGeoHMatrix *l2t = AliGeomManager::GetTracking2LocalMatrix(volIndex);
3176
3177 // Get the position in the track ref system
3178 Double_t tpos[3];
3179 l2t->MasterToLocal(lpos,tpos);
3180 pos[0] = tpos[0];
3181 pos[1] = tpos[1];
3182 pos[2] = tpos[2];
3183
3184 //Get the cluster covariance in the track ref system
3185 Double_t lcov[9];
3186 for (Int_t ii=0; ii<9; ii++) lcov[ii] = 0.;
3187
3188 //cluster covariance in the local system:
3189 // sx2 0 0
3190 // 0 0 0
3191 // 0 0 sz2
3192 /*
3193 lcov[4] = 0.42*0.42/3.;
3194 // = ( 5*0.025 (gas gaps thikness)
3195 // + 4*0.040 (internal glasses thickness)
3196 // + 0.5*0.160 (internl PCB)
3197 // + 1*0.055 (external red glass))
3198 */
e885fb81 3199
e3bd5504 3200 lcov[0] = 0.499678;//AliTOFGeometry::XPad()*AliTOFGeometry::XPad()/12.;
3201 lcov[8] = 0.992429;//AliTOFGeometry::ZPad()*AliTOFGeometry::ZPad()/12.;
3202
3203 //cluster covariance in the tracking system:
3204 TGeoHMatrix m;
3205 m.SetRotation(lcov);
3206 m.Multiply(l2t);
3207 m.MultiplyLeft(&l2t->Inverse());
3208 Double_t *tcov = m.GetRotationMatrix();
3209 cov[0] = tcov[0]; cov[1] = tcov[1]; cov[2] = tcov[2];
3210 cov[3] = tcov[4]; cov[4] = tcov[5]; cov[5] = tcov[8];
3211
3212 return;
3213
3214}
3215//_____________________________________________________________________________
3216
e885fb81 3217void AliTOFClusterFinderV1::GetClusterPars(/*Bool_t check,*/ Int_t counter,
e3bd5504 3218 Int_t **ind, Double_t *weight,
3219 Double_t *pos, Double_t *cov) const
3220{
3221 //
3222 // Starting from:
3223 // the volumes indices (ind[counter][5]), for a
3224 // cluster coming from a collection of 'counter'
3225 // digits,
3226 // the volumes weights (weight[counter]), -controlled
3227 // by the 'check' variable control-, for a cluster
3228 // coming from a collection of 'counter' digits,
3229 // the cluster position (pos),
3230 // this function returns:
3231 // the covariance matrix elements (cov) for the found cluster
3232 //
3233
3234 //
3235 // we now go in the system of the strip: determine the local coordinates
3236 //
3237 // 47---------------------------------------------------0 ^ z
3238 // | | | | | | | | | | | | | | | | | | | | | | | | | | | 1 |
3239 // ----------------------------------------------------- | y going outwards
3240 // | | | | | | | | | | | | | | | | | | | | | | | | | | | 0 | par[0]=0;
3241
3242 // ----------------------------------------------------- |
3243 // x <-----------------------------------------------------
3244
3245 for (Int_t ii=0; ii<counter; ii++)
e885fb81 3246 AliDebug(1, Form(" %2d %2d %1d %2d %1d %2d ",
e3bd5504 3247 ii, ind[ii][0], ind[ii][1], ind[ii][2], ind[ii][3], ind[ii][4]));
3248
3249 Float_t posF[3]; for (Int_t ii=0; ii<3; ii++) posF[ii] = (Float_t)pos[ii];
3250 AliDebug(1, Form(" %f %f %f", pos[0], pos[1], pos[2]));
e885fb81 3251
e3bd5504 3252 Int_t detClus[5] = {-1, -1, -1, -1, -1};
e885fb81 3253 fTOFGeometry->GetDetID(posF, detClus);
e3bd5504 3254
3255 // Volume ID
e885fb81 3256 UShort_t volIndex = fTOFGeometry->GetAliSensVolIndex(detClus[0],detClus[1],detClus[2]);
3257 //UShort_t volIndex = GetClusterVolIndex(detClus);
3258 AliDebug(1, Form(" %2d %1d %2d %1d %2d %7i",
e3bd5504 3259 detClus[0], detClus[1], detClus[2], detClus[3], detClus[4], volIndex));
3260
3261 // Get the position in the TOF strip ref system
3262 const TGeoHMatrix *alice2strip = AliGeomManager::GetOrigGlobalMatrix(volIndex);
3263 Double_t ppos[3] = {-1, -1, -1};
3264 alice2strip->MasterToLocal(pos,ppos);
3265 AliDebug(1, Form(" %f %f %f", ppos[0], ppos[1], ppos[2]));
3266
3267
3268 // Get the position in the tracking ref system
3269 const TGeoHMatrix *g2l = AliGeomManager::GetTracking2LocalMatrix(volIndex);
3270 Double_t lpos[3] = {-1, -1, -1};
3271 g2l->MasterToLocal(ppos,lpos);
3272 AliDebug(1, Form(" %f %f %f", lpos[0], lpos[1], lpos[2]));
3273 for (Int_t ii=0; ii<3; ii++) pos[ii] = lpos[ii];
3274
3275 //Get the cluster covariance in the track ref system
3276 Double_t lcov[9];
3277 for (Int_t ii=0; ii<9; ii++) lcov[ii] = 0.;
3278
3279 //cluster covariance in the local system:
3280 // sx2 0 0
3281 // 0 0 0
3282 // 0 0 sz2
3283
3284 // Evaluation of the ovariance matrix elements
e885fb81 3285 TOFclusterError(/*check,*/ counter, ind, weight, ppos, lcov);
e3bd5504 3286
3287 AliDebug(1, Form("lcov[0] = %f, lcov[8] = %f", lcov[0], lcov[8]));
3288
3289 //cluster covariance in the tracking system:
3290 TGeoHMatrix m;
3291 m.SetRotation(lcov);
3292 m.Multiply(g2l);
3293 m.MultiplyLeft(&g2l->Inverse());
3294 Double_t *tcov = m.GetRotationMatrix();
3295 cov[0] = tcov[0]; cov[1] = tcov[1]; cov[2] = tcov[2];
3296 cov[3] = tcov[4]; cov[4] = tcov[5]; cov[5] = tcov[8];
3297
3298 return;
3299
3300}
3301//_____________________________________________________________________________
3302
e885fb81 3303void AliTOFClusterFinderV1::TOFclusterError(/*Bool_t check,*/ Int_t counter,
e3bd5504 3304 Int_t **ind, Double_t *weight,
3305 Double_t ppos[], Double_t lcov[]) const
3306{
3307 //
3308 //
3309 //
3310
e885fb81 3311 //lcov[4] = 0.42*0.42/3.; // cm2
e3bd5504 3312 // = ( 5*0.025 (gas gaps thikness)
3313 // + 4*0.040 (internal glasses thickness)
3314 // + 0.5*0.160 (internl PCB)
3315 // + 1*0.055 (external red glass))
3316
3317
3318 Float_t *delta2X = new Float_t[counter];
3319 for (Int_t ii=0; ii<counter; ii++)
3320 delta2X[ii] =
3321 ((ind[ii][4]-23.5)*AliTOFGeometry::XPad() - ppos[0])*((ind[ii][4]-23.5)*AliTOFGeometry::XPad() - ppos[0]);
3322
3323 Float_t *delta2Z = new Float_t[counter];
3324 for (Int_t ii=0; ii<counter; ii++)
3325 delta2Z[ii] =
3326 ((ind[ii][3]- 0.5)*AliTOFGeometry::ZPad() - ppos[2])*((ind[ii][3]- 0.5)*AliTOFGeometry::ZPad() - ppos[2]);
3327
3328 for (Int_t ii=0; ii<counter; ii++)
e885fb81 3329 AliDebug(1, Form("x[%d] = %f, z[%d] = %f, weight[%d] = %f",
e3bd5504 3330 ii, (ind[ii][4]-23.5)*AliTOFGeometry::XPad(),
3331 ii, (ind[ii][3]- 0.5)*AliTOFGeometry::ZPad(),
3332 ii, weight[ii]
3333 ));
3334 AliDebug(1, Form("xMean = %f, zMean = %f",ppos[0], ppos[2]));
3335
3336
3337 switch (counter)
3338 {
3339
3340 case 2:
3341
3342 if (ind[0][3]==ind[1][3] && TMath::Abs(ind[0][4]-ind[1][4])==1) { //
3343
e885fb81 3344 lcov[8] = 1.02039; // cm2
3345 lcov[0] = 0.0379409; // cm2
3346 /*
e3bd5504 3347 if (check)
e885fb81 3348 lcov[0] = 0.5*0.5; // cm2
e3bd5504 3349 else {
3350 if (weight[0]==weight[1])
e885fb81 3351 lcov[0] = 0.0379409; // cm2
e3bd5504 3352 else
e885fb81 3353 lcov[0] = TMath::Mean(counter, delta2X, weight); // cm2
e3bd5504 3354 }
e885fb81 3355 */
e3bd5504 3356
3357 }
3358
3359 else if (ind[0][4]==ind[1][4] && TMath::Abs(ind[0][3]-ind[1][3])==1) {//
3360
e885fb81 3361 lcov[0] = 0.505499; // cm2
3362 lcov[8] = 0.0422046; // cm2
3363 /*
e3bd5504 3364 if (check)
e885fb81 3365 lcov[8] = 0.5*0.5; // cm2
e3bd5504 3366 else {
3367 if (weight[0]==weight[1])
e885fb81 3368 lcov[8] = 0.0422046; // cm2
e3bd5504 3369 else
e885fb81 3370 lcov[8] = TMath::Mean(counter, delta2Z, weight); // cm2
e3bd5504 3371 }
e885fb81 3372 */
e3bd5504 3373
3374 }
3375
3376 break;
3377
3378 case 3:
e885fb81 3379 lcov[0] = 0.0290677; // cm2
3380 lcov[8] = 0.0569726; // cm2
3381 /*
e3bd5504 3382 if (check) {
e885fb81 3383 lcov[0] = 0.5*0.5; // cm2
3384 lcov[8] = 0.5*0.5; // cm2
e3bd5504 3385 }
3386 else {
e885fb81 3387 if (weight[0]==weight[1] && weight[0]==weight[2]) {
3388 lcov[0] = 0.0290677; // cm2
3389 lcov[8] = 0.0569726; // cm2
3390 }
e3bd5504 3391 else {
e885fb81 3392 lcov[0] = TMath::Mean(counter, delta2X, weight); // cm2
3393 lcov[8] = TMath::Mean(counter, delta2Z, weight); // cm2
3394 }
e3bd5504 3395
e885fb81 3396 }
3397 */
e3bd5504 3398
3399 break;
3400
3401 case 4:
e885fb81 3402 lcov[0] = 0.0223807; // cm2
3403 lcov[8] = 0.0438662; // cm2
3404 /*
e3bd5504 3405 if (check) {
e885fb81 3406 lcov[0] = 0.5*0.5; // cm2
3407 lcov[8] = 0.5*0.5; // cm2
e3bd5504 3408 }
3409 else {
e885fb81 3410 if (weight[0]==weight[1] && weight[0]==weight[2] && weight[0]==weight[3]) {
3411 lcov[0] = 0.0223807; // cm2
3412 lcov[8] = 0.0438662; // cm2
3413 }
e3bd5504 3414 else {
e885fb81 3415 lcov[0] = TMath::Mean(counter, delta2X, weight); // cm2
3416 lcov[8] = TMath::Mean(counter, delta2Z, weight); // cm2
3417 }
e3bd5504 3418
e885fb81 3419 }
3420 */
e3bd5504 3421
3422 break;
3423
3424 }
3425
e885fb81 3426 delete [] delta2Z;
3427 delete [] delta2X;
3428
e3bd5504 3429}
3430//_____________________________________________________________________________
3431
3432Bool_t AliTOFClusterFinderV1::MakeSlewingCorrection(Int_t *detectorIndex,
3433 Int_t tofDigitToT,
3434 Int_t tofDigitTdc,
3435 Int_t &tdcCorr)
3436{
3437 //
3438 // This funtion makes the following:
3439 //
3440 // - if at least one of the three status (Pulser/Noise/HW) is
3441 // bad, is sets the status of electronic channel, corresponding to the
3442 // volume identified by detectorIndex, as kFALSE;
3443 // - if offline calibration is in the valid status, it performs the
3444 // slewing correction. In particular, by taking into account:
3445 // * the measured tot and tof values (tofDigitToT and tofDigitTdc,
3446 // respectively);
3447 // * the six parameters of 5th order polynomial used
3448 // to fit the tofVStot scatter plot,
3449 // it returns the corrected tof value, i.e. tdcCorr value.
3450 //
3451
3452 Bool_t output = kTRUE;
3453
3454 Double_t timeCorr;
3455 Int_t jj;
3456
3457 //AliInfo(" Calibrating TOF Digits: ");
3458
e885fb81 3459 AliTOFChannelOnlineArray *calDelay = fTOFcalib->GetTOFOnlineDelay();
3460 AliTOFChannelOnlineStatusArray *calStatus = fTOFcalib->GetTOFOnlineStatus();
e3bd5504 3461
3462 TObjArray *calTOFArrayOffline = fTOFcalib->GetTOFCalArrayOffline();
3463
3464 Int_t index = AliTOFGeometry::GetIndex(detectorIndex);
3465
3466 UChar_t statusPulser = calStatus->GetPulserStatus(index);
3467 UChar_t statusNoise = calStatus->GetNoiseStatus(index);
3468 UChar_t statusHW = calStatus->GetHWStatus(index);
3469 UChar_t status = calStatus->GetStatus(index);
3470
3471 //check the status, also unknown is fine!!!!!!!
3472
e885fb81 3473 AliDebug(2, Form(" Status for channel %d = %d",index, (Int_t)status));
e3bd5504 3474 if((statusPulser & AliTOFChannelOnlineStatusArray::kTOFPulserBad)==(AliTOFChannelOnlineStatusArray::kTOFPulserBad)||(statusNoise & AliTOFChannelOnlineStatusArray::kTOFNoiseBad)==(AliTOFChannelOnlineStatusArray::kTOFNoiseBad)||(statusHW & AliTOFChannelOnlineStatusArray::kTOFHWBad)==(AliTOFChannelOnlineStatusArray::kTOFHWBad)){
e885fb81 3475 AliDebug(2, Form(" Bad Status for channel %d",index));
e3bd5504 3476 //fTofClusters[ii]->SetStatus(kFALSE); //odd convention, to avoid conflict with calibration objects currently in the db (temporary solution).
3477 output = kFALSE;
3478 }
3479 else
e885fb81 3480 AliDebug(2, Form(" Good Status for channel %d",index));
e3bd5504 3481
3482 // Get Rough channel online equalization
3483 Double_t roughDelay = (Double_t)calDelay->GetDelay(index); // in ns
3484 AliDebug(2,Form(" channel delay (ns) = %f", roughDelay));
3485 // Get Refined channel offline calibration parameters
3486 TString validity = (TString)fTOFcalib->GetOfflineValidity();
3487 if (validity.CompareTo("valid")==0) {
3488 AliTOFChannelOffline * calChannelOffline = (AliTOFChannelOffline*)calTOFArrayOffline->At(index);
3489 Double_t par[6];
3490 for (jj = 0; jj<6; jj++)
3491 par[jj] = (Double_t)calChannelOffline->GetSlewPar(jj);
3492
3493 AliDebug(2,Form(" Calib Pars = %f, %f, %f, %f, %f, %f ",par[0],par[1],par[2],par[3],par[4],par[5]));
e885fb81 3494 AliDebug(2,Form(" The ToT and Time, uncorr (counts) = %d , %d", tofDigitToT, tofDigitTdc));
e3bd5504 3495 Double_t tToT = (Double_t)(tofDigitToT*AliTOFGeometry::ToTBinWidth());
3496 tToT*=1.E-3; //ToT in ns
3497 AliDebug(2,Form(" The ToT and Time, uncorr (ns)= %e, %e",tofDigitTdc*AliTOFGeometry::TdcBinWidth()*1.E-3,tToT));
3498 timeCorr = par[0] + tToT*(par[1] + tToT*(par[2] + tToT*(par[3] + tToT*(par[4] + tToT*par[5])))); // the time correction (ns)
3499 }
3500 else
3501 timeCorr = roughDelay; // correction in ns
3502
3503 AliDebug(2,Form(" The ToT and Time, uncorr (ns)= %e, %e",tofDigitTdc*AliTOFGeometry::TdcBinWidth()*1.E-3,tofDigitToT*AliTOFGeometry::ToTBinWidth()));
3504 AliDebug(2,Form(" The time correction (ns) = %f", timeCorr));
3505 timeCorr = (Double_t)(tofDigitTdc)*AliTOFGeometry::TdcBinWidth()*1.E-3-timeCorr;//redefine the time
3506 timeCorr *= 1.E3;
3507 AliDebug(2,Form(" The channel time, corr (ps)= %e",timeCorr ));
3508 tdcCorr = (Int_t)(timeCorr/AliTOFGeometry::TdcBinWidth()); //the corrected time (tdc counts)
3509
3510 return output;
3511
3512}
3513//______________________________________________________________________________
3514
3515void AliTOFClusterFinderV1::Digits2RecPoints(Int_t iEvent)
3516{
3517 //
3518 // Converts digits to recpoints for TOF
3519 //
3520
3521 TStopwatch stopwatch;
3522 stopwatch.Start();
3523
3524 fRunLoader->GetEvent(iEvent);
3525
3526 AliLoader *localTOFLoader = (AliLoader*)fRunLoader->GetLoader("TOFLoader");
3527
3528 TTree * localTreeD = (TTree*)localTOFLoader->TreeD();
3529 if (localTreeD == 0x0)
3530 AliFatal("Can not get TreeD");
3531
3532 TBranch *branch = localTreeD->GetBranch("TOF");
3533 if (!branch) {
3534 AliError("Can't get the branch with the TOF digits !");
3535 return;
3536 }
3537
3538 TTree *localTreeR = (TTree*)localTOFLoader->TreeR();
3539 if (localTreeR == 0x0)
3540 {
3541 localTOFLoader->MakeTree("R");
3542 localTreeR = localTOFLoader->TreeR();
3543 }
3544
3545 Digits2RecPoints(localTreeD, localTreeR);
3546
3547 //localTOFLoader = fRunLoader->GetLoader("TOFLoader");
3548 localTOFLoader->WriteRecPoints("OVERWRITE");
3549
e885fb81 3550 AliDebug(1, Form("Execution time to read TOF digits and to write TOF clusters for the event number %d: R:%.4fs C:%.4fs",
e3bd5504 3551 iEvent, stopwatch.RealTime(),stopwatch.CpuTime()));
3552
3553}
3554//______________________________________________________________________________
3555
3556void AliTOFClusterFinderV1::Digits2RecPoints(Int_t iEvent, AliRawReader *rawReader)
3557{
3558 //
3559 // Converts RAW data to recpoints for TOF
3560 //
3561
3562 TStopwatch stopwatch;
3563 stopwatch.Start();
3564
3565 fRunLoader->GetEvent(iEvent);
3566
e885fb81 3567 AliDebug(2,Form(" Event number %2d ", iEvent));
e3bd5504 3568
3569 AliLoader *localTOFLoader = (AliLoader*)fRunLoader->GetLoader("TOFLoader");
3570
3571 TTree *localTreeR = localTOFLoader->TreeR();
3572
3573 if (localTreeR == 0x0){
3574 localTOFLoader->MakeTree("R");
3575 localTreeR = localTOFLoader->TreeR();
3576 }
3577
3578 Digits2RecPoints(rawReader, localTreeR);
3579
e885fb81 3580 AliDebug(1, Form("Execution time to read TOF raw data and to write TOF clusters for the event number %d: R:%.4fs C:%.4fs",
e3bd5504 3581 iEvent, stopwatch.RealTime(),stopwatch.CpuTime()));
3582
3583}
3584//______________________________________________________________________________
3585
3586void AliTOFClusterFinderV1::Raw2Digits(Int_t iEvent, AliRawReader *rawReader)
3587{
3588 //
3589 // Converts RAW data to MC digits for TOF
3590 //
3591
3592
3593 TStopwatch stopwatch;
3594 stopwatch.Start();
3595
3596 fRunLoader->GetEvent(iEvent);
3597
e885fb81 3598 AliDebug(2,Form(" Event number %2d ", iEvent));
e3bd5504 3599
3600 AliLoader *localTOFLoader = (AliLoader*)fRunLoader->GetLoader("TOFLoader");
3601
3602 TTree *localTreeD = localTOFLoader->TreeD();
3603
3604 if (localTreeD == 0x0){
3605 localTOFLoader->MakeTree("D");
3606 localTreeD = localTOFLoader->TreeD();
3607 }
3608
3609 Raw2Digits(rawReader, localTreeD);
3610
e885fb81 3611 AliDebug(1, Form("Execution time to read TOF raw data and to write TOF clusters for the event number %d: R:%.4fs C:%.4fs",
e3bd5504 3612 iEvent, stopwatch.RealTime(),stopwatch.CpuTime()));
3613
3614}
3615//______________________________________________________________________________
3616
3617void AliTOFClusterFinderV1::AverageCalculations(Int_t number, Float_t *interestingX,
3618 Float_t *interestingY, Float_t *interestingZ,
3619 Double_t *interestingTOF, Double_t *interestingTOT,
3620 Double_t *interestingADC, Double_t *interestingWeight,
3621 Int_t *parTOF, Double_t *posClus, Bool_t &check)
3622{
3623 //
3624 //
3625 //
3626
e3bd5504 3627 Double_t tofAverage = 0.;
3628 Double_t totAverage = 0.;
3629 Double_t adcAverage = 0.;
3630
3631 check = kFALSE;
3632 Int_t ii=-1;
e885fb81 3633 for (ii=number-1; ii>=0; ii--) check=check||(interestingWeight[ii]==0 || interestingWeight[ii]==-1);
e3bd5504 3634
3635 if (check) {
3636
3637 posClus[0] = TMath::Mean(number, interestingX);
3638 posClus[1] = TMath::Mean(number, interestingY);
3639 posClus[2] = TMath::Mean(number, interestingZ);
3640 tofAverage = TMath::Mean(number, interestingTOF);
3641 totAverage = TMath::Mean(number, interestingTOT);
3642 adcAverage = TMath::Mean(number, interestingADC);
3643
3644 }
3645 else {
3646
3647 posClus[0] = TMath::Mean(number, interestingX, interestingWeight);
3648 posClus[1] = TMath::Mean(number, interestingY, interestingWeight);
3649 posClus[2] = TMath::Mean(number, interestingZ, interestingWeight);
3650 tofAverage = TMath::Mean(number, interestingTOF, interestingWeight);
3651 totAverage = TMath::Mean(number, interestingTOT, interestingWeight);
3652 adcAverage = TMath::Mean(number, interestingADC, interestingWeight);
3653
3654 }
3655
3656 parTOF[0] = Int_t(tofAverage);
e885fb81 3657 parTOF[1] = Int_t(totAverage);
3658 parTOF[2] = Int_t(adcAverage);
3659 parTOF[3] = Int_t(tofAverage);//tofND
3660 parTOF[4] = Int_t(tofAverage);//tofRAW
e3bd5504 3661
e3bd5504 3662}