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