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