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