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