Calling check of overlaps only in debug mode
[u/mrichter/AliRoot.git] / TRD / AliTRDtrigger.cxx
CommitLineData
0ee00e25 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// //
18// TRD trigger class //
19// //
20///////////////////////////////////////////////////////////////////////////////
21
22#include <TTree.h>
23#include <TBranch.h>
24#include <TMatrixD.h>
25
26#include "AliLog.h"
27#include "AliRun.h"
28#include "AliRunLoader.h"
29#include "AliLoader.h"
30#include "AliHeader.h"
31#include "AliRawReader.h"
32
33#include "AliTRDdigitsManager.h"
34#include "AliTRDgeometry.h"
35#include "AliTRDdataArrayI.h"
36#include "AliTRDcalibDB.h"
37#include "AliTRDCommonParam.h"
38#include "Cal/AliTRDCalPIDLQ.h"
39#include "AliTRDrawData.h"
40
41#include "AliTRDtrigger.h"
42#include "AliTRDmcmTracklet.h"
43#include "AliTRDtrigParam.h"
44#include "AliTRDmcm.h"
45
46ClassImp(AliTRDtrigger)
47ClassImp(AliTRDltuTracklet)
48ClassImp(AliTRDgtuTrack)
49ClassImp(AliTRDmodule)
50
51//_____________________________________________________________________________
52AliTRDltuTracklet::AliTRDltuTracklet(Int_t det,
53 Int_t row,
54 Float_t rowz,
55 Float_t slope,
56 Float_t offset,
57 Float_t time,
58 Int_t ncl,
59 Int_t label,
60 Float_t q)
61{
62 //
63 // AliTRDltuTracklet constructor
64 //
65
66 fDetector = det;
67 fRow = row;
68 fRowz = rowz;
69 fSlope = slope;
70 fX = time;
71 fY = offset;
72 fNclusters = ncl;
73 fLabel = label;
74 fQ = q;
75
76}
77
78//_____________________________________________________________________________
79Float_t AliTRDltuTracklet::GetPt(Float_t field)
80{
81 // transverse momentum calculation
82 // curvature R = (fX*fX + fY*fY) / (2 * sin(alpha))
83 // alpha = angle deviation from "infinite momentum"
84 //
85 // consistent with AliTRDmcmTracklet::GetPt(...)
86
87 Float_t InfSlope = TMath::ATan(fY/fX)/TMath::Pi()*180.0;
88 Float_t alpha = fSlope - InfSlope;
89 Float_t R = TMath::Sqrt(fX*fX + fY*fY)/(2.0*TMath::Sin(alpha/180.0*TMath::Pi()));
90
91 Float_t Pt = 0.3 * field * 0.01 * R;
92
93 return Pt;
94
95}
96
97//_____________________________________________________________________________
98Int_t AliTRDltuTracklet::Compare(const TObject * o) const
99{
100 //
101 // compare two LTU tracklets according to the intercept point Y1
102 //
103
104 AliTRDltuTracklet *ltutrk = (AliTRDltuTracklet*)o;
105
106 if (fRow != ltutrk->fRow) return +1;
107 if (fDetector != ltutrk->fDetector) return +1;
108
109 if (fY < ltutrk->fY) return -1;
110 if (fY == ltutrk->fY) return 0;
111
112 return 1;
113
114}
115
116//_____________________________________________________________________________
117Float_t AliTRDltuTracklet::GetYproj(Float_t xpl)
118{
119
120 Float_t Yproj;
121
122 Yproj = fY + TMath::Tan(fSlope/180.0*TMath::Pi()) * (xpl - fX);
123
124 return Yproj;
125
126}
127
128//_____________________________________________________________________________
129Float_t AliTRDltuTracklet::GetZproj(Float_t xpl)
130{
131
132 Float_t Zproj;
133
134 Zproj = fRowz * xpl / fX;
135
136 return Zproj;
137
138}
139
140//_____________________________________________________________________________
141AliTRDgtuTrack::AliTRDgtuTrack()
142{
143
144 fYproj = 0.0;
145 fZproj = 0.0;
146 fSlope = 0.0;
147 fDetector = -1;
148 fNtracklets = 0;
149 fNplanes = 0;
150 fNclusters = 0;
151 fPt = 0.0;
152 fPhi = 0.0;
153 fEta = 0.0;
154 fLabel = -1;
155 fPID = 0.0;
156 fIsElectron = kFALSE;
157
158 fTracklets = new TObjArray(400);
159
160}
161
162//_____________________________________________________________________________
163AliTRDgtuTrack::AliTRDgtuTrack(const AliTRDgtuTrack& track):
164 TObject(track),
165 fYproj(track.fYproj),
166 fZproj(track.fZproj),
167 fSlope(track.fSlope),
168 fDetector(track.fDetector),
169 fNtracklets(track.fNtracklets),
170 fNplanes(track.fNplanes),
171 fNclusters(track.fNclusters),
172 fPt(track.fPt),
173 fPhi(track.fPhi),
174 fEta(track.fEta),
175 fLabel(track.fLabel),
176 fPID(track.fPID),
177 fIsElectron(track.fIsElectron)
178{
179 //
180 // copy contructor
181 //
182
183 fTracklets = NULL;
184
185}
186
187//_____________________________________________________________________________
188void AliTRDgtuTrack::AddTracklet(AliTRDltuTracklet *trk)
189{
190
191 Tracklets()->Add(trk);
192
193}
194
195//_____________________________________________________________________________
196AliTRDltuTracklet* AliTRDgtuTrack::GetTracklet(Int_t pos)
197{
198
199 if (fTracklets == 0) return 0;
200 void * trk = fTracklets->UncheckedAt(pos);
201 if (trk == 0) return 0;
202
203 return (AliTRDltuTracklet*)trk;
204
205}
206
207//_____________________________________________________________________________
208Int_t AliTRDgtuTrack::Compare(const TObject * o) const
209{
210
211 AliTRDgtuTrack *gtutrack = (AliTRDgtuTrack*)o;
212
213 if (fYproj < gtutrack->GetYproj()) return -1;
214 if (fYproj == gtutrack->GetYproj()) return 0;
215
216 return +1;
217
218}
219
220//_____________________________________________________________________________
221void AliTRDgtuTrack::Reset()
222{
223
224 fYproj = 0.0;
225 fZproj = 0.0;
226 fSlope = 0.0;
227 fDetector = -1;
228 fNtracklets = 0;
229 fNplanes = 0;
230 fNclusters = 0;
231 fPt = 0.0;
232 fPhi = 0.0;
233 fEta = 0.0;
234 fLabel = -1;
235 fPID = 0.0;
236 fIsElectron = kFALSE;
237
238}
239
240//_____________________________________________________________________________
241void AliTRDgtuTrack::Track(Float_t xpl, Float_t field)
242{
243
244 AliTRDltuTracklet *trk;
245 Int_t nTracklets = GetNtracklets();
246 Float_t fC[kNmaxTrk][3]; // X, Y, Z coordinates of segments
247
248 fYproj = 0.0;
249 fZproj = 0.0;
250 fSlope = 0.0;
251 fNclusters = 0;
252 fNplanes = 0;
253 fNtracklets = GetNtracklets();
254 Int_t InDetector[kNplan];
255 for (Int_t i = 0; i < kNplan; i++) InDetector[i] = -1;
256 Int_t iDet, nDet = 0;
257 Bool_t NewDetector;
258 for (Int_t i = 0; i < nTracklets; i++) {
259
260 trk = GetTracklet(i);
261 fYproj += trk->GetYproj(xpl);
262 fZproj += trk->GetZproj(xpl);
263 fSlope += trk->GetSlope();
264 fNclusters += trk->GetNclusters();
265 iDet = trk->GetDetector();
266
267 NewDetector = kTRUE;
268 for (Int_t id = 0; id < nDet; id++) {
269 if (iDet == InDetector[id]) {
270 NewDetector = kFALSE;
271 break;
272 }
273 }
274 if (NewDetector) {
275 InDetector[nDet++] = iDet;
276 fNplanes++;
277 }
278
279 fC[i][0] = trk->GetTime0();
280 fC[i][1] = trk->GetOffset();
281 fC[i][2] = trk->GetRowz();
282
283 }
284 fYproj /= (Float_t)nTracklets;
285 fZproj /= (Float_t)nTracklets;
286 fSlope /= (Float_t)nTracklets;
287
288 Float_t X[kNmaxTrk+1], Y[kNmaxTrk+1], Z[kNmaxTrk+1];
289 Bool_t count[kNmaxTrk];
290 for (Int_t i = 0; i < kNmaxTrk; i++) count[i] = kFALSE;
291
292 Int_t iXmin = -1;
293 Int_t j = 0;
294 X[0] = Y[0] = Z[0] = 0.0;
295 while (j < nTracklets) {
296 iXmin = -1;
297 for (Int_t i = 0; i < nTracklets; i++) {
298 if (count[i]) continue;
299 if (iXmin == -1) {
300 iXmin = i;
301 continue;
302 }
303 if (fC[i][0] < fC[iXmin][0]) iXmin = i;
304 }
305 X[j+1] = fC[iXmin][0];
306 Y[j+1] = fC[iXmin][1];
307 Z[j+1] = fC[iXmin][2];
308 j++;
309 count[iXmin] = kTRUE;
310 }
311
312 TMatrixD smatrix(2,2);
313 TMatrixD sums(2,1);
314 TMatrixD res(2,1);
315 Double_t x, y;
316 Float_t A, B;
317
318 smatrix.Zero();
319 sums.Zero();
320 for (Int_t i = 0; i < nTracklets; i++) {
321 x = (Double_t)X[i+1];
322 y = (Double_t)Y[i+1];
323 smatrix(0,0) += 1.0;
324 smatrix(1,1) += x*x;
325 smatrix(0,1) += x;
326 smatrix(1,0) += x;
327 sums(0,0) += y;
328 sums(1,0) += x*y;
329 }
330 res = smatrix.Invert() * sums;
331 A = res(0,0);
332 B = res(1,0);
333
334 Float_t dist = AliTRDgeometry::GetTime0(1) - AliTRDgeometry::GetTime0(0);
335
336 Float_t fX1 = X[1] + dist * (Float_t)(nTracklets-1)/6.0;
337 Float_t fY1 = A + B * fX1;
338 Float_t fX2 = X[nTracklets] - dist * (Float_t)(nTracklets-1)/6.0;
339 Float_t fY2 = A + B * fX2;
340 Float_t D12 = TMath::Sqrt((fX2-fX1)*(fX2-fX1)+(fY2-fY1)*(fY2-fY1));
341 Float_t Alpha = TMath::ATan(fY2/fX2) - TMath::ATan(fY1/fX1);
342 Float_t R = (D12/2.0)/TMath::Sin(Alpha);
343
344 fPt = 0.3 * field * 0.01 * R;
345
346 Float_t D1 = fX1*fX1+fY1*fY1;
347 Float_t D2 = fX2*fX2+fY2*fY2;
348 Float_t D = fX1*fY2-fX2*fY1;
349
350 Float_t Xc = (D1*fY2-D2*fY1)/(2*D);
351 Float_t Yc = (D2*fX1-D1*fX2)/(2*D);
352
353 if (Yc != 0.0) {
354 fPhi = TMath::ATan(Xc/Yc);
355 } else {
356 fPhi = TMath::PiOver2();
357 }
358
359 fPhi *= 180.0/TMath::Pi();
360
361 smatrix.Zero();
362 sums.Zero();
363 for (Int_t i = 0; i < nTracklets+1; i++) {
364 x = (Double_t)Z[i];
365 y = (Double_t)X[i];
366 smatrix(0,0) += 1.0;
367 smatrix(1,1) += x*x;
368 smatrix(0,1) += x;
369 smatrix(1,0) += x;
370 sums(0,0) += y;
371 sums(1,0) += x*y;
372 }
373 res = smatrix.Invert() * sums;
374 A = res(0,0);
375 B = res(1,0);
376 Float_t theta = TMath::ATan(B);
377
378 if (theta < 0.0) theta = TMath::Pi() + theta;
379
380 if (theta == 0.0) {
381 fEta = 0.0;
382 } else {
383 fEta = -TMath::Log(TMath::Tan(theta/2.0));
384 }
385
386}
387
388//_____________________________________________________________________________
389void AliTRDgtuTrack::MakePID()
390{
391
392 //
393 // Electron likelihood signal
394 //
395
396 AliTRDcalibDB* calibration = AliTRDcalibDB::Instance();
397 if (!calibration)
398 {
399 Error("MakePID","No instance of AliTRDcalibDB.");
400 return;
401 }
402 const AliTRDCalPIDLQ *pd = calibration->GetPIDLQObject();
403
404 AliTRDltuTracklet *trk;
405 Int_t nTracklets = GetNtracklets();
406 Int_t det, pla;
407 Float_t sl, th, q, probPio = 1.0, probEle = 1.0;
408 for (Int_t i = 0; i < nTracklets; i++) {
409
410 trk = GetTracklet(i);
411
412 sl = TMath::Abs(trk->GetSlope()); // tracklet inclination in X-y plane
413 th = trk->GetRowz()/trk->GetTime0(); // tracklet inclination in X-z plane
414 th = TMath::ATan(TMath::Abs(th));
415
416 q = trk->GetQ()
417 * TMath::Cos(sl/180.0*TMath::Pi())
418 * TMath::Cos(th/180.0*TMath::Pi());
419
420 det = trk->GetDetector();
421 pla = trk->GetPlane(det);
422
423 // unclear yet factor to match the PS distributions = 5.8
424 // not explained only by the tail filter ...
425
426 // AliRoot v4-03-07 , v4-03-Release
427 //q = q * 5.8;
428
429 // Temporary (B. Vulpescu):
430 // The charge distributions do not match the new changes in simulation (A. Bercuci),
431 // which are nevertheless now in agreement with the beam tests.
432 // Some tricks will be used to still have reasonable results
433 // To match the existing charge distributions, the charge per layer has to be modified
434 // as folows:
435 /*
436 if (k == 0) {
437 // electrons
438 q = 4.3 * q + 95.0;
439 } else {
440 // others
441 q = 4.2 * q + 70.0;
442 }
443 */
444 // Since at tracking time we have no information on the particle type, we will modify
445 // instead the charge distributions accordingly. This will slow down the sampling.
446 // The modified distributions are in TRDdEdxHistogramsV1_BV.root and the CDB has
447 // been regenerated with AliTRDCreateDummyCDB.C
448 // The new PIDLQ data base has the version :
449 // I-AliCDBLocal::Get: CDB object retrieved: path "TRD/Calib/PIDLQ"; run range [0,0];
450 // version v0_s1
451
452 probEle *= pd->GetProbability(0,TMath::Abs(fPt),q);
453 probPio *= pd->GetProbability(2,TMath::Abs(fPt),q);
454
455 }
456
457 if ((probEle+probPio) > 0.0) {
458 fPID = probEle/(probEle+probPio);
459 } else {
460 fPID = 0.0;
461 }
462
463 // Thresholds for LQ cut at 90% electron efficiency (from AliRoot v4-03-07)
464 // P [GeV/c] fPIDcut (between 0 and 1)
465 // 2 0.925
466 // 3 0.915
467 // 4 0.875
468 // 5 0.855
469 // 6 0.845
470 // 8 0.785
471 // 10 0.735
472 //
473 // PIDcut = 0.978 - 0.024 * P[GeV/c]
474 //Float_t PIDcut = 0.978 - 0.024 * TMath::Abs(fPt);
475
476 // HEAD28Mar06 with modified distributions (A. Bercuci changes, P. Shukla distributions)
477 Float_t PIDcut = 0.829 - 0.032 * TMath::Abs(fPt);
478
479 fIsElectron = kFALSE;
480 if (fPID >= PIDcut) {
481 fIsElectron = kTRUE;
482 }
483
484}
485
486//_____________________________________________________________________________
487void AliTRDgtuTrack::CookLabel()
488{
489
490 //
491 // Cook the track label from tracklets labels
492 //
493
494 AliTRDltuTracklet *trk;
495
496 const Int_t kMaxTracks = 10;
497 Int_t trackLabel[kMaxTracks];
498 Int_t trackCount[kMaxTracks];
499 for (Int_t it = 0; it < kMaxTracks; it++) {
500 trackLabel[it] = -1;
501 trackCount[it] = 0;
502 }
503
504 Bool_t counted;
505 Int_t label, nTracks = 0;
506 for (Int_t itrk = 0; itrk < fNtracklets; itrk++) {
507
508 trk = GetTracklet(itrk);
509
510 if (trk->GetLabel() == -1) continue;
511
512 label = trk->GetLabel();
513
514 counted = kFALSE;
515 for (Int_t it = 0; it < nTracks; it++) {
516 if (label == trackLabel[it]) {
517 trackCount[it]++;
518 counted = kTRUE;
519 break;
520 }
521 }
522 if (!counted) {
523 trackLabel[nTracks] = label;
524 trackCount[nTracks]++;
525 nTracks++;
526 if (nTracks == kMaxTracks) {
527 Warning("CookLabel","Too many tracks for this tracklet.");
528 nTracks--;
529 break;
530 }
531 }
532
533 }
534
535 Float_t frac = 4.0/5.0;
536 for (Int_t it = 0; it < kMaxTracks; it++) {
537 if (trackCount[it] >= (Int_t)(frac*fNtracklets)) {
538 fLabel = trackLabel[it];
539 break;
540 }
541 }
542
543}
544
545//_____________________________________________________________________________
546AliTRDmodule::AliTRDmodule(AliTRDtrigParam *trigp)
547{
548
549 //
550 // AliTRDmodule default constructor
551 //
552
553 fDeltaY = trigp->GetDeltaY();
554 fDeltaS = trigp->GetDeltaS();
555 fXprojPlane = trigp->GetXprojPlane();
556 fField = trigp->GetField();
557 fLTUtrk = 0;
558 fGTUtrk = 0;
559 fTracklets = new TObjArray(400);
560 fTracks = new TObjArray(400);
561
562}
563
564//_____________________________________________________________________________
565void AliTRDmodule::Reset()
566{
567
568 ResetTracklets();
569 ResetTracks();
570
571 fLTUtrk = 0;
572 fGTUtrk = 0;
573 fTracklets = new TObjArray(400);
574 fTracks = new TObjArray(400);
575
576}
577
578//_____________________________________________________________________________
579void AliTRDmodule::ResetTracks()
580{
581
582 if (fTracks) {
583
584 AliTRDgtuTrack *trk;
585 for (Int_t i = 0; i < GetNtracks(); i++) {
586
587 trk = GetTrack(i);
588 trk->Reset();
589
590 }
591
592 fTracks->Delete();
593
594 }
595
596}
597
598//_____________________________________________________________________________
599AliTRDgtuTrack* AliTRDmodule::GetTrack(Int_t pos)
600{
601
602 if (fTracks == 0) return 0;
603 void * trk = fTracks->UncheckedAt(pos);
604 if (trk == 0) return 0;
605
606 return (AliTRDgtuTrack*)trk;
607
608}
609
610//_____________________________________________________________________________
611void AliTRDmodule::RemoveTrack(Int_t pos)
612{
613
614 if (fTracks == 0) return;
615 fTracks->RemoveAt(pos);
616 fTracks->Compress();
617
618}
619
620//_____________________________________________________________________________
621void AliTRDmodule::AddTracklet(Int_t det,
622 Int_t row,
623 Float_t rowz,
624 Float_t slope,
625 Float_t offset,
626 Float_t time,
627 Int_t ncl,
628 Int_t label,
629 Float_t q)
630{
631
632 fLTUtrk = new AliTRDltuTracklet(det,row,rowz,slope,offset,time,ncl,label,q);
633
634 Tracklets()->Add(fLTUtrk);
635
636}
637
638//_____________________________________________________________________________
639AliTRDltuTracklet* AliTRDmodule::GetTracklet(Int_t pos)
640{
641
642 if (fTracklets == 0) return 0;
643 void * trk = fTracklets->UncheckedAt(pos);
644 if (trk == 0) return 0;
645
646 return (AliTRDltuTracklet*)trk;
647
648}
649
650//_____________________________________________________________________________
651void AliTRDmodule::RemoveTracklet(Int_t pos)
652{
653
654 if (fTracklets == 0) return;
655 fTracklets->RemoveAt(pos);
656 fTracklets->Compress();
657
658}
659
660//_____________________________________________________________________________
661void AliTRDmodule::RemoveMultipleTracklets()
662{
663
664 Float_t OffDiffMin = 0.5; // [cm]
665
666 AliTRDltuTracklet *trk;
667 Int_t Det1, Det2, Row1, Row2, Ncl1, Ncl2, Label1, Label2;
668 Float_t Off1, Off2;
669 Int_t itrk = 0;
670 while (itrk < (GetNtracklets()-1)) {
671
672 trk = GetTracklet(itrk );
673
674 Det1 = trk->GetDetector();
675 Row1 = trk->GetRow();
676 Off1 = trk->GetOffset();
677 Ncl1 = trk->GetNclusters();
678 Label1 = trk->GetLabel();
679
680 trk = GetTracklet(itrk+1);
681
682 Det2 = trk->GetDetector();
683 Row2 = trk->GetRow();
684 Off2 = trk->GetOffset();
685 Ncl2 = trk->GetNclusters();
686 Label2 = trk->GetLabel();
687
688 if (Det1 == Det2 && Row1 == Row2) {
689 if ((Off2-Off1) < OffDiffMin) {
690 if (Ncl1 < Ncl2) {
691 RemoveTracklet(itrk );
692 } else {
693 RemoveTracklet(itrk+1);
694 }
695 }
696 }
697
698 itrk++;
699
700 }
701
702}
703
704//_____________________________________________________________________________
705void AliTRDmodule::SortZ(Int_t cha)
706{
707
708 InitZLUT();
709
710 AliTRDltuTracklet *trk;
711 Int_t row, pla, det;
712 for (Int_t iTrk = 0; iTrk < GetNtracklets(); iTrk++) {
713
714 trk = GetTracklet(iTrk);
715
716 row = trk->GetRow();
717 det = trk->GetDetector();
718 pla = trk->GetPlane(det);
719
720 for (Int_t iZchan = 0; iZchan < kNsubZchan; iZchan++) {
721 if (fZChannelMap[cha][iZchan][pla][row] == 1) {
722 fZtrkid[pla][fZnchan[pla][iZchan]][iZchan] = iTrk;
723 fZnchan[pla][iZchan]++;
724 }
725 }
726
727 }
728
729}
730
731//_____________________________________________________________________________
732void AliTRDmodule::InitZLUT()
733{
734
735 for (Int_t iPlan = 0; iPlan < AliTRDgeometry::Nplan(); iPlan++) {
736 for (Int_t i = 0; i < kNsubZchan; i++) {
737 fZnchan[iPlan][i] = 0;
738 for (Int_t j = 0; j < kNmaxZchan; j++) {
739 fZtrkid[iPlan][j][i] = -1;
740 }
741 }
742 }
743
744}
745
746//_____________________________________________________________________________
747void AliTRDmodule::FindTracks()
748{
749
750 for (Int_t iZchan = 0; iZchan < kNsubZchan; iZchan++) {
751 FindTracksCombi(iZchan);
752 }
753
754}
755
756//_____________________________________________________________________________
757void AliTRDmodule::FindTracksCombi(Int_t zchan)
758{
759
760 //
761 // find tracks by pure combinatorics...
762 //
763
764 static Int_t TrkTrack[12];
765
766 Int_t nTracklets, nPlanes;
767 Int_t Ntrk1, TrkId1, Ntrk2, TrkId2;
768 Float_t Y1, Y1min, Y1max, S1, Z1, S1min, S1max, Y2, S2, Z2;
769 AliTRDltuTracklet *Trk1;
770 AliTRDltuTracklet *Trk2;
771 AliTRDltuTracklet *Trk ;
772
773 Bool_t IsPlane[kNplan];
774
775 for (Int_t iPlan1 = 0; iPlan1 < kNplan; iPlan1++) {
776
777 Ntrk1 = fZnchan[iPlan1][zchan];
778
779 for (Int_t iTrk1 = 0; iTrk1 < Ntrk1; iTrk1++) {
780
781 for (Int_t iPlan = 0; iPlan < kNplan; iPlan++) IsPlane[iPlan] = kFALSE;
782
783 TrkId1 = fZtrkid[iPlan1][iTrk1][zchan];
784
785 nTracklets = 0;
786 for (Int_t iList = 0; iList < kNmaxTrk; iList++) {
787 TrkTrack[iList] = -1;
788 }
789
790 TrkTrack[nTracklets++] = TrkId1;
791
792 IsPlane[iPlan1] = kTRUE;
793
794 Trk1 = GetTracklet(TrkId1);
795
796 Y1 = Trk1->GetYproj(fXprojPlane);
797 Y1min = Y1 - fDeltaY;
798 Y1max = Y1 + fDeltaY;
799 S1 = Trk1->GetSlope();
800 S1min = S1 - fDeltaS;
801 S1max = S1 + fDeltaS;
802 Z1 = Trk1->GetZproj(fXprojPlane);
803
804 for (Int_t iPlan2 = 0; iPlan2 < kNplan; iPlan2++) {
805
806 if (iPlan2 == iPlan1) continue;
807
808 Ntrk2 = fZnchan[iPlan2][zchan];
809
810 for (Int_t iTrk2 = 0; iTrk2 < Ntrk2; iTrk2++) {
811
812 TrkId2 = fZtrkid[iPlan2][iTrk2][zchan];
813
814 if (TrkId2 == TrkId1) continue;
815
816 Trk2 = GetTracklet(TrkId2);
817
818 Y2 = Trk2->GetYproj(fXprojPlane);
819 S2 = Trk2->GetSlope();
820 Z2 = Trk2->GetZproj(fXprojPlane);
821
822 if ((Y1min < Y2 && Y2 < Y1max) &&
823 (S1min < S2 && S2 < S1max)) {
824
825 if (nTracklets >= kNmaxTrk) {
826 Warning("FindTracksCombi","Too many tracklets for this track.");
827 } else {
828 TrkTrack[nTracklets++] = TrkId2;
829 IsPlane[iPlan2] = kTRUE;
830 }
831
832 }
833
834 } // end trk 2
835
836 } // end plan 2
837
838 nPlanes = 0;
839 for (Int_t iPlan = 0; iPlan < kNplan; iPlan++) {
840 nPlanes += (Int_t)IsPlane[iPlan];
841 }
842
843 if (nPlanes >= 4) {
844
845 Int_t Cha1, Cha2, Npoints1, Npoints2;
846 for (Int_t iList = 0; iList < (nTracklets-1); iList++) {
847
848 if (TrkTrack[iList] == -1 || TrkTrack[iList+1] == -1) continue;
849 Trk1 = GetTracklet(TrkTrack[iList ]);
850 Trk2 = GetTracklet(TrkTrack[iList+1]);
851
852 Cha1 = Trk1->GetDetector();
853 Cha2 = Trk2->GetDetector();
854 if (Cha1 != Cha2) continue;
855
856 Npoints1 = Trk1->GetNclusters();
857 Npoints2 = Trk2->GetNclusters();
858
859 if (Npoints1 == Npoints2) {
860 TrkTrack[iList] = -1;
861 } else {
862 if (Npoints1 > Npoints2) TrkTrack[iList+1] = -1;
863 if (Npoints1 < Npoints2) TrkTrack[iList ] = -1;
864 }
865
866 }
867
868 fGTUtrk = new AliTRDgtuTrack();
869 for (Int_t iList = 0; iList < nTracklets; iList++) {
870 if (TrkTrack[iList] == -1) continue;
871 Trk = GetTracklet(TrkTrack[iList]);
872 fGTUtrk->AddTracklet(Trk);
873 }
874 fGTUtrk->Track(fXprojPlane,fField);
875 AddTrack();
876 }
877
878 } // end trk 1
879
880 } // end plan 1
881
882}
883
884//_____________________________________________________________________________
885void AliTRDmodule::AddTrack()
886{
887
888 Tracks()->Add(fGTUtrk);
889
890}
891
892//_____________________________________________________________________________
893void AliTRDmodule::RemoveMultipleTracks()
894{
895
896 AliTRDgtuTrack *trk1;
897 AliTRDgtuTrack *trk2;
898
899 Float_t Yproj1, Yproj2, Alpha1, Alpha2;
900 Int_t ntrk1, ntrk2;
901 Int_t iTrack = 0;
902
903 while (iTrack < (GetNtracks()-1)) {
904
905 trk1 = GetTrack(iTrack );
906 trk2 = GetTrack(iTrack+1);
907
908 ntrk1 = trk1->GetNtracklets();
909 Yproj1 = trk1->GetYproj();
910 Alpha1 = trk1->GetSlope();
911 ntrk2 = trk2->GetNtracklets();
912 Yproj2 = trk2->GetYproj();
913 Alpha2 = trk2->GetSlope();
914
915 if (TMath::Abs(Yproj1-Yproj2) < fDeltaY && TMath::Abs(Alpha1-Alpha2) < fDeltaS) {
916 if (ntrk1 < ntrk2) {
917 RemoveTrack(iTrack );
918 } else {
919 RemoveTrack(iTrack+1);
920 }
921 } else {
922 iTrack++;
923 }
924
925 }
926
927}
928
929//_____________________________________________________________________________
930AliTRDtrigger::AliTRDtrigger():
931 TNamed(),
932 fTracks("AliTRDgtuTrack",0)
933{
934 //
935 // AliTRDtrigger default constructor
936 //
937
938 fDigitsManager = NULL;
939 fTrackletTree = NULL;
940 fTracklets = NULL;
941
942 fNROB = 0;
943 fTrigParam = NULL;
944 fMCM = NULL;
945 fTrk = NULL;
946 fGTUtrk = NULL;
947
948 fNtracklets = 0;
949
950 fDigits = NULL;
951 fTrack0 = NULL;
952 fTrack1 = NULL;
953 fTrack2 = NULL;
954
955 fModule = NULL;
956
957 fNPrimary = 0;
958
959}
960
961//_____________________________________________________________________________
962AliTRDtrigger::AliTRDtrigger(const Text_t *name, const Text_t *title):
963 TNamed(name,title),
964 fTracks("AliTRDgtuTrack",1000)
965{
966 //
967 // AliTRDtrigger constructor
968 //
969
970 fDigitsManager = new AliTRDdigitsManager();
971 fTrackletTree = NULL;
972 fTracklets = new TObjArray(400);
973
974 fNROB = 0;
975 fTrigParam = NULL;
976 fMCM = NULL;
977 fTrk = NULL;
978 fGTUtrk = NULL;
979
980 fNtracklets = 0;
981
982 fDigits = NULL;
983 fTrack0 = NULL;
984 fTrack1 = NULL;
985 fTrack2 = NULL;
986
987 fModule = NULL;
988
989 fNPrimary = 0;
990
991}
992
993//_____________________________________________________________________________
994AliTRDtrigger::AliTRDtrigger(const AliTRDtrigger &p):TNamed(p)
995{
996 //
997 // AliTRDtrigger copy constructor
998 //
999
1000 ((AliTRDtrigger &) p).Copy(*this);
1001
1002}
1003
1004///_____________________________________________________________________________
1005AliTRDtrigger::~AliTRDtrigger()
1006{
1007 //
1008 // AliTRDtrigger destructor
1009 //
1010
1011 if (fTracklets) {
1012 fTracklets->Delete();
1013 delete fTracklets;
1014 }
1015
1016 fTracks.Delete();
1017
1018}
1019
1020//_____________________________________________________________________________
1021AliTRDtrigger &AliTRDtrigger::operator=(const AliTRDtrigger &p)
1022{
1023 //
1024 // Assignment operator
1025 //
1026
1027 if (this != &p) ((AliTRDtrigger &) p).Copy(*this);
1028 return *this;
1029
1030}
1031
1032//_____________________________________________________________________________
1033void AliTRDtrigger::Copy(TObject &) const
1034{
1035 //
1036 // Copy function
1037 //
1038
1039 AliFatal("Not implemented");
1040
1041}
1042
1043//_____________________________________________________________________________
1044void AliTRDtrigger::Init()
1045{
1046
1047 fModule = new AliTRDmodule(fTrigParam);
1048 /*
1049 AliHeader *header = fRunLoader->GetHeader();
1050 fNPrimary = header->GetNprimary();
1051 */
1052 fTracks.Clear();
1053
1054}
1055
1056//_____________________________________________________________________________
1057Bool_t AliTRDtrigger::Open(const Char_t *name, Int_t nEvent)
1058{
1059 //
1060 // Opens the AliROOT file.
1061 //
1062
1063 TString evfoldname = AliConfig::GetDefaultEventFolderName();
1064 fRunLoader = AliRunLoader::GetRunLoader(evfoldname);
1065
1066 if (!fRunLoader)
1067 fRunLoader = AliRunLoader::Open(name);
1068
1069 if (!fRunLoader) {
1070 Error("Open","Can not open session for file %s.",name);
1071 return kFALSE;
1072 }
1073
1074 // Open input
1075
1076 if (fRunLoader->GetAliRun() == 0x0) fRunLoader->LoadgAlice();
1077 gAlice = fRunLoader->GetAliRun();
1078
1079 if (!(gAlice)) {
1080 fRunLoader->LoadgAlice();
1081 gAlice = fRunLoader->GetAliRun();
1082 if (!(gAlice)) {
1083 Error("Open","Could not find AliRun object.");
1084 return kFALSE;
1085 }
1086 }
1087
1088 // Import the Trees for the event nEvent in the file
1089 fRunLoader->GetEvent(nEvent);
1090
1091 // Open output
1092
1093 TObjArray *ioArray = 0;
1094
1095 AliLoader* loader = fRunLoader->GetLoader("TRDLoader");
1096 loader->MakeTree("T");
1097 fTrackletTree = loader->TreeT();
1098 fTrackletTree->Branch("TRDmcmTracklet","TObjArray",&ioArray,32000,0);
1099
1100 fRunLoader->LoadHeader();
1101
1102 Init();
1103
1104 return kTRUE;
1105
1106}
1107
1108
1109//_____________________________________________________________________________
1110Bool_t AliTRDtrigger::ReadDigits()
1111{
1112 //
1113 // Reads the digits arrays from the input aliroot file
1114 //
1115
1116 if (!fRunLoader) {
1117 Error("ReadDigits","Can not find the Run Loader");
1118 return kFALSE;
1119 }
1120
1121 AliLoader* loader = fRunLoader->GetLoader("TRDLoader");
1122 if (!loader->TreeD()) loader->LoadDigits();
1123
1124 return (fDigitsManager->ReadDigits(loader->TreeD()));
1125
1126}
1127
1128//_____________________________________________________________________________
1129Bool_t AliTRDtrigger::ReadDigits(AliRawReader* rawReader)
1130{
1131 //
1132 // Reads the digits arrays from the ddl file
1133 //
1134
1135 AliTRDrawData *raw = new AliTRDrawData();
1136 raw->SetDebug(1);
1137
1138 fDigitsManager = raw->Raw2Digits(rawReader);
1139
1140 return kTRUE;
1141
1142}
1143
1144//_____________________________________________________________________________
1145Bool_t AliTRDtrigger::ReadTracklets(AliRunLoader *rl)
1146{
1147 //
1148 // Reads the tracklets find the tracks
1149 //
1150
1151 Int_t idet;
1152
1153 AliLoader *loader = rl->GetLoader("TRDLoader");
1154 loader->LoadTracks();
1155 fTrackletTree = loader->TreeT();
1156
1157 TBranch *branch = fTrackletTree->GetBranch("TRDmcmTracklet");
1158 if (!branch) {
1159 Error("ReadTracklets","Can't get the branch !");
1160 return kFALSE;
1161 }
1162 TObjArray *tracklets = new TObjArray(400);
1163 branch->SetAddress(&tracklets);
1164
1165 Int_t nEntries = (Int_t) fTrackletTree->GetEntries();
1166 Int_t iEntry, itrk;
1167 Int_t iStack, iStackPrev = -1;
1168
1169 for (iEntry = 0; iEntry < nEntries; iEntry++) {
1170 fTrackletTree->GetEvent(iEntry);
1171
1172 for (itrk = 0; itrk < tracklets->GetEntriesFast(); itrk++){
1173
1174 fTrk = (AliTRDmcmTracklet*)tracklets->UncheckedAt(itrk);
1175
1176 idet = fTrk->GetDetector();
1177
1178 iStack = idet / (AliTRDgeometry::Nplan());
1179 if (iStackPrev != iStack) {
1180 if (iStackPrev == -1) {
1181 iStackPrev = iStack;
1182 } else {
1183 MakeTracks(idet-AliTRDgeometry::Nplan());
1184 ResetTracklets();
1185 iStackPrev = iStack;
1186 }
1187 }
1188
1189 Tracklets()->Add(fTrk);
1190
1191 if (iEntry == (nEntries-1) && itrk == (tracklets->GetEntriesFast()-1)) {
1192 idet++;
1193 MakeTracks(idet-AliTRDgeometry::Nplan());
1194 ResetTracklets();
1195 }
1196
1197 }
1198
1199 }
1200
1201 loader->UnloadTracks();
1202
1203 return kTRUE;
1204
1205}
1206
1207//_____________________________________________________________________________
1208Bool_t AliTRDtrigger::MakeTracklets()
1209{
1210
1211 AliTRDcalibDB* calibration = AliTRDcalibDB::Instance();
1212 if (!calibration)
1213 {
1214 Error("MakeTracklets","No instance of AliTRDcalibDB.");
1215 return kFALSE;
1216 }
1217
1218 AliTRDCommonParam* commonParam = AliTRDCommonParam::Instance();
1219 if (!commonParam)
1220 {
1221 Error("MakeTracklets","No common params.");
1222 return kFALSE;
1223 }
1224
1225 AliTRDgeometry *geo = AliTRDgeometry::GetGeometry(fRunLoader);
1226
1227 Int_t chamBeg = 0;
1228 Int_t chamEnd = AliTRDgeometry::Ncham();
1229 Int_t planBeg = 0;
1230 Int_t planEnd = AliTRDgeometry::Nplan();
1231 Int_t sectBeg = 0;
1232 Int_t sectEnd = AliTRDgeometry::Nsect();
1233
1234 fMCM = new AliTRDmcm(fTrigParam,0);
1235
1236 Int_t time, col, row, col1, col2;
1237 Float_t amp;
1238 Int_t idet, iStack, iStackPrev;
1239 iStack = -1;
1240 iStackPrev = -1;
1241 for (Int_t isect = sectBeg; isect < sectEnd; isect++) {
1242
1243 for (Int_t icham = chamBeg; icham < chamEnd; icham++) {
1244
1245 // number of ROBs in the chamber
1246 if( icham == 2 ) {
1247 fNROB = 6;
1248 } else {
1249 fNROB = 8;
1250 }
1251
1252 for (Int_t iplan = planBeg; iplan < planEnd; iplan++) {
1253
1254 idet = geo->GetDetector(iplan,icham,isect);
1255 ResetTracklets();
1256 /*
1257 iStack = idet / (AliTRDgeometry::Nplan());
1258 if (iStackPrev != iStack) {
1259 if (iStackPrev == -1) {
1260 iStackPrev = iStack;
1261 } else {
1262 MakeTracks(idet-AliTRDgeometry::Nplan());
1263 ResetTracklets();
1264 iStackPrev = iStack;
1265 }
1266 }
1267 */
1268 Int_t nRowMax = commonParam->GetRowMax(iplan,icham,isect);
1269 Int_t nColMax = commonParam->GetColMax(iplan);
1270 Int_t nTimeTotal = calibration->GetNumberOfTimeBins();
1271
1272 // Get the digits
1273 fDigits = fDigitsManager->GetDigits(idet);
1274 fDigits->Expand();
1275 fTrack0 = fDigitsManager->GetDictionary(idet,0);
1276 fTrack0->Expand();
1277 fTrack1 = fDigitsManager->GetDictionary(idet,1);
1278 fTrack1->Expand();
1279 fTrack2 = fDigitsManager->GetDictionary(idet,2);
1280 fTrack2->Expand();
1281
1282
1283 for (Int_t iRob = 0; iRob < fNROB; iRob++) {
1284
1285 for (Int_t iMcm = 0; iMcm < kNMCM; iMcm++) {
1286
1287 fMCM->Reset();
1288
1289 fMCM->SetRobId(iRob);
1290 fMCM->SetChaId(idet);
1291
1292 SetMCMcoordinates(iMcm);
1293
1294 row = fMCM->GetRow();
1295
1296 if (row < 0 || row > nRowMax) {
1297 Error("MakeTracklets","MCM row number out of range.");
1298 }
1299
1300 fMCM->GetColRange(col1,col2);
1301
1302 for (time = 0; time < nTimeTotal; time++) {
1303 for (col = col1; col < col2; col++) {
1304 if (col >= 0 && col < nColMax) {
1305 amp = TMath::Abs(fDigits->GetDataUnchecked(row,col,time));
1306 } else {
1307 amp = 0.0;
1308 }
1309 fMCM->SetADC(col-col1,time,amp);
1310
1311 }
1312 }
1313
1314 if (fTrigParam->GetTailCancelation()) {
1315 fMCM->Filter(fTrigParam->GetNexponential(),fTrigParam->GetFilterType());
1316 }
1317
1318 if (fMCM->Run()) {
1319
1320 for (Int_t iSeed = 0; iSeed < kMaxTrackletsPerMCM; iSeed++) {
1321
1322 if (fMCM->GetSeedCol()[iSeed] < 0) continue;
1323
1324 if ( fTrigParam->GetDebugLevel() > 1 )
1325 printf("Add tracklet %d in col %02d \n",fNtracklets,fMCM->GetSeedCol()[iSeed]);
1326
1327 if ( fTrigParam->GetDebugLevel() == -1 ) {
1328 printf("Add tracklet %d in col %02d \n",fNtracklets,fMCM->GetSeedCol()[iSeed]);
1329 for (time = 0; time < nTimeTotal; time++) {
1330 for (col = 0; col < kMcmCol; col++) {
1331 printf("%03.0f ",fMCM->GetADC(col,time));
1332 }
1333 printf("\n");
1334 }
1335 }
1336
1337 AddTracklet(idet,row,iSeed,fNtracklets++);
1338
1339 }
1340
1341 }
1342
1343 }
1344
1345
1346 }
1347
1348 // Compress the arrays
1349 fDigits->Compress(1,0);
1350 fTrack0->Compress(1,0);
1351 fTrack1->Compress(1,0);
1352 fTrack2->Compress(1,0);
1353
1354 WriteTracklets(idet);
1355
1356 }
1357 }
1358 }
1359 /*
1360 idet++;
1361 MakeTracks(idet-AliTRDgeometry::Nplan());
1362 ResetTracklets();
1363 */
1364 return kTRUE;
1365
1366}
1367
1368//_____________________________________________________________________________
1369void AliTRDtrigger::SetMCMcoordinates(Int_t imcm)
1370{
1371
1372 Int_t robid = fMCM->GetRobId();
1373
1374 // setting the Row and Col range
1375
1376 const Int_t kNcolRob = 2; // number of ROBs per chamber in column direction
1377 const Int_t kNmcmRob = 4; // number of MCMs per ROB in column/row direction
1378
1379 Int_t mcmid = imcm%(kNmcmRob*kNmcmRob);
1380
1381 if (robid%kNcolRob == 0) {
1382
1383 if ( mcmid%kNmcmRob == 0 ) {
1384 fMCM->SetColRange(18*0-1,18*1-1+2+1);
1385 }
1386 if ( mcmid%kNmcmRob == 1 ) {
1387 fMCM->SetColRange(18*1-1,18*2-1+2+1);
1388 }
1389 if ( mcmid%kNmcmRob == 2 ) {
1390 fMCM->SetColRange(18*2-1,18*3-1+2+1);
1391 }
1392 if ( mcmid%kNmcmRob == 3 ) {
1393 fMCM->SetColRange(18*3-1,18*4-1+2+1);
1394 }
1395
1396 } else {
1397
1398 if ( mcmid%kNmcmRob == 0 ) {
1399 fMCM->SetColRange(18*4-1,18*5-1+2+1);
1400 }
1401 if ( mcmid%kNmcmRob == 1 ) {
1402 fMCM->SetColRange(18*5-1,18*6-1+2+1);
1403 }
1404 if ( mcmid%kNmcmRob == 2 ) {
1405 fMCM->SetColRange(18*6-1,18*7-1+2+1);
1406 }
1407 if ( mcmid%kNmcmRob == 3 ) {
1408 fMCM->SetColRange(18*7-1,18*8-1+2+1);
1409 }
1410
1411 }
1412
1413 fMCM->SetRow(kNmcmRob*(robid/kNcolRob)+mcmid/kNmcmRob);
1414
1415}
1416
1417//_____________________________________________________________________________
1418void AliTRDtrigger::AddTracklet(Int_t det, Int_t row, Int_t seed, Int_t n)
1419{
1420
1421 Float_t field = fTrigParam->GetField();
1422 AliTRDgeometry *geo = (AliTRDgeometry*)AliTRDgeometry::GetGeometry(fRunLoader);
1423
1424 AliTRDcalibDB* calibration = AliTRDcalibDB::Instance();
1425 if (!calibration)
1426 {
1427 Error("AddTracklets","No instance of AliTRDcalibDB.");
1428 return;
1429 }
1430
1431 Int_t nTimeTotal = calibration->GetNumberOfTimeBins();
1432
1433 fTrk = new AliTRDmcmTracklet(det,row,n);
1434
1435 Int_t iCol, iCol1, iCol2, track[3];
1436 iCol = fMCM->GetSeedCol()[seed]; // 0....20 (MCM)
1437 fMCM->GetColRange(iCol1,iCol2); // range in the pad plane
1438
1439 Float_t Amp[3];
1440 for (Int_t iTime = 0; iTime < nTimeTotal; iTime++) {
1441
1442 Amp[0] = fMCM->GetADC(iCol-1,iTime);
1443 Amp[1] = fMCM->GetADC(iCol ,iTime);
1444 Amp[2] = fMCM->GetADC(iCol+1,iTime);
1445
1446 // extract track contribution only from the central pad
1447 track[0] = fTrack0->GetDataUnchecked(row,iCol+iCol1,iTime);
1448 track[1] = fTrack1->GetDataUnchecked(row,iCol+iCol1,iTime);
1449 track[2] = fTrack2->GetDataUnchecked(row,iCol+iCol1,iTime);
1450
1451 if (fMCM->IsCluster(iCol,iTime)) {
1452
1453 fTrk->AddCluster(iCol+iCol1,iTime,Amp,track);
1454
1455 } else if ((iCol+1+1) < kMcmCol) {
1456
1457 Amp[0] = fMCM->GetADC(iCol-1+1,iTime);
1458 Amp[1] = fMCM->GetADC(iCol +1,iTime);
1459 Amp[2] = fMCM->GetADC(iCol+1+1,iTime);
1460
1461 if (fMCM->IsCluster(iCol+1,iTime)) {
1462
1463 // extract track contribution only from the central pad
1464 track[0] = fTrack0->GetDataUnchecked(row,iCol+1+iCol1,iTime);
1465 track[1] = fTrack1->GetDataUnchecked(row,iCol+1+iCol1,iTime);
1466 track[2] = fTrack2->GetDataUnchecked(row,iCol+1+iCol1,iTime);
1467
1468 fTrk->AddCluster(iCol+1+iCol1,iTime,Amp,track);
1469
1470 }
1471
1472 } else {
1473 }
1474
1475 }
1476
1477 fTrk->CookLabel(0.8);
1478 /*
1479 if (fTrk->GetLabel() >= fNPrimary) {
1480 Info("AddTracklet","Only primaries are stored!");
1481 return;
1482 }
1483 */
1484 // LTU Pt cut
1485 fTrk->MakeTrackletGraph(geo,field);
1486 fTrk->MakeClusAmpGraph();
1487 if (TMath::Abs(fTrk->GetPt()) < fTrigParam->GetLtuPtCut()) return;
1488
1489 Tracklets()->Add(fTrk);
1490
1491}
1492
1493//_____________________________________________________________________________
1494Bool_t AliTRDtrigger::WriteTracklets(Int_t det)
1495{
1496 //
1497 // Fills TRDmcmTracklet branch in the tree with the Tracklets
1498 // found in detector = det. For det=-1 writes the tree.
1499 //
1500
1501 if ((det < -1) || (det >= AliTRDgeometry::Ndet())) {
1502 Error("WriteTracklets","Unexpected detector index %d.",det);
1503 return kFALSE;
1504 }
1505
1506 TBranch *branch = fTrackletTree->GetBranch("TRDmcmTracklet");
1507 if (!branch) {
1508 TObjArray *ioArray = 0;
1509 branch = fTrackletTree->Branch("TRDmcmTracklet","TObjArray",&ioArray,32000,0);
1510 }
1511
1512 if ((det >= 0) && (det < AliTRDgeometry::Ndet())) {
1513
1514 Int_t nTracklets = Tracklets()->GetEntriesFast();
1515 TObjArray *detTracklets = new TObjArray(400);
1516
1517 for (Int_t i = 0; i < nTracklets; i++) {
1518 AliTRDmcmTracklet *trk = (AliTRDmcmTracklet *) Tracklets()->UncheckedAt(i);
1519
1520 if (det == trk->GetDetector()) {
1521 detTracklets->AddLast(trk);
1522 }
1523 else {
1524 }
1525 }
1526
1527 branch->SetAddress(&detTracklets);
1528 fTrackletTree->Fill();
1529
1530 delete detTracklets;
1531
1532 return kTRUE;
1533
1534 }
1535
1536 if (det == -1) {
1537
1538 Info("WriteTracklets","Writing the Tracklet tree %s for event %d."
1539 ,fTrackletTree->GetName(),fRunLoader->GetEventNumber());
1540
1541 AliLoader* loader = fRunLoader->GetLoader("TRDLoader");
1542 loader->WriteTracks("OVERWRITE");
1543
1544 return kTRUE;
1545
1546 }
1547
1548 return kFALSE;
1549
1550}
1551
1552//_____________________________________________________________________________
1553void AliTRDtrigger::MakeTracks(Int_t det)
1554{
1555 //
1556 // Create GTU tracks per module (stack of 6 chambers)
1557 //
1558
1559 fModule->Reset();
1560
1561 AliTRDCommonParam* commonParam = AliTRDCommonParam::Instance();
1562 if (!commonParam)
1563 {
1564 Error("MakeTracks","No common params.");
1565 return;
1566 }
1567
1568 Int_t nRowMax, iplan, icham, isect, row;
1569
1570 AliTRDgeometry *geo = (AliTRDgeometry*)AliTRDgeometry::GetGeometry(fRunLoader);
1571
1572 if ((det < 0) || (det >= AliTRDgeometry::Ndet())) {
1573 Error("MakeTracks","Unexpected detector index %d.",det);
1574 return;
1575 }
1576
1577 Int_t nTracklets = Tracklets()->GetEntriesFast();
1578
1579 AliTRDmcmTracklet *trk;
1580 for (Int_t i = 0; i < nTracklets; i++) {
1581
1582 trk = (AliTRDmcmTracklet *) Tracklets()->UncheckedAt(i);
1583
1584 iplan = geo->GetPlane(trk->GetDetector());
1585 icham = geo->GetChamber(trk->GetDetector());
1586 isect = geo->GetSector(trk->GetDetector());
1587
1588 nRowMax = commonParam->GetRowMax(iplan,icham,isect);
1589 row = trk->GetRow();
1590
1591 fModule->AddTracklet(trk->GetDetector(),
1592 row,
1593 trk->GetRowz(),
1594 trk->GetSlope(),
1595 trk->GetOffset(),
1596 trk->GetTime0(),
1597 trk->GetNclusters(),
1598 trk->GetLabel(),
1599 trk->GetdQdl());
1600
1601 }
1602
1603 fModule->SortTracklets();
1604 fModule->RemoveMultipleTracklets();
1605 fModule->SortZ((Int_t)geo->GetChamber(det));
1606 fModule->FindTracks();
1607 fModule->SortTracks();
1608 fModule->RemoveMultipleTracks();
1609
1610 Int_t nModTracks = fModule->GetNtracks();
1611 AliTRDgtuTrack *gtutrk;
1612 for (Int_t i = 0; i < nModTracks; i++) {
1613 gtutrk = (AliTRDgtuTrack*)fModule->GetTrack(i);
1614 if (TMath::Abs(gtutrk->GetPt()) < fTrigParam->GetGtuPtCut()) continue;
1615 gtutrk->CookLabel();
1616 gtutrk->MakePID();
1617 AddTrack(gtutrk,det);
1618 }
1619
1620}
1621
1622