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