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 "AliTRDCalibra.h"
  49 #include "Cal/AliTRDCalPIDLQ.h"
  50
  51 ClassImp(AliTRDtrigger)
  52
  53 //_____________________________________________________________________________
  54 AliTRDtrigger::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 //_____________________________________________________________________________
  86 AliTRDtrigger::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 //_____________________________________________________________________________
 118 AliTRDtrigger::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 ///_____________________________________________________________________________
 150 AliTRDtrigger::~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 //_____________________________________________________________________________
 169 AliTRDtrigger &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 //_____________________________________________________________________________
 181 void AliTRDtrigger::Copy(TObject &) const
 182 {
 183   //
 184   // Copy function
 185   //
 186
 187   AliFatal("Not implemented");
 188
 189 }
 190
 191 //_____________________________________________________________________________
 192 void 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 //_____________________________________________________________________________
 216 Bool_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 //_____________________________________________________________________________
 249 Bool_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 //_____________________________________________________________________________
 273 Bool_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 //_____________________________________________________________________________
 287 Bool_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 //_____________________________________________________________________________
 354 Bool_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 //_____________________________________________________________________________
 516 void 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 //_____________________________________________________________________________
 569 Bool_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 //_____________________________________________________________________________
 657 void 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 //_____________________________________________________________________________
 728 Bool_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 //_____________________________________________________________________________
 787 void 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 //_____________________________________________________________________________
 848 void 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 //_____________________________________________________________________________
 861 TObjArray* 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 //_____________________________________________________________________________
 875 void AliTRDtrigger::ResetTracklets()
 876 {
 877   //
 878   // Resets the list of tracklets
 879   //
 880
 881   if (fTracklets) {
 882     fTracklets->Delete();
 883   }
 884
 885 }
 886
 887 //_____________________________________________________________________________
 888 Int_t AliTRDtrigger::GetNumberOfTracks() const
 889 {
 890   //
 891   // Returns number of tracks
 892   //
 893
 894   return fTracks->GetEntriesFast();
 895
 896 }
 897
 898 //_____________________________________________________________________________
 899 AliTRDgtuTrack* 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 }