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 "AliTRDrawData.h"
  40 #include "AliTRDtrigger.h"
  41 #include "AliTRDmodule.h"
  42 #include "AliTRDmcmTracklet.h"
  43 #include "AliTRDgtuTrack.h"
  44 #include "AliTRDtrigParam.h"
  45 #include "AliTRDmcm.h"
  46 #include "AliTRDzmaps.h"
  47 #include "AliTRDCalibraFillHisto.h"
  48 #include "Cal/AliTRDCalPIDLQ.h"
  49
  50 ClassImp(AliTRDtrigger)
  51
  52 //_____________________________________________________________________________
  53 AliTRDtrigger::AliTRDtrigger()
  54   :TNamed()
  55   ,fField(0)
  56   ,fGeo(NULL)
  57   ,fRunLoader(NULL)
  58   ,fDigitsManager(NULL)
  59   ,fTrackletTree(NULL)
  60   ,fTracklets(NULL)
  61   ,fNROB(0)
  62   ,fMCM(NULL)
  63   ,fTrk(NULL)
  64   ,fTrkTest(NULL)
  65   ,fModule(NULL)
  66   ,fGTUtrk(NULL)
  67   ,fNtracklets(0)
  68   ,fDigits(NULL)
  69   ,fTrack0(NULL)
  70   ,fTrack1(NULL)
  71   ,fTrack2(NULL)
  72   ,fNPrimary(0)
  73   ,fTracks(NULL)
  74 {
  75   //
  76   // AliTRDtrigger default constructor
  77   //
  78
  79 }
  80
  81 //_____________________________________________________________________________
  82 AliTRDtrigger::AliTRDtrigger(const Text_t *name, const Text_t *title)
  83   :TNamed(name,title)
  84   ,fField(0)
  85   ,fGeo(NULL)
  86   ,fRunLoader(NULL)
  87   ,fDigitsManager(new AliTRDdigitsManager())
  88   ,fTrackletTree(NULL)
  89   ,fTracklets(new TObjArray(400))
  90   ,fNROB(0)
  91   ,fMCM(NULL)
  92   ,fTrk(NULL)
  93   ,fTrkTest(NULL)
  94   ,fModule(NULL)
  95   ,fGTUtrk(NULL)
  96   ,fNtracklets(0)
  97   ,fDigits(NULL)
  98   ,fTrack0(NULL)
  99   ,fTrack1(NULL)
 100   ,fTrack2(NULL)
 101   ,fNPrimary(0)
 102   ,fTracks(new TClonesArray("AliTRDgtuTrack",1000))
 103 {
 104   //
 105   // AliTRDtrigger constructor
 106   //
 107
 108 }
 109
 110 //_____________________________________________________________________________
 111 AliTRDtrigger::AliTRDtrigger(const AliTRDtrigger &p)
 112   :TNamed(p)
 113   ,fField(p.fField)
 114   ,fGeo(NULL)
 115   ,fRunLoader(NULL)
 116   ,fDigitsManager(NULL)
 117   ,fTrackletTree(NULL)
 118   ,fTracklets(NULL)
 119   ,fNROB(p.fNROB)
 120   ,fMCM(NULL)
 121   ,fTrk(NULL)
 122   ,fTrkTest(NULL)
 123   ,fModule(NULL)
 124   ,fGTUtrk(NULL)
 125   ,fNtracklets(p.fNtracklets)
 126   ,fDigits(NULL)
 127   ,fTrack0(NULL)
 128   ,fTrack1(NULL)
 129   ,fTrack2(NULL)
 130   ,fNPrimary(p.fNPrimary)
 131   ,fTracks(NULL)
 132 {
 133   //
 134   // AliTRDtrigger copy constructor
 135   //
 136
 137   if (fGeo) {
 138     delete fGeo;
 139   }
 140   fGeo = new AliTRDgeometry();
 141
 142 }
 143
 144 ///_____________________________________________________________________________
 145 AliTRDtrigger::~AliTRDtrigger()
 146 {
 147   //
 148   // AliTRDtrigger destructor
 149   //
 150
 151   if (fTracklets) {
 152     fTracklets->Delete();
 153     delete fTracklets;
 154   }
 155
 156   if (fTracks) {
 157     fTracks->Delete();
 158     delete fTracks;
 159   }
 160
 161   if (fGeo) {
 162     delete fGeo;
 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();
 195   fTracks->Clear();
 196
 197   // The magnetic field strength
 198   Double_t x[3] = { 0.0, 0.0, 0.0 };
 199   Double_t b[3];
 200   gAlice->Field(x,b);  // b[] is in kilo Gauss
 201   fField = b[2] * 0.1; // Tesla
 202
 203   fGeo = new AliTRDgeometry();
 204
 205   if (!AliTRDcalibDB::Instance()) {
 206     AliError("No instance of AliTRDcalibDB.");
 207     return;
 208   }
 209
 210 }
 211
 212 //_____________________________________________________________________________
 213 Bool_t AliTRDtrigger::Open(const Char_t *name, Int_t nEvent)
 214 {
 215   //
 216   // Opens the AliROOT file.
 217   //
 218
 219   TString evfoldname = AliConfig::GetDefaultEventFolderName();
 220   fRunLoader         = AliRunLoader::GetRunLoader(evfoldname);
 221
 222   if (!fRunLoader) {
 223     fRunLoader = AliRunLoader::Open(name);
 224   }
 225   if (!fRunLoader) {
 226     AliError(Form("Can not open session for file %s.",name));
 227     return kFALSE;
 228   }
 229
 230   // Import the Trees for the event nEvent in the file
 231   fRunLoader->GetEvent(nEvent);
 232
 233   // Open output
 234   TObjArray *ioArray = 0;
 235   AliLoader* loader  = fRunLoader->GetLoader("TRDLoader");
 236   loader->MakeTree("T");
 237   fTrackletTree = loader->TreeT();
 238   fTrackletTree->Branch("TRDmcmTracklet","TObjArray",&ioArray,32000,0);
 239   Init();
 240
 241   return kTRUE;
 242
 243 }
 244
 245 //_____________________________________________________________________________
 246 Bool_t AliTRDtrigger::ReadDigits()
 247 {
 248   //
 249   // Reads the digits arrays from the input aliroot file
 250   //
 251
 252   if (!fRunLoader) {
 253     AliError("Can not find the Run Loader");
 254     return kFALSE;
 255   }
 256
 257   AliLoader* loader = fRunLoader->GetLoader("TRDLoader");
 258   if (!loader->TreeD()) {
 259     loader->LoadDigits();
 260   }
 261   if (!loader->TreeD()) {
 262      return kFALSE;
 263   }
 264
 265   return (fDigitsManager->ReadDigits(loader->TreeD()));
 266
 267 }
 268
 269 //_____________________________________________________________________________
 270 Bool_t AliTRDtrigger::ReadDigits(AliRawReader* rawReader)
 271 {
 272   //
 273   // Reads the digits arrays from the ddl file
 274   //
 275
 276   AliTRDrawData *raw = new AliTRDrawData();
 277   fDigitsManager     = raw->Raw2Digits(rawReader);
 278
 279   return kTRUE;
 280
 281 }
 282
 283 //_____________________________________________________________________________
 284 Bool_t AliTRDtrigger::ReadDigits(TTree *digitsTree)
 285 {
 286   //
 287   // Reads the digits arrays from the input tree
 288   //
 289
 290   return (fDigitsManager->ReadDigits(digitsTree));
 291
 292 }
 293
 294 //_____________________________________________________________________________
 295 Bool_t AliTRDtrigger::ReadTracklets(AliRunLoader *rl)
 296 {
 297   //
 298   // Reads the tracklets find the tracks
 299   //
 300
 301   Int_t idet;
 302
 303   AliLoader *loader = rl->GetLoader("TRDLoader");
 304   loader->LoadTracks();
 305   fTrackletTree     = loader->TreeT();
 306
 307   TBranch *branch   = fTrackletTree->GetBranch("TRDmcmTracklet");
 308   if (!branch) {
 309     AliError("Can't get the branch !");
 310     return kFALSE;
 311   }
 312   TObjArray *tracklets = new TObjArray(400);
 313   branch->SetAddress(&tracklets);
 314
 315   Int_t nEntries   = (Int_t) fTrackletTree->GetEntries();
 316   Int_t iEntry;
 317   Int_t itrk;
 318   Int_t iStack;
 319   Int_t iStackPrev = -1;
 320
 321   for (iEntry = 0; iEntry < nEntries; iEntry++) {
 322
 323     fTrackletTree->GetEvent(iEntry);
 324
 325     for (itrk = 0; itrk < tracklets->GetEntriesFast(); itrk++) {
 326
 327       fTrk   = (AliTRDmcmTracklet *) tracklets->UncheckedAt(itrk);
 328       idet   = fTrk->GetDetector();
 329       iStack = idet / (AliTRDgeometry::Nplan());
 330
 331       if (iStackPrev != iStack) {
 332         if (iStackPrev == -1) {
 333           iStackPrev = iStack;
 334         }
 335         else {
 336           MakeTracks(idet - AliTRDgeometry::Nplan());
 337           ResetTracklets();
 338           iStackPrev = iStack;
 339         }
 340       }
 341
 342       Tracklets()->Add(fTrk);
 343
 344       if ((iEntry == (nEntries-1)) &&
 345           (itrk   == (tracklets->GetEntriesFast() - 1))) {
 346         idet++;
 347         MakeTracks(idet-AliTRDgeometry::Nplan());
 348         ResetTracklets();
 349       }
 350
 351     }
 352
 353   }
 354
 355   loader->UnloadTracks();
 356
 357   return kTRUE;
 358
 359 }
 360
 361 //_____________________________________________________________________________
 362 Bool_t AliTRDtrigger::MakeTracklets(Bool_t makeTracks)
 363 {
 364   //
 365   // Create tracklets from digits
 366   //
 367
 368   Int_t chamBeg = 0;
 369   Int_t chamEnd = AliTRDgeometry::Ncham();
 370   Int_t planBeg = 0;
 371   Int_t planEnd = AliTRDgeometry::Nplan();
 372   Int_t sectBeg = 0;
 373   Int_t sectEnd = AliTRDgeometry::Nsect();
 374
 375   fTrkTest = new AliTRDmcmTracklet(0,0,0);
 376   fMCM     = new AliTRDmcm(0);
 377
 378   Int_t   time;
 379   Int_t   col;
 380   Int_t   row;
 381   Int_t   col1;
 382   Int_t   col2;
 383   Int_t   idet       = -1;
 384   Int_t   iStack     = -1;
 385   Int_t   iStackPrev = -1;
 386   Float_t amp;
 387
 388   for (Int_t isect = sectBeg; isect < sectEnd; isect++) {
 389
 390     for (Int_t icham = chamBeg; icham < chamEnd; icham++) {
 391
 392       // Number of ROBs in the chamber
 393       if(icham == 2) {
 394         fNROB = 6;
 395       }
 396       else {
 397         fNROB = 8;
 398       }
 399
 400       for (Int_t iplan = planBeg; iplan < planEnd; iplan++) {
 401
 402         idet = fGeo->GetDetector(iplan,icham,isect);
 403         ResetTracklets();
 404
 405         if (makeTracks) {
 406           iStack = idet / (AliTRDgeometry::Nplan());
 407           if (iStackPrev != iStack) {
 408             if (iStackPrev == -1) {
 409               iStackPrev = iStack;
 410             }
 411             else {
 412               MakeTracks(idet-AliTRDgeometry::Nplan());
 413               ResetTracklets();
 414               iStackPrev = iStack;
 415             }
 416           }
 417         }
 418
 419         Int_t nRowMax    = fGeo->GetRowMax(iplan,icham,isect);
 420         Int_t nColMax    = fGeo->GetColMax(iplan);
 421         Int_t nTimeTotal = AliTRDcalibDB::Instance()->GetNumberOfTimeBins();
 422
 423         // Get the digits
 424         fDigits = fDigitsManager->GetDigits(idet);
 425         if (!fDigits) return kFALSE;
 426         // This is to take care of switched off super modules
 427         if (fDigits->GetNtime() == 0) {
 428           continue;
 429         }
 430         fDigits->Expand();
 431         fTrack0 = fDigitsManager->GetDictionary(idet,0);
 432         if (!fTrack0) return kFALSE;
 433         fTrack0->Expand();
 434         fTrack1 = fDigitsManager->GetDictionary(idet,1);
 435         if (!fTrack1) return kFALSE;
 436         fTrack1->Expand();
 437         fTrack2 = fDigitsManager->GetDictionary(idet,2);
 438         if (!fTrack2) return kFALSE;
 439         fTrack2->Expand();
 440
 441         for (Int_t iRob = 0; iRob < fNROB; iRob++) {
 442
 443           for (Int_t iMcm = 0; iMcm < kNMCM; iMcm++) {
 444
 445             fMCM->Reset();
 446             fMCM->SetRobId(iRob);
 447             fMCM->SetChaId(idet);
 448
 449             SetMCMcoordinates(iMcm);
 450
 451             row = fMCM->GetRow();
 452
 453             if ((row < 0) || (row >= nRowMax)) {
 454               AliError("MCM row number out of range.");
 455               continue;
 456             }
 457
 458             fMCM->GetColRange(col1,col2);
 459
 460             for (time = 0; time < nTimeTotal; time++) {
 461               for (col = col1; col < col2; col++) {
 462                 if ((col >= 0) && (col < nColMax)) {
 463                   amp = TMath::Abs(fDigits->GetDataUnchecked(row,col,time));
 464                 }
 465                 else {
 466                   amp = 0.0;
 467                 }
 468                 fMCM->SetADC(col-col1,time,amp);
 469               }
 470             }
 471
 472             if (AliTRDtrigParam::Instance()->GetTailCancelation()) {
 473               fMCM->Filter(AliTRDtrigParam::Instance()->GetNexponential()
 474                           ,AliTRDtrigParam::Instance()->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                 AliDebug(2,Form("Add tracklet %d in col %02d \n",fNtracklets,fMCM->GetSeedCol()[iSeed]));
 486
 487                 if (TestTracklet(idet,row,iSeed,0)) {
 488                   AddTracklet(idet,row,iSeed,fNtracklets++);
 489                 }
 490
 491               }
 492
 493             }
 494
 495           }
 496
 497
 498         }
 499
 500         // Compress the arrays
 501         fDigits->Compress(1,0);
 502         fTrack0->Compress(1,0);
 503         fTrack1->Compress(1,0);
 504         fTrack2->Compress(1,0);
 505
 506         WriteTracklets(idet);
 507
 508      }
 509     }
 510   }
 511
 512   if (makeTracks) {
 513     idet++;
 514     MakeTracks(idet - AliTRDgeometry::Nplan());
 515     ResetTracklets();
 516   }
 517
 518   return kTRUE;
 519
 520 }
 521
 522 //_____________________________________________________________________________
 523 void AliTRDtrigger::SetMCMcoordinates(Int_t imcm)
 524 {
 525   //
 526   // Configure MCM position in the pad plane
 527   //
 528
 529   Int_t robid = fMCM->GetRobId();
 530
 531   // setting the Row and Col range
 532
 533   const Int_t kNcolRob = 2;  // number of ROBs per chamber in column direction
 534   const Int_t kNmcmRob = 4;  // number of MCMs per ROB in column/row direction
 535
 536   Int_t mcmid = imcm%(kNmcmRob*kNmcmRob);
 537
 538   if (robid%kNcolRob == 0) {
 539
 540     if (mcmid%kNmcmRob == 0) {
 541       fMCM->SetColRange(18*0-1,18*1-1+2+1);
 542     }
 543     if (mcmid%kNmcmRob == 1) {
 544       fMCM->SetColRange(18*1-1,18*2-1+2+1);
 545     }
 546     if (mcmid%kNmcmRob == 2) {
 547       fMCM->SetColRange(18*2-1,18*3-1+2+1);
 548     }
 549     if (mcmid%kNmcmRob == 3) {
 550       fMCM->SetColRange(18*3-1,18*4-1+2+1);
 551     }
 552
 553   }
 554   else {
 555
 556     if (mcmid%kNmcmRob == 0) {
 557       fMCM->SetColRange(18*4-1,18*5-1+2+1);
 558     }
 559     if (mcmid%kNmcmRob == 1) {
 560       fMCM->SetColRange(18*5-1,18*6-1+2+1);
 561     }
 562     if (mcmid%kNmcmRob == 2) {
 563       fMCM->SetColRange(18*6-1,18*7-1+2+1);
 564     }
 565     if (mcmid%kNmcmRob == 3) {
 566       fMCM->SetColRange(18*7-1,18*8-1+2+1);
 567     }
 568
 569   }
 570
 571   fMCM->SetRow(kNmcmRob*(robid/kNcolRob)+mcmid/kNmcmRob);
 572
 573 }
 574
 575 //_____________________________________________________________________________
 576 Bool_t AliTRDtrigger::TestTracklet(Int_t det, Int_t row, Int_t seed, Int_t n)
 577 {
 578   //
 579   // Check first the tracklet pt
 580   //
 581
 582   Int_t nTimeTotal  = AliTRDcalibDB::Instance()->GetNumberOfTimeBins();
 583
 584   // Calibration fill 2D
 585   AliTRDCalibraFillHisto *calibra = AliTRDCalibraFillHisto::Instance();
 586   if (!calibra) {
 587     AliInfo("Could not get Calibra instance\n");
 588   }
 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   fTrkTest->MakeTrackletGraph(fGeo,fField);
 647
 648   // TRD Online calibration
 649   if (calibra->GetMcmTracking()) {
 650     calibra->UpdateHistogramcm(fTrkTest);
 651   }
 652
 653   fTrkTest->MakeClusAmpGraph();
 654
 655   if (TMath::Abs(fTrkTest->GetPt()) < AliTRDtrigParam::Instance()->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  = AliTRDcalibDB::Instance()->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()) < AliTRDtrigParam::Instance()->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 = fGeo->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()) < AliTRDtrigParam::Instance()->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 }