TRD/AliTRDdigitsManager.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 /* $Id$ */
  17
  18 ///////////////////////////////////////////////////////////////////////////////
  19 //                                                                           //
  20 //  Manages the digits and the track dictionary in the form of               //
  21 //  TObjArray objects                                                        //
  22 //                                                                           //
  23 ///////////////////////////////////////////////////////////////////////////////
  24
  25 #include <TTree.h>
  26
  27 #include "AliLog.h"
  28
  29 #include "AliTRDdigitsManager.h"
  30 #include "AliTRDarrayDictionary.h"
  31 #include "AliTRDarrayADC.h"
  32 #include "AliTRDarraySignal.h"
  33 #include "AliTRDdigit.h"
  34 #include "AliTRDgeometry.h"
  35 #include "AliTRDSignalIndex.h"
  36
  37 ClassImp(AliTRDdigitsManager)
  38
  39 //_____________________________________________________________________________
  40
  41   // Number of track dictionary arrays
  42   const Int_t AliTRDdigitsManager::fgkNDict = kNDict;
  43
  44 //_____________________________________________________________________________
  45 AliTRDdigitsManager::AliTRDdigitsManager(Bool_t rawRec)
  46   :TObject()
  47   ,fEvent(0)
  48   ,fTree(0)
  49   ,fDigits(0)
  50   ,fHasSDigits(0)
  51   ,fSignalIndexes(NULL)
  52   ,fUseDictionaries(kTRUE)
  53   ,fTreeD(0)
  54   ,fBranch(0)
  55   ,fDets(AliTRDgeometry::Ndet())
  56   ,fRawRec(rawRec)
  57 {
  58   //
  59   // Default constructor
  60   //
  61
  62   if(fRawRec)
  63     {
  64       fDets=1;
  65       fRawRec=kTRUE;
  66     }
  67
  68   for (Int_t iDict = 0; iDict < kNDict; iDict++)
  69     {
  70       fDict[iDict] = NULL;
  71     }
  72 }
  73
  74 //_____________________________________________________________________________
  75 AliTRDdigitsManager::AliTRDdigitsManager(const AliTRDdigitsManager &m)
  76   :TObject(m)
  77   ,fEvent(m.fEvent)
  78   ,fTree(0)
  79   ,fDigits(0)
  80   ,fHasSDigits(m.fHasSDigits)
  81   ,fSignalIndexes(NULL)
  82   ,fUseDictionaries(kTRUE)
  83   ,fTreeD(m.fTree)
  84   ,fBranch(m.fBranch)
  85   ,fDets(m.fDets)
  86   ,fRawRec(m.fRawRec)
  87 {
  88   //
  89   // AliTRDdigitsManager copy constructor
  90   //
  91
  92 }
  93
  94 //_____________________________________________________________________________
  95 AliTRDdigitsManager::~AliTRDdigitsManager()
  96 {
  97   //
  98   // AliTRDdigitsManager destructor
  99   //
 100
 101
 102   if (fDigits)
 103     {
 104       fDigits->Delete();
 105       delete fDigits;
 106       fDigits = NULL;
 107     }
 108
 109   for (Int_t iDict = 0; iDict < kNDict; iDict++)
 110     {
 111       if(fDict[iDict])
 112         {
 113           fDict[iDict]->Delete();
 114           delete fDict[iDict];
 115           fDict[iDict] = NULL;
 116         }
 117     }
 118
 119   if (fSignalIndexes)
 120     {
 121       fSignalIndexes->Delete();
 122       delete fSignalIndexes;
 123       fSignalIndexes = NULL;
 124     }
 125
 126 }
 127
 128 //_____________________________________________________________________________
 129 AliTRDdigitsManager &AliTRDdigitsManager::operator=(const AliTRDdigitsManager &m)
 130 {
 131   //
 132   // Assignment operator
 133   //
 134
 135   if (this != &m)
 136     {
 137       ((AliTRDdigitsManager &) m).Copy(*this);
 138     }
 139
 140   return *this;
 141
 142 }
 143
 144 //_____________________________________________________________________________
 145 void AliTRDdigitsManager::Copy(TObject &m) const
 146 {
 147   //
 148   // Copy function
 149   //
 150
 151   ((AliTRDdigitsManager &) m).fEvent           = fEvent;
 152   ((AliTRDdigitsManager &) m).fHasSDigits      = fHasSDigits;
 153   ((AliTRDdigitsManager &) m).fDigits          = fDigits;
 154   for(Int_t i=0; i<kNDict; i++)
 155     {
 156       ((AliTRDdigitsManager &) m).fDict[i]  = fDict[i];
 157     }
 158   ((AliTRDdigitsManager &) m).fSignalIndexes   = fSignalIndexes;
 159   ((AliTRDdigitsManager &) m).fUseDictionaries = fUseDictionaries;
 160   ((AliTRDdigitsManager &) m).fDets            = fDets;
 161   ((AliTRDdigitsManager &) m).fRawRec           = fRawRec;
 162
 163   TObject::Copy(m);
 164
 165 }
 166
 167 //_____________________________________________________________________________
 168 void AliTRDdigitsManager::CreateArrays()
 169 {
 170   //
 171   // Create the data arrays
 172   //
 173
 174   if (fHasSDigits)
 175     {
 176       if(fDigits)
 177         {
 178           fDigits->Delete();
 179           delete fDigits;
 180         }
 181       fDigits = new TObjArray(fDets);
 182       for (Int_t index = 0; index < fDets; index++)
 183         fDigits->AddAt(new AliTRDarraySignal(),index);
 184     }
 185   else
 186     {
 187       if(fDigits)
 188         {
 189           fDigits->Delete();
 190           delete fDigits;
 191         }
 192       fDigits = new TObjArray(fDets);
 193       for (Int_t index = 0; index < fDets;index++)
 194         fDigits->AddAt(new AliTRDarrayADC(),index);
 195     }
 196
 197   if (fUseDictionaries)
 198     {
 199       for(Int_t iDict = 0; iDict < kNDict; iDict++)
 200         if(fDict[iDict])
 201           {
 202             fDict[iDict]->Delete();
 203             delete fDict[iDict];
 204           }
 205       for(Int_t iDict = 0; iDict < kNDict; iDict++)
 206         fDict[iDict] = new TObjArray(fDets);
 207
 208       for (Int_t iDict = 0; iDict < kNDict; iDict++)
 209         for (Int_t index = 0; index < fDets; index++)
 210           fDict[iDict]->AddAt(new AliTRDarrayDictionary(),index);
 211     }
 212
 213   if(fSignalIndexes)
 214     {
 215       fSignalIndexes->Delete();
 216       delete fSignalIndexes;
 217     }
 218   fSignalIndexes = new TObjArray(fDets);
 219   for (Int_t i = 0; i < fDets; i++)
 220     fSignalIndexes->AddLast(new AliTRDSignalIndex());
 221
 222 }
 223
 224 //_____________________________________________________________________________
 225 void AliTRDdigitsManager::ResetArrays()
 226 {
 227   //
 228   // Reset the data arrays
 229   //
 230
 231   if (fDigits)
 232     {
 233       fDigits->Delete();
 234       delete fDigits;
 235     }
 236   if (fHasSDigits)
 237     {
 238       fDigits = new TObjArray(fDets);
 239       for (Int_t index = 0; index < fDets; index++)
 240         fDigits->AddAt(new AliTRDarraySignal(),index);
 241     }
 242   else
 243     {
 244       fDigits = new TObjArray(fDets);
 245       for (Int_t index = 0; index < fDets; index++)
 246         fDigits->AddAt(new AliTRDarrayADC(),index);
 247     }
 248
 249   for (Int_t iDict = 0; iDict < kNDict; iDict++)
 250     {
 251       if (fDict[iDict])
 252         {
 253           fDict[iDict]->Delete();
 254           delete fDict[iDict];
 255           fDict[iDict]=NULL;
 256         }
 257     }
 258   if (fUseDictionaries)
 259     {
 260       for(Int_t iDict = 0; iDict < kNDict; iDict++)
 261         fDict[iDict] = new TObjArray(fDets);
 262
 263       for (Int_t iDict = 0; iDict < kNDict; iDict++)
 264         for (Int_t index = 0; index < fDets; index++)
 265           fDict[iDict]->AddAt(new AliTRDarrayDictionary(),index);
 266     }
 267
 268   if(fSignalIndexes)
 269     {
 270       fSignalIndexes->Delete();
 271       delete fSignalIndexes;
 272     }
 273   fSignalIndexes = new TObjArray(fDets);
 274   for (Int_t i = 0; i < fDets; i++)
 275     fSignalIndexes->AddLast(new AliTRDSignalIndex());
 276 }
 277
 278 //_____________________________________________________________________________
 279 void AliTRDdigitsManager::ResetArrays(Int_t det)
 280 {
 281   //
 282   // Reset the data arrays
 283   //
 284
 285   Int_t recoDet = fRawRec ? 0 : det;
 286
 287   RemoveDigits(recoDet);
 288   RemoveDictionaries(recoDet);
 289   RemoveIndexes(recoDet);
 290
 291   if (fHasSDigits)
 292     fDigits->AddAt(new AliTRDarraySignal(),recoDet);
 293   else
 294     fDigits->AddAt(new AliTRDarrayADC(),recoDet);
 295
 296   if (fUseDictionaries)
 297     {
 298       for (Int_t iDict = 0; iDict < kNDict; iDict++)
 299         fDict[iDict]->AddAt(new AliTRDarrayDictionary(),recoDet);
 300     }
 301
 302   fSignalIndexes->AddAt(new AliTRDSignalIndex(),recoDet);
 303 }
 304
 305 //_____________________________________________________________________________
 306 Short_t AliTRDdigitsManager::GetDigitAmp(Int_t row, Int_t col,Int_t time, Int_t det) const
 307 {
 308   //
 309   // Returns the amplitude of a digit
 310   //
 311
 312   if (!GetDigits(det)) return 0;
 313
 314   return ((Short_t) ((AliTRDarrayADC *) GetDigits(det))->GetDataBits(row,col,time));
 315
 316 }
 317
 318 //_____________________________________________________________________________
 319 UChar_t AliTRDdigitsManager::GetPadStatus(Int_t row, Int_t col, Int_t time, Int_t det) const
 320 {
 321   //
 322   // Returns the pad status for the requested pad
 323   //
 324
 325   if (!GetDigits(det)) return 0;
 326
 327   return ((UChar_t) ((AliTRDarrayADC *) GetDigits(det))->GetPadStatus(row,col,time));
 328
 329 }
 330
 331 //_____________________________________________________________________________
 332 Bool_t AliTRDdigitsManager::MakeBranch(TTree * const tree)
 333 {
 334   //
 335   // Creates the tree and branches for the digits and the dictionary
 336   //
 337
 338   Int_t  buffersize = 64000;
 339   Bool_t status     = kTRUE;
 340
 341   if (tree)
 342     {
 343       fTree = tree;
 344     }
 345
 346   // Make the branch for the digits
 347   if (fDigits)
 348     {
 349       if(fHasSDigits)
 350         {
 351           const AliTRDarraySignal *kDigits = (AliTRDarraySignal *) fDigits->At(0);
 352           if (kDigits)
 353             {
 354               if (!fTree) return kFALSE;
 355               AliDebug(1,"Making branch for SDigits!\n");
 356               TBranch* branch = fTree->GetBranch("TRDdigits");
 357               if (!branch) fTree->Branch("TRDdigits","AliTRDarraySignal",&kDigits,buffersize,99);
 358               AliDebug(1,"Making branch TRDdigits\n");
 359             }
 360           else
 361             {
 362               status = kFALSE;
 363             }
 364         }
 365
 366       if(!fHasSDigits)
 367         {
 368           const AliTRDarrayADC *kDigits = (AliTRDarrayADC *) fDigits->At(0);
 369           if (kDigits)
 370             {
 371               if (!fTree) return kFALSE;
 372               AliDebug(1,"Making branch for Digits!\n");
 373               TBranch* branch = fTree->GetBranch("TRDdigits");
 374               if (!branch) fTree->Branch("TRDdigits","AliTRDarrayADC",&kDigits,buffersize,99);
 375               AliDebug(1,"Making branch TRDdigits\n");
 376             }
 377           else
 378             {
 379               status = kFALSE;
 380             }
 381         }
 382
 383     }
 384   else
 385     {
 386       status = kFALSE;
 387     }
 388
 389   if (fUseDictionaries)
 390     {
 391       // Make the branches for the dictionaries
 392       for (Int_t iDict = 0; iDict < kNDict; iDict++)
 393         {
 394           Char_t branchname[15];
 395           sprintf(branchname,"TRDdictionary%d",iDict);
 396           if (fDict[iDict])
 397             {
 398               const AliTRDarrayDictionary *kDictionary = (AliTRDarrayDictionary *) fDict[iDict]->At(0);
 399               if (kDictionary)
 400                 {
 401                   if (!fTree) return kFALSE;
 402                   AliDebug(2,"Making branch for dictionary!\n");
 403                   TBranch* branch = fTree->GetBranch(branchname);
 404                   if (!branch) fTree->Branch(branchname,"AliTRDarrayDictionary",&kDictionary,buffersize,99);
 405                   AliDebug(1,Form("Making branch %s\n",branchname));
 406                 }
 407               else
 408                 {
 409                   status = kFALSE;
 410                 }
 411             }
 412           else
 413             {
 414               status = kFALSE;
 415             }
 416         }
 417     }
 418
 419   return status;
 420
 421 }
 422
 423 //_____________________________________________________________________________
 424 Bool_t AliTRDdigitsManager::ReadDigits(TTree * const tree)
 425 {
 426   //
 427   // Reads the digit information from the input file
 428   //
 429
 430   Bool_t status = kTRUE;
 431
 432   if (tree)
 433     {
 434       fTree = tree;
 435     }
 436
 437   if (!fDigits)
 438     {
 439       AliDebug(1,"Create the data arrays.\n");
 440       CreateArrays();
 441     }
 442
 443   status = LoadArray(fDigits,"TRDdigits",fTree);
 444
 445   if (fUseDictionaries)
 446     {
 447       for (Int_t iDict = 0; iDict < kNDict; iDict++)
 448         {
 449           Char_t branchname[15];
 450           sprintf(branchname,"TRDdictionary%d",iDict);
 451           status = LoadArrayDict(fDict[iDict],branchname,fTree);
 452           if (status == kFALSE)
 453             {
 454               fUseDictionaries = kFALSE;
 455               AliWarning("Unable to load dict arrays. Will not use them.\n");
 456               break;
 457             }
 458         }
 459     }
 460
 461   return kTRUE;
 462
 463 }
 464
 465 //_____________________________________________________________________________
 466 Bool_t AliTRDdigitsManager::WriteDigits()
 467 {
 468   //
 469   // Writes out the TRD-digits and the dictionaries
 470   //
 471
 472   // Store the contents of the detector array in the tree
 473
 474   if (!StoreArray(fDigits,"TRDdigits",fTree))
 475     {
 476       AliError("Error while storing digits in branch TRDdigits\n");
 477       return kFALSE;
 478     }
 479
 480   if (fUseDictionaries)
 481     {
 482       for (Int_t iDict = 0; iDict < kNDict; iDict++)
 483         {
 484           Char_t branchname[15];
 485           sprintf(branchname,"TRDdictionary%d",iDict);
 486           if (!StoreArrayDict(fDict[iDict],branchname,fTree))
 487             {
 488               AliError(Form("Error while storing dictionary in branch %s\n",branchname));
 489               return kFALSE;
 490             }
 491         }
 492     }
 493
 494   // Write the new tree to the output file
 495   fTree->AutoSave();
 496
 497   return kTRUE;
 498
 499 }
 500
 501 //_____________________________________________________________________________
 502 AliTRDdigit *AliTRDdigitsManager::GetDigit(Int_t row
 503                                          , Int_t col
 504                                          , Int_t time
 505                                          , Int_t det) const
 506 {
 507   //
 508   // Creates a single digit object
 509   //
 510
 511   Int_t digits[4];
 512   Int_t amp[1];
 513
 514   digits[0] = det;
 515   digits[1] = row;
 516   digits[2] = col;
 517   digits[3] = time;
 518
 519   amp[0]    = ((AliTRDarrayADC *) GetDigits(det))->GetData(row,col,time);
 520
 521   return (new AliTRDdigit(digits,amp));
 522
 523 }
 524
 525 //_____________________________________________________________________________
 526 Int_t AliTRDdigitsManager::GetTrack(Int_t track
 527                                   , Int_t row
 528                                   , Int_t col
 529                                   , Int_t time
 530                                   , Int_t det) const
 531 {
 532   //
 533   // Returns the MC-track numbers from the dictionary.
 534   //
 535
 536   if ((track < 0) || (track >= kNDict))
 537     {
 538       AliError(Form("track %d out of bounds (size: %d, this: 0x%08x)",track,kNDict,this));
 539       return -1;
 540     }
 541
 542   if (fUseDictionaries == kFALSE)
 543     {
 544       return -1;
 545     }
 546
 547   // Array contains index+1 to allow data compression--->Changed
 548   return (((AliTRDarrayDictionary *) GetDictionary(det,track))->GetData(row,col,time) );
 549
 550 }
 551
 552 //________________________________________________________________________________
 553 AliTRDarrayADC *AliTRDdigitsManager::GetDigits(Int_t det) const
 554 {
 555   //
 556   // Returns the digits array for one detector
 557   //
 558
 559   Int_t RecoDet = fRawRec ? 0 : det;
 560
 561   if (!fDigits)
 562     {
 563       return 0x0;
 564     }
 565
 566   if (!fHasSDigits)
 567     {
 568       ((AliTRDarrayADC *) fDigits->At(RecoDet))->SetNdet(det);
 569       return (AliTRDarrayADC *) fDigits->At(RecoDet);
 570     }
 571   else
 572     {
 573       AliDebug(2,"ERROR IN DATA TYPE!!!!");
 574       return 0x0;
 575     }
 576
 577 }
 578
 579 //_____________________________________________________________________________
 580 AliTRDarraySignal *AliTRDdigitsManager::GetSDigits(Int_t det) const
 581 {
 582   //
 583   // Returns the sdigits array for one detector
 584   //
 585
 586   Int_t RecoDet = fRawRec ? 0 : det;
 587
 588   if (!fDigits)
 589     {
 590       //      AliDebug(1,"NO FDIGITS!");
 591       return 0x0;
 592     }
 593
 594   if (fHasSDigits)
 595     {
 596       ((AliTRDarraySignal *) fDigits->At(RecoDet))->SetNdet(det);
 597       return (AliTRDarraySignal *) fDigits->At(RecoDet);
 598     }
 599   else
 600     {
 601       AliDebug(2,"ERROR IN DATA TYPE!!!!");
 602       return 0x0;
 603     }
 604
 605 }
 606
 607 //_____________________________________________________________________________
 608 AliTRDarrayDictionary *AliTRDdigitsManager::GetDictionary(Int_t det
 609                                                         , Int_t i) const
 610 {
 611   //
 612   // Returns the dictionary for one detector
 613   //
 614
 615   Int_t RecoDet = fRawRec ? 0 : det;
 616
 617   if (fUseDictionaries == kFALSE)
 618     {
 619       return 0x0;
 620     }
 621
 622   ((AliTRDarrayDictionary *) fDigits->At(RecoDet))->SetNdet(det);
 623   return (AliTRDarrayDictionary *) fDict[i]->At(RecoDet);
 624
 625 }
 626
 627 //_____________________________________________________________________________
 628 Int_t AliTRDdigitsManager::GetTrack(Int_t track, AliTRDdigit * const digit) const
 629 {
 630   //
 631   // Returns the MC-track numbers from the dictionary for a given digit
 632   //
 633
 634   Int_t row  = digit->GetRow();
 635   Int_t col  = digit->GetCol();
 636   Int_t time = digit->GetTime();
 637   Int_t det  = digit->GetDetector();
 638
 639   return GetTrack(track,row,col,time,det);
 640
 641 }
 642
 643 //_____________________________________________________________________________
 644 AliTRDSignalIndex *AliTRDdigitsManager::GetIndexes(Int_t det)
 645 {
 646   //
 647   // Returns indexes of active pads
 648   //
 649
 650   Int_t RecoDet = fRawRec ? 0 : det;
 651
 652   return (AliTRDSignalIndex *) fSignalIndexes->At(RecoDet);
 653
 654 }
 655
 656 //_____________________________________________________________________________
 657 void AliTRDdigitsManager::RemoveDigits(Int_t det)
 658 {
 659    //
 660    // Clear memory at det for Digits
 661    //
 662
 663   Int_t RecoDet = fRawRec ? 0 : det;
 664
 665   if (fDigits->At(RecoDet))
 666     {
 667       if (fHasSDigits)
 668         {
 669           AliTRDarraySignal *arr = (AliTRDarraySignal *) fDigits->RemoveAt(RecoDet);
 670           delete arr;
 671         }
 672       else
 673         {
 674           AliTRDarrayADC    *arr = (AliTRDarrayADC *)    fDigits->RemoveAt(RecoDet);
 675           delete arr;
 676         }
 677     }
 678
 679 }
 680
 681 //_____________________________________________________________________________
 682 void AliTRDdigitsManager::RemoveDictionaries(Int_t det)
 683 {
 684   //
 685   // Clear memory
 686   //
 687
 688   Int_t RecoDet = fRawRec ? 0 : det;
 689
 690   if (fUseDictionaries == kFALSE)
 691     {
 692       return;
 693     }
 694
 695   for (Int_t i = 0; i < kNDict; i++)
 696     {
 697       if (fDict[i]->At(RecoDet))
 698         {
 699           AliTRDarrayDictionary *arr = (AliTRDarrayDictionary *) fDict[i]->RemoveAt(RecoDet);
 700           delete arr;
 701         }
 702     }
 703
 704 }
 705
 706 //_____________________________________________________________________________
 707 void AliTRDdigitsManager::RemoveIndexes(Int_t det)
 708 {
 709    //
 710    // Clear memory
 711    //
 712
 713   Int_t RecoDet = fRawRec ? 0 : det;
 714
 715   if (fSignalIndexes->At(RecoDet))
 716     {
 717       AliTRDSignalIndex *arr = (AliTRDSignalIndex *) fSignalIndexes->RemoveAt(RecoDet);
 718       delete arr;
 719     }
 720
 721 }
 722
 723
 724 //_____________________________________________________________________________
 725 void AliTRDdigitsManager::ClearIndexes(Int_t det)
 726 {
 727   //
 728   // Clear memory
 729   //
 730
 731   Int_t RecoDet = fRawRec ? 0 : det;
 732
 733   ((AliTRDSignalIndex *) fSignalIndexes->At(RecoDet))->ClearAll();
 734
 735 }
 736
 737 //_____________________________________________________________________________
 738 Bool_t AliTRDdigitsManager::BuildIndexes(Int_t det)
 739 {
 740   //
 741   // Build the list of indices
 742   //
 743
 744   Int_t nRows  = 0;
 745   Int_t nCols  = 0;
 746   Int_t nTbins = 0;
 747
 748   AliTRDgeometry  geom;
 749   AliTRDarrayADC *digits = 0x0;
 750
 751   if (fHasSDigits)
 752     {
 753       return kFALSE;
 754     }
 755   else
 756     {
 757       digits = (AliTRDarrayADC *) GetDigits(det);
 758     }
 759
 760   //digits should be expanded by now!!!
 761   if (digits->GetNtime() > 0)
 762     {
 763       digits->Expand();
 764       nRows  = digits->GetNrow();
 765       nCols  = digits->GetNcol();
 766       nTbins = digits->GetNtime();
 767
 768       AliTRDSignalIndex *indexes = GetIndexes(det);
 769       indexes->SetSM(geom.GetSector(det));
 770       indexes->SetStack(geom.GetStack(det));
 771       indexes->SetLayer(geom.GetLayer(det));
 772       indexes->SetDetNumber(det);
 773
 774       if (indexes->IsAllocated() == kFALSE)
 775         {
 776           indexes->Allocate(nRows,nCols,nTbins);
 777         }
 778
 779       for (Int_t ir = 0; ir < nRows; ir++)
 780         {
 781           for (Int_t ic = 0; ic < nCols; ic++)
 782             {
 783               for (Int_t it = 0; it < nTbins; it++)
 784                 {
 785                   Int_t isig = digits->GetDataBits(ir,ic,it);
 786                   if (isig > 0)
 787                     {
 788                       indexes->AddIndexRC(ir,ic);
 789                     }
 790                 } // tbins
 791             } // cols
 792         } // rows
 793
 794     } // if GetNtime
 795   else
 796     {
 797       return kFALSE;
 798     }
 799
 800   return kTRUE;
 801
 802 }
 803
 804 //_____________________________________________________________________________
 805 Bool_t AliTRDdigitsManager::LoadArray(TObjArray * const object
 806                                     , const Char_t *branchname
 807                                     , TTree * const tree)
 808 {
 809   //
 810   // Loads all detectors of the array from the branch <branchname> of
 811   // the digits tree <tree>
 812   // Adapted from code of the class AliTRDsegmentArray
 813   //
 814
 815   fTreeD = tree;
 816
 817   if (!fTreeD)
 818     {
 819       AliError("Digits tree is not defined\n");
 820       return kFALSE;
 821     }
 822
 823   // Get the branch
 824   fBranch = fTreeD->GetBranch(branchname);
 825   if (!fBranch)
 826     {
 827       AliError(Form("Branch %s is not defined\n",branchname));
 828       return kFALSE;
 829     }
 830
 831   // Loop through all detectors and read them from the tree
 832   Bool_t status = kTRUE;
 833   for (Int_t iDet = 0; iDet < fDets; iDet++)
 834     {
 835       if(fHasSDigits)
 836         {
 837           AliTRDarraySignal *dataArray = (AliTRDarraySignal *) object->At(iDet);
 838           if (!dataArray)
 839             {
 840               status = kFALSE;
 841               break;
 842             }
 843
 844           fBranch->SetAddress(&dataArray);
 845           fBranch->GetEntry(iDet);
 846         }
 847       else
 848         {
 849           AliTRDarrayADC *dataArray = (AliTRDarrayADC *) object->At(iDet);
 850           if (!dataArray)
 851             {
 852               status = kFALSE;
 853               break;
 854             }
 855           fBranch->SetAddress(&dataArray);
 856           fBranch->GetEntry(iDet);
 857         }
 858     }
 859
 860   return status;
 861
 862 }
 863
 864 //________________________________________________________________________________________________
 865 Bool_t AliTRDdigitsManager::LoadArrayDict(TObjArray * const object
 866                                         , const Char_t *branchname
 867                                         , TTree * const tree)
 868 {
 869   //
 870   // Loads all detectors of the array from the branch <branchname> of
 871   // the dictionary tree <tree>
 872   // Adapted from code of the class AliTRDsegmentArray
 873   //
 874
 875   fTreeD = tree;
 876
 877   if (!fTreeD)
 878     {
 879       AliError("Digits tree is not defined\n");
 880       return kFALSE;
 881     }
 882
 883   // Get the branch
 884   fBranch = fTreeD->GetBranch(branchname);
 885   if (!fBranch)
 886     {
 887       AliError(Form("Branch %s is not defined\n",branchname));
 888       return kFALSE;
 889     }
 890
 891   // Loop through all detectors and read them from the tree
 892   Bool_t status = kTRUE;
 893   for (Int_t iDet = 0; iDet < fDets; iDet++)
 894     {
 895       AliTRDarrayDictionary *dataArray = (AliTRDarrayDictionary *) object->At(iDet);
 896       if (!dataArray)
 897         {
 898           status = kFALSE;
 899           break;
 900         }
 901       fBranch->SetAddress(&dataArray);
 902       fBranch->GetEntry(iDet);
 903     }
 904
 905   return status;
 906
 907 }
 908
 909 //_____________________________________________________________________________
 910 Bool_t AliTRDdigitsManager::StoreArray(TObjArray * const array1
 911                                      , const Char_t *branchname
 912                                      , TTree * const tree)
 913 {
 914   //
 915   // Stores all the detectors of the array in the branch <branchname> of
 916   // the digits tree <tree>
 917   // Adapted from code of the class AliTRDsegmentArray
 918   //
 919
 920   fTree = tree;
 921
 922   if (!fTree)
 923     {
 924       AliError("Digits tree is not defined\n");
 925       return kFALSE;
 926     }
 927
 928   // Get the branch
 929   fBranch = fTree->GetBranch(branchname);
 930   if (!fBranch)
 931     {
 932       AliError(Form("Branch %s is not defined\n",branchname));
 933       return kFALSE;
 934     }
 935
 936   // Loop through all detectors and fill them into the tree
 937   Bool_t status = kTRUE;
 938   for (Int_t iDet = 0; iDet < fDets; iDet++)
 939     {
 940       if (fHasSDigits)
 941         {
 942           const AliTRDarraySignal *kDataArray = (AliTRDarraySignal *) array1->At(iDet);
 943           if (!kDataArray)
 944             {
 945               status = kFALSE;
 946               break;
 947             }
 948           fBranch->SetAddress(&kDataArray);
 949           fBranch->Fill();
 950         }
 951       else
 952         {
 953           const AliTRDarrayADC *kDataArray = (AliTRDarrayADC *) array1->At(iDet);
 954           if (!kDataArray)
 955             {
 956               status = kFALSE;
 957               break;
 958             }
 959           fBranch->SetAddress(&kDataArray);
 960           fBranch->Fill();
 961         }
 962     }
 963
 964   return status;
 965
 966 }
 967
 968 //_____________________________________________________________________________
 969 Bool_t AliTRDdigitsManager::StoreArrayDict(TObjArray * const array3
 970                                          , const Char_t *branchname
 971                                          , TTree * const tree)
 972 {
 973   //
 974   // Stores all the dictionary arrays of the detectors of the array in the branch <branchname> of
 975   // the dictionary tree <tree>
 976   // Adapted from code of the class AliTRDsegmentArray
 977   //
 978
 979   //  AliDebug(1,"Storing Arrays of Dictionary");
 980   fTree = tree;
 981
 982   if (!fTree)
 983     {
 984       AliError("Digits tree is not defined\n");
 985       return kFALSE;
 986     }
 987
 988   // Get the branch
 989   fBranch = fTree->GetBranch(branchname);
 990   if (!fBranch)
 991     {
 992       AliError(Form("Branch %s is not defined\n",branchname));
 993       return kFALSE;
 994     }
 995
 996   // Loop through all detectors and fill them into the tree
 997   Bool_t status = kTRUE;
 998   for (Int_t iDet = 0; iDet < fDets; iDet++)
 999     {
1000       const AliTRDarrayDictionary *kDataArray = (AliTRDarrayDictionary *) array3->At(iDet);
1001       if (!kDataArray)
1002         {
1003           status = kFALSE;
1004           break;
1005         }
1006       fBranch->SetAddress(&kDataArray);
1007       fBranch->Fill();
1008     }
1009
1010   return status;
1011
1012 }