Some additional protections
[u/mrichter/AliRoot.git] / TRD / AliTRDtrigger.cxx
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 //                                                                           //
19 //  TRD trigger class                                                        //
20 //                                                                           //
21 //                                                                           //
22 ///////////////////////////////////////////////////////////////////////////////
23
24 #include <TTree.h>
25 #include <TBranch.h>
26 #include <TMatrixD.h>
27
28 #include "AliLog.h"
29 #include "AliRun.h"
30 #include "AliLoader.h"
31
32 #include "AliTRDdigitsManager.h"
33 #include "AliTRDgeometry.h"
34 #include "AliTRDdataArrayI.h"
35 #include "AliTRDcalibDB.h"
36 #include "AliTRDCommonParam.h"
37 #include "Cal/AliTRDCalPIDLQ.h"
38 #include "AliTRDrawData.h"
39
40 #include "AliTRDtrigger.h"
41 #include "AliTRDmodule.h"
42 #include "AliTRDmcmTracklet.h"
43 #include "AliTRDtrigParam.h"
44 #include "AliTRDmcm.h"
45 #include "AliTRDzmaps.h"
46
47 //#include "AliHeader.h"
48
49 ClassImp(AliTRDtrigger)
50
51 //_____________________________________________________________________________
52 AliTRDtrigger::AliTRDtrigger():
53   TNamed(),
54   fTracks("AliTRDgtuTrack",0)
55 {
56   //
57   // AliTRDtrigger default constructor
58   //
59
60   fDigitsManager = NULL;
61   fTrackletTree = NULL;
62   fTracklets     = NULL;
63
64   fNROB = 0;
65   fTrigParam = NULL;
66   fMCM = NULL;
67   fTrk = NULL;
68   fTrkTest = NULL;
69   fGTUtrk = NULL;
70
71   fNtracklets = 0;
72
73   fDigits = NULL;
74   fTrack0 = NULL;
75   fTrack1 = NULL;
76   fTrack2 = NULL;
77
78   fModule = NULL;
79
80   fNPrimary = 0;
81
82   fField  = 0.0;
83   fGeo    = NULL;
84   fCalib  = NULL;
85   fCParam = NULL;
86
87 }
88
89 //_____________________________________________________________________________
90 AliTRDtrigger::AliTRDtrigger(const Text_t *name, const Text_t *title):
91   TNamed(name,title),
92   fTracks("AliTRDgtuTrack",1000)
93 {
94   //
95   // AliTRDtrigger constructor
96   //
97
98   fDigitsManager = new AliTRDdigitsManager();
99   fTrackletTree = NULL;
100   fTracklets = new TObjArray(400);
101
102   fNROB = 0;
103   fTrigParam = NULL;
104   fMCM = NULL;
105   fTrk = NULL;
106   fTrkTest = NULL;
107   fGTUtrk = NULL;
108
109   fNtracklets = 0;
110
111   fDigits = NULL;
112   fTrack0 = NULL;
113   fTrack1 = NULL;
114   fTrack2 = NULL;
115
116   fModule = NULL;
117
118   fNPrimary = 0;
119
120   fField  = 0.0;
121   fGeo    = NULL;
122   fCalib  = NULL;
123   fCParam = NULL;
124
125 }
126
127 //_____________________________________________________________________________
128 AliTRDtrigger::AliTRDtrigger(const AliTRDtrigger &p):TNamed(p)
129 {
130   //
131   // AliTRDtrigger copy constructor
132   //
133
134   ((AliTRDtrigger &) p).Copy(*this);
135
136 }
137
138 ///_____________________________________________________________________________
139 AliTRDtrigger::~AliTRDtrigger()
140 {
141   //
142   // AliTRDtrigger destructor
143   //
144
145   if (fTracklets) {
146     fTracklets->Delete();
147     delete fTracklets;
148   }
149
150   fTracks.Delete();
151
152 }
153
154 //_____________________________________________________________________________
155 AliTRDtrigger &AliTRDtrigger::operator=(const AliTRDtrigger &p)
156 {
157   //
158   // Assignment operator
159   //
160
161   if (this != &p) ((AliTRDtrigger &) p).Copy(*this);
162   return *this;
163
164 }
165
166 //_____________________________________________________________________________
167 void AliTRDtrigger::Copy(TObject &) const
168 {
169   //
170   // Copy function
171   //
172
173   AliFatal("Not implemented");
174
175 }
176
177 //_____________________________________________________________________________
178 void AliTRDtrigger::Init()
179 {
180
181   fModule = new AliTRDmodule(fTrigParam); 
182   /*
183   AliHeader *header = fRunLoader->GetHeader();
184   fNPrimary = header->GetNprimary();
185   */
186   fTracks.Clear();
187
188   fField = fTrigParam->GetField();
189   fGeo = (AliTRDgeometry*)AliTRDgeometry::GetGeometry(fRunLoader);
190
191   fCalib = AliTRDcalibDB::Instance();
192   if (!fCalib)
193   {
194     Error("Init","No instance of AliTRDcalibDB.");
195     return;  
196   }
197
198   fCParam = AliTRDCommonParam::Instance();
199   if (!fCParam)
200   {
201     Error("Init","No common params.");
202     return;
203   }
204
205 }
206
207 //_____________________________________________________________________________
208 Bool_t AliTRDtrigger::Open(const Char_t *name, Int_t nEvent)
209 {
210   //
211   // Opens the AliROOT file.
212   //
213
214   TString evfoldname = AliConfig::GetDefaultEventFolderName();
215   fRunLoader = AliRunLoader::GetRunLoader(evfoldname);
216
217   if (!fRunLoader)
218     fRunLoader = AliRunLoader::Open(name);
219
220   if (!fRunLoader) {
221     Error("Open","Can not open session for file %s.",name);
222     return kFALSE;
223   }
224
225   // Open input
226
227   if (fRunLoader->GetAliRun() == 0x0) fRunLoader->LoadgAlice();
228   gAlice = fRunLoader->GetAliRun();
229
230   if (!(gAlice)) {
231     fRunLoader->LoadgAlice();
232     gAlice = fRunLoader->GetAliRun();
233     if (!(gAlice)) {
234       Error("Open","Could not find AliRun object.");
235       return kFALSE;
236     }
237   }
238
239   // Import the Trees for the event nEvent in the file
240   fRunLoader->GetEvent(nEvent);
241
242   // Open output
243
244   TObjArray *ioArray = 0;
245
246   AliLoader* loader = fRunLoader->GetLoader("TRDLoader");
247   loader->MakeTree("T");
248   fTrackletTree = loader->TreeT();
249   fTrackletTree->Branch("TRDmcmTracklet","TObjArray",&ioArray,32000,0);
250   /*
251   fRunLoader->LoadHeader();
252   */
253   Init();
254
255   return kTRUE;
256
257 }
258
259
260 //_____________________________________________________________________________
261 Bool_t AliTRDtrigger::ReadDigits() 
262 {
263   //
264   // Reads the digits arrays from the input aliroot file
265   //
266
267   if (!fRunLoader) {
268     Error("ReadDigits","Can not find the Run Loader");
269     return kFALSE;
270   }
271
272   AliLoader* loader = fRunLoader->GetLoader("TRDLoader");
273   if (!loader->TreeD()) loader->LoadDigits();
274
275   if (!loader->TreeD()) return kFALSE;
276
277   return (fDigitsManager->ReadDigits(loader->TreeD()));
278
279 }
280
281 //_____________________________________________________________________________
282 Bool_t AliTRDtrigger::ReadDigits(AliRawReader* rawReader)
283 {
284   //
285   // Reads the digits arrays from the ddl file
286   //
287
288   AliTRDrawData *raw = new AliTRDrawData();
289   raw->SetDebug(1);
290
291   fDigitsManager = raw->Raw2Digits(rawReader);
292
293   return kTRUE;
294
295 }
296
297 //_____________________________________________________________________________
298 Bool_t AliTRDtrigger::ReadTracklets(AliRunLoader *rl) 
299 {
300   //
301   // Reads the tracklets find the tracks
302   //
303
304   Int_t idet;
305
306   AliLoader *loader = rl->GetLoader("TRDLoader");
307   loader->LoadTracks();
308   fTrackletTree = loader->TreeT();
309
310   TBranch *branch = fTrackletTree->GetBranch("TRDmcmTracklet");
311   if (!branch) {
312     Error("ReadTracklets","Can't get the branch !");
313     return kFALSE;
314   }
315   TObjArray *tracklets = new TObjArray(400);
316   branch->SetAddress(&tracklets);
317
318   Int_t nEntries = (Int_t) fTrackletTree->GetEntries();
319   Int_t iEntry, itrk;
320   Int_t iStack, iStackPrev = -1;
321   
322   for (iEntry = 0; iEntry < nEntries; iEntry++) {    
323     fTrackletTree->GetEvent(iEntry);
324     
325     for (itrk = 0; itrk < tracklets->GetEntriesFast(); itrk++){
326
327       fTrk = (AliTRDmcmTracklet*)tracklets->UncheckedAt(itrk);
328       
329       idet = fTrk->GetDetector();
330
331       iStack = idet / (AliTRDgeometry::Nplan());
332       if (iStackPrev != iStack) {
333         if (iStackPrev == -1) {
334           iStackPrev = iStack;
335         } else {
336           MakeTracks(idet-AliTRDgeometry::Nplan());
337           ResetTracklets();
338           iStackPrev = iStack;
339         }
340       }
341       
342       Tracklets()->Add(fTrk);
343
344       if (iEntry == (nEntries-1) && itrk == (tracklets->GetEntriesFast()-1)) {
345         idet++;
346         MakeTracks(idet-AliTRDgeometry::Nplan());
347         ResetTracklets();
348       }
349
350     }
351
352   }
353
354   loader->UnloadTracks();
355
356   return kTRUE;
357
358 }
359
360 //_____________________________________________________________________________
361 Bool_t AliTRDtrigger::MakeTracklets(Bool_t makeTracks)
362 {
363   //
364   // Create tracklets from digits
365   //
366
367   Int_t    chamBeg = 0;
368   Int_t    chamEnd = AliTRDgeometry::Ncham();
369   Int_t    planBeg = 0;
370   Int_t    planEnd = AliTRDgeometry::Nplan();
371   Int_t    sectBeg = 0;
372   Int_t    sectEnd = AliTRDgeometry::Nsect();
373
374   fTrkTest = new AliTRDmcmTracklet(0,0,0);
375
376   fMCM = new AliTRDmcm(fTrigParam,0);
377
378   Int_t time, col, row, col1, col2;
379   Float_t amp;
380   Int_t idet, iStack, iStackPrev;
381   idet       = -1;
382   iStack     = -1;
383   iStackPrev = -1;
384   for (Int_t isect = sectBeg; isect < sectEnd; isect++) {
385
386     for (Int_t icham = chamBeg; icham < chamEnd; icham++) {
387
388       // number of ROBs in the chamber
389       if( icham == 2 ) {
390         fNROB = 6;
391       } else {
392         fNROB = 8;
393       }
394
395       for (Int_t iplan = planBeg; iplan < planEnd; iplan++) {
396
397         idet = fGeo->GetDetector(iplan,icham,isect);
398         ResetTracklets();
399         
400         if (makeTracks) {
401           iStack = idet / (AliTRDgeometry::Nplan());
402           if (iStackPrev != iStack) {
403             if (iStackPrev == -1) {
404               iStackPrev = iStack;
405             } else {
406               MakeTracks(idet-AliTRDgeometry::Nplan());
407               ResetTracklets();
408               iStackPrev = iStack;
409             }
410           }
411         }
412
413         Int_t    nRowMax     = fCParam->GetRowMax(iplan,icham,isect);
414         Int_t    nColMax     = fCParam->GetColMax(iplan);
415         Int_t    nTimeTotal  = fCalib->GetNumberOfTimeBins();
416
417         // Get the digits
418         fDigits = fDigitsManager->GetDigits(idet);
419         if (!fDigits) return kFALSE;
420         fDigits->Expand();
421         fTrack0 = fDigitsManager->GetDictionary(idet,0);
422         if (!fTrack0) return kFALSE;
423         fTrack0->Expand();
424         fTrack1 = fDigitsManager->GetDictionary(idet,1);
425         if (!fTrack1) return kFALSE;
426         fTrack1->Expand();
427         fTrack2 = fDigitsManager->GetDictionary(idet,2); 
428         if (!fTrack2) return kFALSE;
429         fTrack2->Expand();
430
431         for (Int_t iRob = 0; iRob < fNROB; iRob++) {
432
433           for (Int_t iMcm = 0; iMcm < kNMCM; iMcm++) {
434
435             fMCM->Reset();
436
437             fMCM->SetRobId(iRob);
438             fMCM->SetChaId(idet);
439
440             SetMCMcoordinates(iMcm);
441
442             row = fMCM->GetRow();
443
444             if (row < 0 || row >= nRowMax) {
445               Error("MakeTracklets","MCM row number out of range.");
446               continue;
447             }
448
449             fMCM->GetColRange(col1,col2);
450             
451             for (time = 0; time < nTimeTotal; time++) {
452               for (col = col1; col < col2; col++) {
453                 if (col >= 0 && col < nColMax) {
454                   amp = TMath::Abs(fDigits->GetDataUnchecked(row,col,time));
455                 } else {
456                   amp = 0.0;
457                 }
458                 fMCM->SetADC(col-col1,time,amp);
459
460               }
461             }
462
463             if (fTrigParam->GetTailCancelation()) {
464               fMCM->Filter(fTrigParam->GetNexponential(),fTrigParam->GetFilterType());
465             }
466             
467             if (fMCM->Run()) {
468
469               for (Int_t iSeed = 0; iSeed < kMaxTrackletsPerMCM; iSeed++) {
470                 
471                 if (fMCM->GetSeedCol()[iSeed] < 0) continue;
472
473                 if ( fTrigParam->GetDebugLevel() > 1 ) 
474                   printf("Add tracklet %d in col %02d \n",fNtracklets,fMCM->GetSeedCol()[iSeed]);
475
476                 if ( fTrigParam->GetDebugLevel() == -1 ) {
477                   printf("Add tracklet %d in col %02d \n",fNtracklets,fMCM->GetSeedCol()[iSeed]);
478                   for (time = 0; time < nTimeTotal; time++) {
479                     for (col = 0; col < kMcmCol; col++) {                   
480                       printf("%03.0f  ",fMCM->GetADC(col,time));
481                     }
482                     printf("\n");
483                   }
484                 }
485
486                 if (TestTracklet(idet,row,iSeed,0)) {
487                   AddTracklet(idet,row,iSeed,fNtracklets++);
488                 }
489
490               }
491
492             }
493
494           }
495
496       
497         }
498
499         // Compress the arrays
500         fDigits->Compress(1,0);
501         fTrack0->Compress(1,0);
502         fTrack1->Compress(1,0);
503         fTrack2->Compress(1,0);
504
505         WriteTracklets(idet);
506
507      }
508     }
509   }
510
511   if (makeTracks) {
512     idet++;
513     MakeTracks(idet-AliTRDgeometry::Nplan());
514     ResetTracklets();
515   }
516
517   return kTRUE;
518
519 }
520
521 //_____________________________________________________________________________
522 void AliTRDtrigger::SetMCMcoordinates(Int_t imcm)
523 {
524   //
525   // Configure MCM position in the pad plane
526   //
527
528   Int_t robid = fMCM->GetRobId();
529
530   // setting the Row and Col range
531
532   const Int_t kNcolRob = 2;  // number of ROBs per chamber in column direction
533   const Int_t kNmcmRob = 4;  // number of MCMs per ROB in column/row direction
534
535   Int_t mcmid = imcm%(kNmcmRob*kNmcmRob);
536
537   if (robid%kNcolRob == 0) {
538
539     if ( mcmid%kNmcmRob == 0 ) {
540       fMCM->SetColRange(18*0-1,18*1-1+2+1);
541     }
542     if ( mcmid%kNmcmRob == 1 ) {
543       fMCM->SetColRange(18*1-1,18*2-1+2+1);
544     }
545     if ( mcmid%kNmcmRob == 2 ) {
546       fMCM->SetColRange(18*2-1,18*3-1+2+1);
547     }
548     if ( mcmid%kNmcmRob == 3 ) {
549       fMCM->SetColRange(18*3-1,18*4-1+2+1);
550     }
551
552   } else {
553
554     if ( mcmid%kNmcmRob == 0 ) {
555       fMCM->SetColRange(18*4-1,18*5-1+2+1);
556     }
557     if ( mcmid%kNmcmRob == 1 ) {
558       fMCM->SetColRange(18*5-1,18*6-1+2+1);
559     }
560     if ( mcmid%kNmcmRob == 2 ) {
561       fMCM->SetColRange(18*6-1,18*7-1+2+1);
562     }
563     if ( mcmid%kNmcmRob == 3 ) {
564       fMCM->SetColRange(18*7-1,18*8-1+2+1);
565     }
566
567   } 
568
569   fMCM->SetRow(kNmcmRob*(robid/kNcolRob)+mcmid/kNmcmRob);
570
571 }
572
573 //_____________________________________________________________________________
574 Bool_t AliTRDtrigger::TestTracklet(Int_t det, Int_t row, Int_t seed, Int_t n)
575 {
576   //
577   // Check first the tracklet pt
578   //
579
580   Int_t nTimeTotal  = fCalib->GetNumberOfTimeBins();
581
582   fTrkTest->Reset();
583
584   fTrkTest->SetDetector(det);
585   fTrkTest->SetRow(row);
586   fTrkTest->SetN(n);
587
588   Int_t iCol, iCol1, iCol2, track[3];
589   iCol = fMCM->GetSeedCol()[seed];  // 0....20 (MCM)
590   fMCM->GetColRange(iCol1,iCol2);   // range in the pad plane
591             
592   Float_t amp[3];
593   for (Int_t iTime = 0; iTime < nTimeTotal; iTime++) {
594
595     amp[0] = fMCM->GetADC(iCol-1,iTime);
596     amp[1] = fMCM->GetADC(iCol  ,iTime);
597     amp[2] = fMCM->GetADC(iCol+1,iTime);
598
599     // extract track contribution only from the central pad
600     track[0] = fTrack0->GetDataUnchecked(row,iCol+iCol1,iTime);
601     track[1] = fTrack1->GetDataUnchecked(row,iCol+iCol1,iTime);
602     track[2] = fTrack2->GetDataUnchecked(row,iCol+iCol1,iTime);
603
604     if (fMCM->IsCluster(iCol,iTime)) {
605
606       fTrkTest->AddCluster(iCol+iCol1,iTime,amp,track);
607
608     } else if ((iCol+1+1) < kMcmCol) {
609
610       amp[0] = fMCM->GetADC(iCol-1+1,iTime);
611       amp[1] = fMCM->GetADC(iCol  +1,iTime);
612       amp[2] = fMCM->GetADC(iCol+1+1,iTime);
613
614       if (fMCM->IsCluster(iCol+1,iTime)) {
615
616         // extract track contribution only from the central pad
617         track[0] = fTrack0->GetDataUnchecked(row,iCol+1+iCol1,iTime);
618         track[1] = fTrack1->GetDataUnchecked(row,iCol+1+iCol1,iTime);
619         track[2] = fTrack2->GetDataUnchecked(row,iCol+1+iCol1,iTime);
620
621         fTrkTest->AddCluster(iCol+1+iCol1,iTime,amp,track);
622
623       }
624
625     } else {
626     }
627
628   }
629
630   fTrkTest->CookLabel(0.8);  
631   /*
632   if (fTrkTest->GetLabel() >= fNPrimary) {
633     Info("AddTracklet","Only primaries are stored!");
634     return;
635   }
636   */
637   // LTU Pt cut
638     
639   fTrkTest->MakeTrackletGraph(fGeo,fField);
640   fTrkTest->MakeClusAmpGraph();
641   if (TMath::Abs(fTrkTest->GetPt()) < fTrigParam->GetLtuPtCut()) {
642     return kFALSE;
643   }
644   
645   return kTRUE;  
646
647 }
648
649 //_____________________________________________________________________________
650 void AliTRDtrigger::AddTracklet(Int_t det, Int_t row, Int_t seed, Int_t n)
651 {
652   //
653   // Add a found tracklet
654   //
655
656   Int_t nTimeTotal  = fCalib->GetNumberOfTimeBins();
657
658   fTrk = new AliTRDmcmTracklet(det,row,n);
659
660   Int_t iCol, iCol1, iCol2, track[3];
661   iCol = fMCM->GetSeedCol()[seed];  // 0....20 (MCM)
662   fMCM->GetColRange(iCol1,iCol2);   // range in the pad plane
663             
664   Float_t amp[3];
665   for (Int_t iTime = 0; iTime < nTimeTotal; iTime++) {
666
667     amp[0] = fMCM->GetADC(iCol-1,iTime);
668     amp[1] = fMCM->GetADC(iCol  ,iTime);
669     amp[2] = fMCM->GetADC(iCol+1,iTime);
670
671     // extract track contribution only from the central pad
672     track[0] = fTrack0->GetDataUnchecked(row,iCol+iCol1,iTime);
673     track[1] = fTrack1->GetDataUnchecked(row,iCol+iCol1,iTime);
674     track[2] = fTrack2->GetDataUnchecked(row,iCol+iCol1,iTime);
675
676     if (fMCM->IsCluster(iCol,iTime)) {
677
678       fTrk->AddCluster(iCol+iCol1,iTime,amp,track);
679
680     } else if ((iCol+1+1) < kMcmCol) {
681
682       amp[0] = fMCM->GetADC(iCol-1+1,iTime);
683       amp[1] = fMCM->GetADC(iCol  +1,iTime);
684       amp[2] = fMCM->GetADC(iCol+1+1,iTime);
685
686       if (fMCM->IsCluster(iCol+1,iTime)) {
687
688         // extract track contribution only from the central pad
689         track[0] = fTrack0->GetDataUnchecked(row,iCol+1+iCol1,iTime);
690         track[1] = fTrack1->GetDataUnchecked(row,iCol+1+iCol1,iTime);
691         track[2] = fTrack2->GetDataUnchecked(row,iCol+1+iCol1,iTime);
692
693         fTrk->AddCluster(iCol+1+iCol1,iTime,amp,track);
694
695       }
696
697     } else {
698     }
699
700   }
701
702   fTrk->CookLabel(0.8);  
703   /*
704   if (fTrk->GetLabel() >= fNPrimary) {
705     Info("AddTracklet","Only primaries are stored!");
706     return;
707   }
708   */
709   // LTU Pt cut
710   fTrk->MakeTrackletGraph(fGeo,fField);
711   fTrk->MakeClusAmpGraph();
712   if (TMath::Abs(fTrk->GetPt()) < fTrigParam->GetLtuPtCut()) {
713     return;
714   }
715       
716   Tracklets()->Add(fTrk);
717
718 }
719
720 //_____________________________________________________________________________
721 Bool_t AliTRDtrigger::WriteTracklets(Int_t det) 
722 {
723   //
724   // Fills TRDmcmTracklet branch in the tree with the Tracklets 
725   // found in detector = det. For det=-1 writes the tree. 
726   //
727
728   if ((det < -1) || (det >= AliTRDgeometry::Ndet())) {
729     Error("WriteTracklets","Unexpected detector index %d.",det);
730     return kFALSE;
731   }
732
733   TBranch *branch = fTrackletTree->GetBranch("TRDmcmTracklet");
734   if (!branch) {
735     TObjArray *ioArray = 0;
736     branch = fTrackletTree->Branch("TRDmcmTracklet","TObjArray",&ioArray,32000,0);
737   }
738
739   if ((det >= 0) && (det < AliTRDgeometry::Ndet())) {
740
741     Int_t nTracklets = Tracklets()->GetEntriesFast();
742     TObjArray *detTracklets = new TObjArray(400);
743
744     for (Int_t i = 0; i < nTracklets; i++) {
745       AliTRDmcmTracklet *trk = (AliTRDmcmTracklet *) Tracklets()->UncheckedAt(i);
746       
747       if (det == trk->GetDetector()) {
748         detTracklets->AddLast(trk);
749       }
750       else {
751       }
752     }
753
754     branch->SetAddress(&detTracklets);
755     fTrackletTree->Fill();
756
757     delete detTracklets;
758
759     return kTRUE;
760
761   }
762
763   if (det == -1) {
764
765     Info("WriteTracklets","Writing the Tracklet tree %s for event %d."
766          ,fTrackletTree->GetName(),fRunLoader->GetEventNumber());
767
768     AliLoader* loader = fRunLoader->GetLoader("TRDLoader");
769     loader->WriteTracks("OVERWRITE");
770     
771     return kTRUE;  
772
773   }
774
775   return kFALSE;
776
777 }
778
779 //_____________________________________________________________________________
780 void AliTRDtrigger::MakeTracks(Int_t det)
781 {
782   //
783   // Create GTU tracks per module (stack of 6 chambers)
784   //
785   
786   fModule->Reset();
787
788   Int_t nRowMax, iplan, icham, isect, row;
789
790   if ((det < 0) || (det >= AliTRDgeometry::Ndet())) {
791     Error("MakeTracks","Unexpected detector index %d.",det);
792     return;
793   }
794   
795   Int_t nTracklets = Tracklets()->GetEntriesFast();
796   
797   AliTRDmcmTracklet *trk;
798   for (Int_t i = 0; i < nTracklets; i++) {
799     
800     trk = (AliTRDmcmTracklet *) Tracklets()->UncheckedAt(i);
801     
802     iplan = fGeo->GetPlane(trk->GetDetector());
803     icham = fGeo->GetChamber(trk->GetDetector());
804     isect = fGeo->GetSector(trk->GetDetector());
805
806     nRowMax = fCParam->GetRowMax(iplan,icham,isect);
807     row = trk->GetRow();
808
809     fModule->AddTracklet(trk->GetDetector(),
810                          row,
811                          trk->GetRowz(),
812                          trk->GetSlope(),
813                          trk->GetOffset(),
814                          trk->GetTime0(),
815                          trk->GetNclusters(),
816                          trk->GetLabel(),
817                          trk->GetdQdl());
818     
819   }
820
821   fModule->SortTracklets();
822   fModule->RemoveMultipleTracklets();
823   fModule->SortZ((Int_t)fGeo->GetChamber(det));
824   fModule->FindTracks();
825   fModule->SortTracks();
826   fModule->RemoveMultipleTracks();
827
828   Int_t nModTracks = fModule->GetNtracks();
829   AliTRDgtuTrack *gtutrk;
830   for (Int_t i = 0; i < nModTracks; i++) {
831     gtutrk = (AliTRDgtuTrack*)fModule->GetTrack(i);
832     if (TMath::Abs(gtutrk->GetPt()) < fTrigParam->GetGtuPtCut()) continue;
833     gtutrk->CookLabel();
834     gtutrk->MakePID();
835     AddTrack(gtutrk,det);
836   }
837   
838 }
839
840