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