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