TRD/AliTRDtrigger.cxx

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