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   Int_t recoDet = fRawRec ? 0 : det;
 283
 284   RemoveDigits(recoDet);
 285   RemoveDictionaries(recoDet);
 286   RemoveIndexes(recoDet);
 287
 288   if (fHasSDigits)
 289     fDigits->AddAt(new AliTRDarraySignal(),recoDet);
 290   else
 291     fDigits->AddAt(new AliTRDarrayADC(),recoDet);
 292
 293   if (fUseDictionaries)
 294     {
 295       for (Int_t iDict = 0; iDict < kNDict; iDict++)
 296         fDict[iDict]->AddAt(new AliTRDarrayDictionary(),recoDet);
 297     }
 298
 299   fSignalIndexes->AddAt(new AliTRDSignalIndex(),recoDet);
 300 }
 301
 302 //_____________________________________________________________________________
 303 Short_t AliTRDdigitsManager::GetDigitAmp(Int_t row, Int_t col,Int_t time, Int_t det) const
 304 {
 305   //
 306   // Returns the amplitude of a digit
 307   //
 308
 309   if (!GetDigits(det)) return 0;
 310
 311   return ((Short_t) ((AliTRDarrayADC *) GetDigits(det))->GetDataBits(row,col,time));
 312
 313 }
 314
 315 //_____________________________________________________________________________
 316 UChar_t AliTRDdigitsManager::GetPadStatus(Int_t row, Int_t col, Int_t time, Int_t det) const
 317 {
 318   //
 319   // Returns the pad status for the requested pad
 320   //
 321
 322   if (!GetDigits(det)) return 0;
 323
 324   return ((UChar_t) ((AliTRDarrayADC *) GetDigits(det))->GetPadStatus(row,col,time));
 325
 326 }
 327
 328 //_____________________________________________________________________________
 329 Bool_t AliTRDdigitsManager::MakeBranch(TTree * const tree)
 330 {
 331   //
 332   // Creates the tree and branches for the digits and the dictionary
 333   //
 334
 335   Int_t  buffersize = 64000;
 336   Bool_t status     = kTRUE;
 337
 338   if (tree)
 339     {
 340       fTree = tree;
 341     }
 342
 343   // Make the branch for the digits
 344   if (fDigits)
 345     {
 346       if(fHasSDigits)
 347         {
 348           const AliTRDarraySignal *kDigits = (AliTRDarraySignal *) fDigits->At(0);
 349           if (kDigits)
 350             {
 351               if (!fTree) return kFALSE;
 352               AliDebug(1,"Making branch for SDigits!\n");
 353               TBranch* branch = fTree->GetBranch("TRDdigits");
 354               if (!branch) fTree->Branch("TRDdigits","AliTRDarraySignal",&kDigits,buffersize,99);
 355               AliDebug(1,"Making branch TRDdigits\n");
 356             }
 357           else
 358             {
 359               status = kFALSE;
 360             }
 361         }
 362
 363       if(!fHasSDigits)
 364         {
 365           const AliTRDarrayADC *kDigits = (AliTRDarrayADC *) fDigits->At(0);
 366           if (kDigits)
 367             {
 368               if (!fTree) return kFALSE;
 369               AliDebug(1,"Making branch for Digits!\n");
 370               TBranch* branch = fTree->GetBranch("TRDdigits");
 371               if (!branch) fTree->Branch("TRDdigits","AliTRDarrayADC",&kDigits,buffersize,99);
 372               AliDebug(1,"Making branch TRDdigits\n");
 373             }
 374           else
 375             {
 376               status = kFALSE;
 377             }
 378         }
 379
 380     }
 381   else
 382     {
 383       status = kFALSE;
 384     }
 385
 386   if (fUseDictionaries)
 387     {
 388       // Make the branches for the dictionaries
 389       for (Int_t iDict = 0; iDict < kNDict; iDict++)
 390         {
 391           Char_t branchname[15];
 392           sprintf(branchname,"TRDdictionary%d",iDict);
 393           if (fDict[iDict])
 394             {
 395               const AliTRDarrayDictionary *kDictionary = (AliTRDarrayDictionary *) fDict[iDict]->At(0);
 396               if (kDictionary)
 397                 {
 398                   if (!fTree) return kFALSE;
 399                   AliDebug(2,"Making branch for dictionary!\n");
 400                   TBranch* branch = fTree->GetBranch(branchname);
 401                   if (!branch) fTree->Branch(branchname,"AliTRDarrayDictionary",&kDictionary,buffersize,99);
 402                   AliDebug(1,Form("Making branch %s\n",branchname));
 403                 }
 404               else
 405                 {
 406                   status = kFALSE;
 407                 }
 408             }
 409           else
 410             {
 411               status = kFALSE;
 412             }
 413         }
 414     }
 415
 416   return status;
 417
 418 }
 419
 420 //_____________________________________________________________________________
 421 Bool_t AliTRDdigitsManager::ReadDigits(TTree * const tree)
 422 {
 423   //
 424   // Reads the digit information from the input file
 425   //
 426
 427   Bool_t status = kTRUE;
 428
 429   if (tree)
 430     {
 431       fTree = tree;
 432     }
 433
 434   if (!fDigits)
 435     {
 436       AliDebug(1,"Create the data arrays.\n");
 437       CreateArrays();
 438     }
 439
 440   status = LoadArray(fDigits,"TRDdigits",fTree);
 441
 442   if (fUseDictionaries)
 443     {
 444       for (Int_t iDict = 0; iDict < kNDict; iDict++)
 445         {
 446           Char_t branchname[15];
 447           sprintf(branchname,"TRDdictionary%d",iDict);
 448           status = LoadArrayDict(fDict[iDict],branchname,fTree);
 449           if (status == kFALSE)
 450             {
 451               fUseDictionaries = kFALSE;
 452               AliWarning("Unable to load dict arrays. Will not use them.\n");
 453               break;
 454             }
 455         }
 456     }
 457
 458   return kTRUE;
 459
 460 }
 461
 462 //_____________________________________________________________________________
 463 Bool_t AliTRDdigitsManager::WriteDigits()
 464 {
 465   //
 466   // Writes out the TRD-digits and the dictionaries
 467   //
 468
 469   // Store the contents of the detector array in the tree
 470
 471   if (!StoreArray(fDigits,"TRDdigits",fTree))
 472     {
 473       AliError("Error while storing digits in branch TRDdigits\n");
 474       return kFALSE;
 475     }
 476
 477   if (fUseDictionaries)
 478     {
 479       for (Int_t iDict = 0; iDict < kNDict; iDict++)
 480         {
 481           Char_t branchname[15];
 482           sprintf(branchname,"TRDdictionary%d",iDict);
 483           if (!StoreArrayDict(fDict[iDict],branchname,fTree))
 484             {
 485               AliError(Form("Error while storing dictionary in branch %s\n",branchname));
 486               return kFALSE;
 487             }
 488         }
 489     }
 490
 491   // Write the new tree to the output file
 492   fTree->AutoSave();
 493
 494   return kTRUE;
 495
 496 }
 497
 498 //_____________________________________________________________________________
 499 AliTRDdigit *AliTRDdigitsManager::GetDigit(Int_t row
 500                                          , Int_t col
 501                                          , Int_t time
 502                                          , Int_t det) const
 503 {
 504   //
 505   // Creates a single digit object
 506   //
 507
 508   Int_t digits[4];
 509   Int_t amp[1];
 510
 511   digits[0] = det;
 512   digits[1] = row;
 513   digits[2] = col;
 514   digits[3] = time;
 515
 516   amp[0]    = ((AliTRDarrayADC *) GetDigits(det))->GetData(row,col,time);
 517
 518   return (new AliTRDdigit(digits,amp));
 519
 520 }
 521
 522 //_____________________________________________________________________________
 523 Int_t AliTRDdigitsManager::GetTrack(Int_t track
 524                                   , Int_t row
 525                                   , Int_t col
 526                                   , Int_t time
 527                                   , Int_t det) const
 528 {
 529   //
 530   // Returns the MC-track numbers from the dictionary.
 531   //
 532
 533   if ((track < 0) || (track >= kNDict))
 534     {
 535       AliError(Form("track %d out of bounds (size: %d, this: 0x%08x)",track,kNDict,this));
 536       return -1;
 537     }
 538
 539   if (fUseDictionaries == kFALSE)
 540     {
 541       return -1;
 542     }
 543
 544   // Array contains index+1 to allow data compression--->Changed
 545   return (((AliTRDarrayDictionary *) GetDictionary(det,track))->GetData(row,col,time) );
 546
 547 }
 548
 549 //________________________________________________________________________________
 550 AliTRDarrayADC *AliTRDdigitsManager::GetDigits(Int_t det) const
 551 {
 552   //
 553   // Returns the digits array for one detector
 554   //
 555
 556   Int_t RecoDet = fRawRec ? 0 : det;
 557
 558   if (!fDigits)
 559     {
 560       return 0x0;
 561     }
 562
 563   if (!fHasSDigits)
 564     {
 565       ((AliTRDarrayADC *) fDigits->At(RecoDet))->SetNdet(det);
 566       return (AliTRDarrayADC *) fDigits->At(RecoDet);
 567     }
 568   else
 569     {
 570       AliDebug(2,"ERROR IN DATA TYPE!!!!");
 571       return 0x0;
 572     }
 573
 574 }
 575
 576 //_____________________________________________________________________________
 577 AliTRDarraySignal *AliTRDdigitsManager::GetSDigits(Int_t det) const
 578 {
 579   //
 580   // Returns the sdigits array for one detector
 581   //
 582
 583   Int_t RecoDet = fRawRec ? 0 : det;
 584
 585   if (!fDigits)
 586     {
 587       //      AliDebug(1,"NO FDIGITS!");
 588       return 0x0;
 589     }
 590
 591   if (fHasSDigits)
 592     {
 593       ((AliTRDarraySignal *) fDigits->At(RecoDet))->SetNdet(det);
 594       return (AliTRDarraySignal *) fDigits->At(RecoDet);
 595     }
 596   else
 597     {
 598       AliDebug(2,"ERROR IN DATA TYPE!!!!");
 599       return 0x0;
 600     }
 601
 602 }
 603
 604 //_____________________________________________________________________________
 605 AliTRDarrayDictionary *AliTRDdigitsManager::GetDictionary(Int_t det
 606                                                         , Int_t i) const
 607 {
 608   //
 609   // Returns the dictionary for one detector
 610   //
 611
 612   Int_t RecoDet = fRawRec ? 0 : det;
 613
 614   if (fUseDictionaries == kFALSE)
 615     {
 616       return 0x0;
 617     }
 618
 619   ((AliTRDarrayDictionary *) fDigits->At(RecoDet))->SetNdet(det);
 620   return (AliTRDarrayDictionary *) fDict[i]->At(RecoDet);
 621
 622 }
 623
 624 //_____________________________________________________________________________
 625 Int_t AliTRDdigitsManager::GetTrack(Int_t track, AliTRDdigit * const digit) const
 626 {
 627   //
 628   // Returns the MC-track numbers from the dictionary for a given digit
 629   //
 630
 631   Int_t row  = digit->GetRow();
 632   Int_t col  = digit->GetCol();
 633   Int_t time = digit->GetTime();
 634   Int_t det  = digit->GetDetector();
 635
 636   return GetTrack(track,row,col,time,det);
 637
 638 }
 639
 640 //_____________________________________________________________________________
 641 AliTRDSignalIndex *AliTRDdigitsManager::GetIndexes(Int_t det)
 642 {
 643   //
 644   // Returns indexes of active pads
 645   //
 646
 647   Int_t RecoDet = fRawRec ? 0 : det;
 648
 649   return (AliTRDSignalIndex *) fSignalIndexes->At(RecoDet);
 650
 651 }
 652
 653 //_____________________________________________________________________________
 654 void AliTRDdigitsManager::RemoveDigits(Int_t det)
 655 {
 656    //
 657    // Clear memory at det for Digits
 658    //
 659
 660   Int_t RecoDet = fRawRec ? 0 : det;
 661
 662   if (fDigits->At(RecoDet))
 663     {
 664       if (fHasSDigits)
 665         {
 666           AliTRDarraySignal *arr = (AliTRDarraySignal *) fDigits->RemoveAt(RecoDet);
 667           delete arr;
 668         }
 669       else
 670         {
 671           AliTRDarrayADC    *arr = (AliTRDarrayADC *)    fDigits->RemoveAt(RecoDet);
 672           delete arr;
 673         }
 674     }
 675
 676 }
 677
 678 //_____________________________________________________________________________
 679 void AliTRDdigitsManager::RemoveDictionaries(Int_t det)
 680 {
 681   //
 682   // Clear memory
 683   //
 684
 685   Int_t RecoDet = fRawRec ? 0 : det;
 686
 687   if (fUseDictionaries == kFALSE)
 688     {
 689       return;
 690     }
 691
 692   for (Int_t i = 0; i < kNDict; i++)
 693     {
 694       if (fDict[i]->At(RecoDet))
 695         {
 696           AliTRDarrayDictionary *arr = (AliTRDarrayDictionary *) fDict[i]->RemoveAt(RecoDet);
 697           delete arr;
 698         }
 699     }
 700
 701 }
 702
 703 //_____________________________________________________________________________
 704 void AliTRDdigitsManager::RemoveIndexes(Int_t det)
 705 {
 706    //
 707    // Clear memory
 708    //
 709
 710   Int_t RecoDet = fRawRec ? 0 : det;
 711
 712   if (fSignalIndexes->At(RecoDet))
 713     {
 714       AliTRDSignalIndex *arr = (AliTRDSignalIndex *) fSignalIndexes->RemoveAt(RecoDet);
 715       delete arr;
 716     }
 717
 718 }
 719
 720
 721 //_____________________________________________________________________________
 722 void AliTRDdigitsManager::ClearIndexes(Int_t det)
 723 {
 724   //
 725   // Clear memory
 726   //
 727
 728   Int_t RecoDet = fRawRec ? 0 : det;
 729
 730   ((AliTRDSignalIndex *) fSignalIndexes->At(RecoDet))->ClearAll();
 731
 732 }
 733
 734 //_____________________________________________________________________________
 735 Bool_t AliTRDdigitsManager::BuildIndexes(Int_t det)
 736 {
 737   //
 738   // Build the list of indices
 739   //
 740
 741   Int_t nRows  = 0;
 742   Int_t nCols  = 0;
 743   Int_t nTbins = 0;
 744
 745   AliTRDgeometry  geom;
 746   AliTRDarrayADC *digits = 0x0;
 747
 748   if (fHasSDigits)
 749     {
 750       return kFALSE;
 751     }
 752   else
 753     {
 754       digits = (AliTRDarrayADC *) GetDigits(det);
 755     }
 756
 757   //digits should be expanded by now!!!
 758   if (digits->GetNtime() > 0)
 759     {
 760       digits->Expand();
 761       nRows  = digits->GetNrow();
 762       nCols  = digits->GetNcol();
 763       nTbins = digits->GetNtime();
 764
 765       AliTRDSignalIndex *indexes = GetIndexes(det);
 766       indexes->SetSM(geom.GetSector(det));
 767       indexes->SetStack(geom.GetStack(det));
 768       indexes->SetLayer(geom.GetLayer(det));
 769       indexes->SetDetNumber(det);
 770
 771       if (indexes->IsAllocated() == kFALSE)
 772         {
 773           indexes->Allocate(nRows,nCols,nTbins);
 774         }
 775
 776       for (Int_t ir = 0; ir < nRows; ir++)
 777         {
 778           for (Int_t ic = 0; ic < nCols; ic++)
 779             {
 780               for (Int_t it = 0; it < nTbins; it++)
 781                 {
 782                   Int_t isig = digits->GetDataBits(ir,ic,it);
 783                   if (isig > 0)
 784                     {
 785                       indexes->AddIndexRC(ir,ic);
 786                     }
 787                 } // tbins
 788             } // cols
 789         } // rows
 790
 791     } // if GetNtime
 792   else
 793     {
 794       return kFALSE;
 795     }
 796
 797   return kTRUE;
 798
 799 }
 800
 801 //_____________________________________________________________________________
 802 Bool_t AliTRDdigitsManager::LoadArray(TObjArray * const object
 803                                     , const Char_t *branchname
 804                                     , TTree * const tree)
 805 {
 806   //
 807   // Loads all detectors of the array from the branch <branchname> of
 808   // the digits tree <tree>
 809   // Adapted from code of the class AliTRDsegmentArray
 810   //
 811
 812   fTreeD = tree;
 813
 814   if (!fTreeD)
 815     {
 816       AliError("Digits tree is not defined\n");
 817       return kFALSE;
 818     }
 819
 820   // Get the branch
 821   fBranch = fTreeD->GetBranch(branchname);
 822   if (!fBranch)
 823     {
 824       AliError(Form("Branch %s is not defined\n",branchname));
 825       return kFALSE;
 826     }
 827
 828   // Loop through all detectors and read them from the tree
 829   Bool_t status = kTRUE;
 830   for (Int_t iDet = 0; iDet < fDets; iDet++)
 831     {
 832       if(fHasSDigits)
 833         {
 834           AliTRDarraySignal *dataArray = (AliTRDarraySignal *) object->At(iDet);
 835           if (!dataArray)
 836             {
 837               status = kFALSE;
 838               break;
 839             }
 840
 841           fBranch->SetAddress(&dataArray);
 842           fBranch->GetEntry(iDet);
 843         }
 844       else
 845         {
 846           AliTRDarrayADC *dataArray = (AliTRDarrayADC *) object->At(iDet);
 847           if (!dataArray)
 848             {
 849               status = kFALSE;
 850               break;
 851             }
 852           fBranch->SetAddress(&dataArray);
 853           fBranch->GetEntry(iDet);
 854         }
 855     }
 856
 857   return status;
 858
 859 }
 860
 861 //________________________________________________________________________________________________
 862 Bool_t AliTRDdigitsManager::LoadArrayDict(TObjArray * const object
 863                                         , const Char_t *branchname
 864                                         , TTree * const tree)
 865 {
 866   //
 867   // Loads all detectors of the array from the branch <branchname> of
 868   // the dictionary tree <tree>
 869   // Adapted from code of the class AliTRDsegmentArray
 870   //
 871
 872   fTreeD = tree;
 873
 874   if (!fTreeD)
 875     {
 876       AliError("Digits tree is not defined\n");
 877       return kFALSE;
 878     }
 879
 880   // Get the branch
 881   fBranch = fTreeD->GetBranch(branchname);
 882   if (!fBranch)
 883     {
 884       AliError(Form("Branch %s is not defined\n",branchname));
 885       return kFALSE;
 886     }
 887
 888   // Loop through all detectors and read them from the tree
 889   Bool_t status = kTRUE;
 890   for (Int_t iDet = 0; iDet < fDets; iDet++)
 891     {
 892       AliTRDarrayDictionary *dataArray = (AliTRDarrayDictionary *) object->At(iDet);
 893       if (!dataArray)
 894         {
 895           status = kFALSE;
 896           break;
 897         }
 898       fBranch->SetAddress(&dataArray);
 899       fBranch->GetEntry(iDet);
 900     }
 901
 902   return status;
 903
 904 }
 905
 906 //_____________________________________________________________________________
 907 Bool_t AliTRDdigitsManager::StoreArray(TObjArray * const array1
 908                                      , const Char_t *branchname
 909                                      , TTree * const tree)
 910 {
 911   //
 912   // Stores all the detectors of the array in the branch <branchname> of
 913   // the digits tree <tree>
 914   // Adapted from code of the class AliTRDsegmentArray
 915   //
 916
 917   fTree = tree;
 918
 919   if (!fTree)
 920     {
 921       AliError("Digits tree is not defined\n");
 922       return kFALSE;
 923     }
 924
 925   // Get the branch
 926   fBranch = fTree->GetBranch(branchname);
 927   if (!fBranch)
 928     {
 929       AliError(Form("Branch %s is not defined\n",branchname));
 930       return kFALSE;
 931     }
 932
 933   // Loop through all detectors and fill them into the tree
 934   Bool_t status = kTRUE;
 935   for (Int_t iDet = 0; iDet < fDets; iDet++)
 936     {
 937       if (fHasSDigits)
 938         {
 939           const AliTRDarraySignal *kDataArray = (AliTRDarraySignal *) array1->At(iDet);
 940           if (!kDataArray)
 941             {
 942               status = kFALSE;
 943               break;
 944             }
 945           fBranch->SetAddress(&kDataArray);
 946           fBranch->Fill();
 947         }
 948       else
 949         {
 950           const AliTRDarrayADC *kDataArray = (AliTRDarrayADC *) array1->At(iDet);
 951           if (!kDataArray)
 952             {
 953               status = kFALSE;
 954               break;
 955             }
 956           fBranch->SetAddress(&kDataArray);
 957           fBranch->Fill();
 958         }
 959     }
 960
 961   return status;
 962
 963 }
 964
 965 //_____________________________________________________________________________
 966 Bool_t AliTRDdigitsManager::StoreArrayDict(TObjArray * const array3
 967                                          , const Char_t *branchname
 968                                          , TTree * const tree)
 969 {
 970   //
 971   // Stores all the dictionary arrays of the detectors of the array in the branch <branchname> of
 972   // the dictionary tree <tree>
 973   // Adapted from code of the class AliTRDsegmentArray
 974   //
 975
 976   //  AliDebug(1,"Storing Arrays of Dictionary");
 977   fTree = tree;
 978
 979   if (!fTree)
 980     {
 981       AliError("Digits tree is not defined\n");
 982       return kFALSE;
 983     }
 984
 985   // Get the branch
 986   fBranch = fTree->GetBranch(branchname);
 987   if (!fBranch)
 988     {
 989       AliError(Form("Branch %s is not defined\n",branchname));
 990       return kFALSE;
 991     }
 992
 993   // Loop through all detectors and fill them into the tree
 994   Bool_t status = kTRUE;
 995   for (Int_t iDet = 0; iDet < fDets; iDet++)
 996     {
 997       const AliTRDarrayDictionary *kDataArray = (AliTRDarrayDictionary *) array3->At(iDet);
 998       if (!kDataArray)
 999         {
1000           status = kFALSE;
1001           break;
1002         }
1003       fBranch->SetAddress(&kDataArray);
1004       fBranch->Fill();
1005     }
1006
1007   return status;
1008
1009 }