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         // This is to take care of switched off super modules
 432         if (fDigits->GetNtime() == 0) {
 433           continue;
 434         }
 435         fDigits->Expand();
 436         fTrack0 = fDigitsManager->GetDictionary(idet,0);
 437         if (!fTrack0) return kFALSE;
 438         fTrack0->Expand();
 439         fTrack1 = fDigitsManager->GetDictionary(idet,1);
 440         if (!fTrack1) return kFALSE;
 441         fTrack1->Expand();
 442         fTrack2 = fDigitsManager->GetDictionary(idet,2);
 443         if (!fTrack2) return kFALSE;
 444         fTrack2->Expand();
 445
 446         for (Int_t iRob = 0; iRob < fNROB; iRob++) {
 447
 448           for (Int_t iMcm = 0; iMcm < kNMCM; iMcm++) {
 449
 450             fMCM->Reset();
 451             fMCM->SetRobId(iRob);
 452             fMCM->SetChaId(idet);
 453
 454             SetMCMcoordinates(iMcm);
 455
 456             row = fMCM->GetRow();
 457
 458             if ((row < 0) || (row >= nRowMax)) {
 459               AliError("MCM row number out of range.");
 460               continue;
 461             }
 462
 463             fMCM->GetColRange(col1,col2);
 464
 465             for (time = 0; time < nTimeTotal; time++) {
 466               for (col = col1; col < col2; col++) {
 467                 if ((col >= 0) && (col < nColMax)) {
 468                   amp = TMath::Abs(fDigits->GetDataUnchecked(row,col,time));
 469                 }
 470                 else {
 471                   amp = 0.0;
 472                 }
 473                 fMCM->SetADC(col-col1,time,amp);
 474               }
 475             }
 476
 477             if (fTrigParam->GetTailCancelation()) {
 478               fMCM->Filter(fTrigParam->GetNexponential(),fTrigParam->GetFilterType());
 479             }
 480
 481             if (fMCM->Run()) {
 482
 483               for (Int_t iSeed = 0; iSeed < kMaxTrackletsPerMCM; iSeed++) {
 484
 485                 if (fMCM->GetSeedCol()[iSeed] < 0) {
 486                   continue;
 487                 }
 488
 489                 if (fTrigParam->GetDebugLevel()   > 1) {
 490                   AliInfo(Form("Add tracklet %d in col %02d \n",fNtracklets,fMCM->GetSeedCol()[iSeed]));
 491                 }
 492
 493                 if (TestTracklet(idet,row,iSeed,0)) {
 494                   AddTracklet(idet,row,iSeed,fNtracklets++);
 495                 }
 496
 497               }
 498
 499             }
 500
 501           }
 502
 503
 504         }
 505
 506         // Compress the arrays
 507         fDigits->Compress(1,0);
 508         fTrack0->Compress(1,0);
 509         fTrack1->Compress(1,0);
 510         fTrack2->Compress(1,0);
 511
 512         WriteTracklets(idet);
 513
 514      }
 515     }
 516   }
 517
 518   if (makeTracks) {
 519     idet++;
 520     MakeTracks(idet - AliTRDgeometry::Nplan());
 521     ResetTracklets();
 522   }
 523
 524   return kTRUE;
 525
 526 }
 527
 528 //_____________________________________________________________________________
 529 void AliTRDtrigger::SetMCMcoordinates(Int_t imcm)
 530 {
 531   //
 532   // Configure MCM position in the pad plane
 533   //
 534
 535   Int_t robid = fMCM->GetRobId();
 536
 537   // setting the Row and Col range
 538
 539   const Int_t kNcolRob = 2;  // number of ROBs per chamber in column direction
 540   const Int_t kNmcmRob = 4;  // number of MCMs per ROB in column/row direction
 541
 542   Int_t mcmid = imcm%(kNmcmRob*kNmcmRob);
 543
 544   if (robid%kNcolRob == 0) {
 545
 546     if (mcmid%kNmcmRob == 0) {
 547       fMCM->SetColRange(18*0-1,18*1-1+2+1);
 548     }
 549     if (mcmid%kNmcmRob == 1) {
 550       fMCM->SetColRange(18*1-1,18*2-1+2+1);
 551     }
 552     if (mcmid%kNmcmRob == 2) {
 553       fMCM->SetColRange(18*2-1,18*3-1+2+1);
 554     }
 555     if (mcmid%kNmcmRob == 3) {
 556       fMCM->SetColRange(18*3-1,18*4-1+2+1);
 557     }
 558
 559   }
 560   else {
 561
 562     if (mcmid%kNmcmRob == 0) {
 563       fMCM->SetColRange(18*4-1,18*5-1+2+1);
 564     }
 565     if (mcmid%kNmcmRob == 1) {
 566       fMCM->SetColRange(18*5-1,18*6-1+2+1);
 567     }
 568     if (mcmid%kNmcmRob == 2) {
 569       fMCM->SetColRange(18*6-1,18*7-1+2+1);
 570     }
 571     if (mcmid%kNmcmRob == 3) {
 572       fMCM->SetColRange(18*7-1,18*8-1+2+1);
 573     }
 574
 575   }
 576
 577   fMCM->SetRow(kNmcmRob*(robid/kNcolRob)+mcmid/kNmcmRob);
 578
 579 }
 580
 581 //_____________________________________________________________________________
 582 Bool_t AliTRDtrigger::TestTracklet(Int_t det, Int_t row, Int_t seed, Int_t n)
 583 {
 584   //
 585   // Check first the tracklet pt
 586   //
 587
 588   Int_t nTimeTotal  = fCalib->GetNumberOfTimeBins();
 589
 590   fTrkTest->Reset();
 591
 592   fTrkTest->SetDetector(det);
 593   fTrkTest->SetRow(row);
 594   fTrkTest->SetN(n);
 595
 596   Int_t iCol, iCol1, iCol2, track[3];
 597   iCol = fMCM->GetSeedCol()[seed];  // 0....20 (MCM)
 598   fMCM->GetColRange(iCol1,iCol2);   // range in the pad plane
 599
 600   Float_t amp[3];
 601   for (Int_t iTime = 0; iTime < nTimeTotal; iTime++) {
 602
 603     amp[0] = fMCM->GetADC(iCol-1,iTime);
 604     amp[1] = fMCM->GetADC(iCol  ,iTime);
 605     amp[2] = fMCM->GetADC(iCol+1,iTime);
 606
 607     // extract track contribution only from the central pad
 608     track[0] = fTrack0->GetDataUnchecked(row,iCol+iCol1,iTime);
 609     track[1] = fTrack1->GetDataUnchecked(row,iCol+iCol1,iTime);
 610     track[2] = fTrack2->GetDataUnchecked(row,iCol+iCol1,iTime);
 611
 612     if      (fMCM->IsCluster(iCol,iTime)) {
 613
 614       fTrkTest->AddCluster(iCol+iCol1,iTime,amp,track);
 615
 616     }
 617     else if ((iCol+1+1) < kMcmCol) {
 618
 619       amp[0] = fMCM->GetADC(iCol-1+1,iTime);
 620       amp[1] = fMCM->GetADC(iCol  +1,iTime);
 621       amp[2] = fMCM->GetADC(iCol+1+1,iTime);
 622
 623       if (fMCM->IsCluster(iCol+1,iTime)) {
 624
 625         // extract track contribution only from the central pad
 626         track[0] = fTrack0->GetDataUnchecked(row,iCol+1+iCol1,iTime);
 627         track[1] = fTrack1->GetDataUnchecked(row,iCol+1+iCol1,iTime);
 628         track[2] = fTrack2->GetDataUnchecked(row,iCol+1+iCol1,iTime);
 629
 630         fTrkTest->AddCluster(iCol+1+iCol1,iTime,amp,track);
 631
 632       }
 633
 634     }
 635
 636   }
 637
 638   fTrkTest->CookLabel(0.8);
 639   /*
 640   if (fTrkTest->GetLabel() >= fNPrimary) {
 641     Info("AddTracklet","Only primaries are stored!");
 642     return;
 643   }
 644   */
 645   // LTU Pt cut
 646
 647   fTrkTest->MakeTrackletGraph(fGeo,fField);
 648   fTrkTest->MakeClusAmpGraph();
 649   if (TMath::Abs(fTrkTest->GetPt()) < fTrigParam->GetLtuPtCut()) {
 650     return kFALSE;
 651   }
 652
 653   return kTRUE;
 654
 655 }
 656
 657 //_____________________________________________________________________________
 658 void AliTRDtrigger::AddTracklet(Int_t det, Int_t row, Int_t seed, Int_t n)
 659 {
 660   //
 661   // Add a found tracklet
 662   //
 663
 664   Int_t nTimeTotal  = fCalib->GetNumberOfTimeBins();
 665
 666   fTrk = new AliTRDmcmTracklet(det,row,n);
 667
 668   Int_t iCol, iCol1, iCol2, track[3];
 669   iCol = fMCM->GetSeedCol()[seed];  // 0....20 (MCM)
 670   fMCM->GetColRange(iCol1,iCol2);   // range in the pad plane
 671
 672   Float_t amp[3];
 673   for (Int_t iTime = 0; iTime < nTimeTotal; iTime++) {
 674
 675     amp[0] = fMCM->GetADC(iCol-1,iTime);
 676     amp[1] = fMCM->GetADC(iCol  ,iTime);
 677     amp[2] = fMCM->GetADC(iCol+1,iTime);
 678
 679     // extract track contribution only from the central pad
 680     track[0] = fTrack0->GetDataUnchecked(row,iCol+iCol1,iTime);
 681     track[1] = fTrack1->GetDataUnchecked(row,iCol+iCol1,iTime);
 682     track[2] = fTrack2->GetDataUnchecked(row,iCol+iCol1,iTime);
 683
 684     if      (fMCM->IsCluster(iCol,iTime)) {
 685
 686       fTrk->AddCluster(iCol+iCol1,iTime,amp,track);
 687
 688     }
 689     else if ((iCol+1+1) < kMcmCol) {
 690
 691       amp[0] = fMCM->GetADC(iCol-1+1,iTime);
 692       amp[1] = fMCM->GetADC(iCol  +1,iTime);
 693       amp[2] = fMCM->GetADC(iCol+1+1,iTime);
 694
 695       if (fMCM->IsCluster(iCol+1,iTime)) {
 696
 697         // extract track contribution only from the central pad
 698         track[0] = fTrack0->GetDataUnchecked(row,iCol+1+iCol1,iTime);
 699         track[1] = fTrack1->GetDataUnchecked(row,iCol+1+iCol1,iTime);
 700         track[2] = fTrack2->GetDataUnchecked(row,iCol+1+iCol1,iTime);
 701
 702         fTrk->AddCluster(iCol+1+iCol1,iTime,amp,track);
 703
 704       }
 705
 706     }
 707
 708   }
 709
 710   fTrk->CookLabel(0.8);
 711   /*
 712   if (fTrk->GetLabel() >= fNPrimary) {
 713     Info("AddTracklet","Only primaries are stored!");
 714     return;
 715   }
 716   */
 717   // LTU Pt cut
 718   fTrk->MakeTrackletGraph(fGeo,fField);
 719   fTrk->MakeClusAmpGraph();
 720   if (TMath::Abs(fTrk->GetPt()) < fTrigParam->GetLtuPtCut()) {
 721     return;
 722   }
 723
 724   Tracklets()->Add(fTrk);
 725
 726 }
 727
 728 //_____________________________________________________________________________
 729 Bool_t AliTRDtrigger::WriteTracklets(Int_t det)
 730 {
 731   //
 732   // Fills TRDmcmTracklet branch in the tree with the Tracklets
 733   // found in detector = det. For det=-1 writes the tree.
 734   //
 735
 736   if ((det < -1) || (det >= AliTRDgeometry::Ndet())) {
 737     AliError(Form("Unexpected detector index %d.",det));
 738     return kFALSE;
 739   }
 740
 741   TBranch *branch = fTrackletTree->GetBranch("TRDmcmTracklet");
 742   if (!branch) {
 743     TObjArray *ioArray = 0;
 744     branch = fTrackletTree->Branch("TRDmcmTracklet","TObjArray",&ioArray,32000,0);
 745   }
 746
 747   if ((det >= 0) && (det < AliTRDgeometry::Ndet())) {
 748
 749     Int_t nTracklets = Tracklets()->GetEntriesFast();
 750     TObjArray *detTracklets = new TObjArray(400);
 751
 752     for (Int_t i = 0; i < nTracklets; i++) {
 753
 754       AliTRDmcmTracklet *trk = (AliTRDmcmTracklet *) Tracklets()->UncheckedAt(i);
 755
 756       if (det == trk->GetDetector()) {
 757         detTracklets->AddLast(trk);
 758       }
 759
 760     }
 761
 762     branch->SetAddress(&detTracklets);
 763     fTrackletTree->Fill();
 764
 765     delete detTracklets;
 766
 767     return kTRUE;
 768
 769   }
 770
 771   if (det == -1) {
 772
 773     AliInfo(Form("Writing the Tracklet tree %s for event %d."
 774                 ,fTrackletTree->GetName(),fRunLoader->GetEventNumber()));
 775
 776     AliLoader* loader = fRunLoader->GetLoader("TRDLoader");
 777     loader->WriteTracks("OVERWRITE");
 778
 779     return kTRUE;
 780
 781   }
 782
 783   return kFALSE;
 784
 785 }
 786
 787 //_____________________________________________________________________________
 788 void AliTRDtrigger::MakeTracks(Int_t det)
 789 {
 790   //
 791   // Create GTU tracks per module (stack of 6 chambers)
 792   //
 793
 794   fModule->Reset();
 795
 796   Int_t nRowMax, iplan, icham, isect, row;
 797
 798   if ((det < 0) || (det >= AliTRDgeometry::Ndet())) {
 799     AliError(Form("Unexpected detector index %d.",det));
 800     return;
 801   }
 802
 803   Int_t nTracklets = Tracklets()->GetEntriesFast();
 804
 805   AliTRDmcmTracklet *trk;
 806   for (Int_t i = 0; i < nTracklets; i++) {
 807
 808     trk = (AliTRDmcmTracklet *) Tracklets()->UncheckedAt(i);
 809
 810     iplan = fGeo->GetPlane(trk->GetDetector());
 811     icham = fGeo->GetChamber(trk->GetDetector());
 812     isect = fGeo->GetSector(trk->GetDetector());
 813
 814     nRowMax = fCParam->GetRowMax(iplan,icham,isect);
 815     row = trk->GetRow();
 816
 817     fModule->AddTracklet(trk->GetDetector(),
 818                          row,
 819                          trk->GetRowz(),
 820                          trk->GetSlope(),
 821                          trk->GetOffset(),
 822                          trk->GetTime0(),
 823                          trk->GetNclusters(),
 824                          trk->GetLabel(),
 825                          trk->GetdQdl());
 826
 827   }
 828
 829   fModule->SortTracklets();
 830   fModule->RemoveMultipleTracklets();
 831   fModule->SortZ((Int_t)fGeo->GetChamber(det));
 832   fModule->FindTracks();
 833   fModule->SortTracks();
 834   fModule->RemoveMultipleTracks();
 835
 836   Int_t nModTracks = fModule->GetNtracks();
 837   AliTRDgtuTrack *gtutrk;
 838   for (Int_t i = 0; i < nModTracks; i++) {
 839     gtutrk = (AliTRDgtuTrack*)fModule->GetTrack(i);
 840     if (TMath::Abs(gtutrk->GetPt()) < fTrigParam->GetGtuPtCut()) continue;
 841     gtutrk->CookLabel();
 842     gtutrk->MakePID();
 843     AddTrack(gtutrk,det);
 844   }
 845
 846 }
 847
 848 //_____________________________________________________________________________
 849 void AliTRDtrigger::AddTrack(const AliTRDgtuTrack *t, Int_t det)
 850 {
 851   //
 852   // Add a track to the list
 853   //
 854
 855   AliTRDgtuTrack *track = new(fTracks->operator[](fTracks->GetEntriesFast()))
 856                           AliTRDgtuTrack(*t);
 857   track->SetDetector(det);
 858
 859 }
 860
 861 //_____________________________________________________________________________
 862 TObjArray* AliTRDtrigger::Tracklets()
 863 {
 864   //
 865   // Returns list of tracklets
 866   //
 867
 868   if (!fTracklets) {
 869     fTracklets = new TObjArray(400);
 870   }
 871   return fTracklets;
 872
 873 }
 874
 875 //_____________________________________________________________________________
 876 void AliTRDtrigger::ResetTracklets()
 877 {
 878   //
 879   // Resets the list of tracklets
 880   //
 881
 882   if (fTracklets) {
 883     fTracklets->Delete();
 884   }
 885
 886 }
 887
 888 //_____________________________________________________________________________
 889 Int_t AliTRDtrigger::GetNumberOfTracks() const
 890 {
 891   //
 892   // Returns number of tracks
 893   //
 894
 895   return fTracks->GetEntriesFast();
 896
 897 }
 898
 899 //_____________________________________________________________________________
 900 AliTRDgtuTrack* AliTRDtrigger::GetTrack(Int_t i) const
 901 {
 902   //
 903   // Returns a given track from the list
 904   //
 905
 906   return (AliTRDgtuTrack *) fTracks->UncheckedAt(i);
 907
 908 }