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 //  AliTRDdataArray objects.                                                 //
  22 //                                                                           //
  23 ///////////////////////////////////////////////////////////////////////////////
  24
  25 #include <Riostream.h>
  26
  27 #include <TROOT.h>
  28 #include <TTree.h>
  29 #include <TFile.h>
  30
  31 #include "AliRun.h"
  32 #include "AliLog.h"
  33
  34 #include "AliTRDdigitsManager.h"
  35 #include "AliTRDsegmentArray.h"
  36 #include "AliTRDdataArray.h"
  37 #include "AliTRDdataArrayI.h"
  38 #include "AliTRDdataArrayS.h"
  39 #include "AliTRDdataArrayDigits.h"
  40 #include "AliTRDdigit.h"
  41 #include "AliTRDgeometry.h"
  42
  43 #include "AliTRDSignalIndex.h"
  44
  45 ClassImp(AliTRDdigitsManager)
  46
  47 //_____________________________________________________________________________
  48
  49   // Number of track dictionary arrays
  50   const Int_t AliTRDdigitsManager::fgkNDict = kNDict;
  51
  52 //_____________________________________________________________________________
  53 AliTRDdigitsManager::AliTRDdigitsManager()
  54   :TObject()
  55   ,fEvent(0)
  56   ,fTree(0)
  57   ,fDigits(0)
  58   ,fHasSDigits(0)
  59   ,fSignalIndexes(NULL)
  60   ,fUseDictionaries(kTRUE)
  61 {
  62   //
  63   // Default constructor
  64   //
  65
  66   for (Int_t iDict = 0; iDict < kNDict; iDict++) {
  67     fDictionary[iDict] = NULL;
  68   }
  69
  70   fSignalIndexes = new TObjArray(AliTRDgeometry::Ndet());
  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 {
  84   //
  85   // AliTRDdigitsManager copy constructor
  86   //
  87
  88 }
  89
  90 //_____________________________________________________________________________
  91 AliTRDdigitsManager::~AliTRDdigitsManager()
  92 {
  93   //
  94   // AliTRDdigitsManager destructor
  95   //
  96
  97   if (fDigits) {
  98     fDigits->Delete();
  99     delete fDigits;
 100     fDigits            = NULL;
 101   }
 102
 103   for (Int_t iDict = 0; iDict < kNDict; iDict++) {
 104     fDictionary[iDict]->Delete();
 105     delete fDictionary[iDict];
 106     fDictionary[iDict] = NULL;
 107   }
 108
 109   if (fSignalIndexes) {
 110     fSignalIndexes->Delete();
 111     delete fSignalIndexes;
 112     fSignalIndexes     = NULL;
 113   }
 114
 115 }
 116
 117 //_____________________________________________________________________________
 118 AliTRDdigitsManager &AliTRDdigitsManager::operator=(const AliTRDdigitsManager &m)
 119 {
 120   //
 121   // Assignment operator
 122   //
 123
 124   if (this != &m) {
 125     ((AliTRDdigitsManager &) m).Copy(*this);
 126   }
 127
 128   return *this;
 129
 130 }
 131
 132 //_____________________________________________________________________________
 133 void AliTRDdigitsManager::Copy(TObject &m) const
 134 {
 135   //
 136   // Copy function
 137   //
 138
 139   ((AliTRDdigitsManager &) m).fEvent           = fEvent;
 140   ((AliTRDdigitsManager &) m).fHasSDigits      = fHasSDigits;
 141
 142   ((AliTRDdigitsManager &) m).fSignalIndexes   = fSignalIndexes;
 143   ((AliTRDdigitsManager &) m).fUseDictionaries = fUseDictionaries;
 144
 145   TObject::Copy(m);
 146
 147 }
 148
 149 //_____________________________________________________________________________
 150 void AliTRDdigitsManager::CreateArrays()
 151 {
 152   //
 153   // Create the data arrays
 154   //
 155
 156   if (fHasSDigits) {
 157     fDigits = new AliTRDsegmentArray("AliTRDdataArrayF",AliTRDgeometry::Ndet());
 158   }
 159   else {
 160     fDigits = new AliTRDsegmentArray("AliTRDdataArrayDigits",AliTRDgeometry::Ndet());
 161   }
 162
 163   if (fUseDictionaries) {
 164     for (Int_t iDict = 0; iDict < kNDict; iDict++) {
 165       fDictionary[iDict] = new AliTRDsegmentArray("AliTRDdataArrayI"
 166                                                  ,AliTRDgeometry::Ndet());
 167     }
 168   }
 169
 170   for (Int_t i = 0; i < AliTRDgeometry::Ndet(); i++) {
 171     fSignalIndexes->AddLast(new AliTRDSignalIndex());
 172   }
 173
 174 }
 175
 176 //_____________________________________________________________________________
 177 void AliTRDdigitsManager::ResetArrays()
 178 {
 179   //
 180   // Reset the data arrays
 181   //
 182
 183   if (fDigits) {
 184     fDigits->Delete();
 185     delete fDigits;
 186   }
 187   if (fHasSDigits) {
 188     fDigits = new AliTRDsegmentArray("AliTRDdataArrayF",AliTRDgeometry::Ndet());
 189   }
 190   else {
 191     fDigits = new AliTRDsegmentArray("AliTRDdataArrayS",AliTRDgeometry::Ndet());
 192   }
 193
 194   if (fUseDictionaries) {
 195     for (Int_t iDict = 0; iDict < kNDict; iDict++) {
 196       if (fDictionary[iDict]) {
 197         fDictionary[iDict]->Delete();
 198         delete fDictionary[iDict];
 199       }
 200       fDictionary[iDict] = new AliTRDsegmentArray("AliTRDdataArrayI"
 201                                                  ,AliTRDgeometry::Ndet());
 202     }
 203   }
 204
 205   for (Int_t i = 0; i < AliTRDgeometry::Ndet(); i++) {
 206     AliTRDSignalIndex *idx = (AliTRDSignalIndex *)fSignalIndexes->At(i);
 207     if (idx) idx->Reset();
 208   }
 209
 210 }
 211
 212 //_____________________________________________________________________________
 213 Short_t AliTRDdigitsManager::GetDigitAmp(Int_t row, Int_t col,Int_t time
 214                                        , Int_t det) const
 215 {
 216   //
 217   // Returns the amplitude of a digit
 218   //
 219
 220   if (!GetDigits(det)) {
 221     return 0;
 222   }
 223
 224   return ((Short_t) ((AliTRDdataArrayDigits *) GetDigits(det))->GetData(row,col,time));
 225
 226 }
 227
 228 //_____________________________________________________________________________
 229 UChar_t AliTRDdigitsManager::GetPadStatus(Int_t row, Int_t col, Int_t time
 230                                              , Int_t det) const
 231 {
 232   //
 233   // Returns the pad status for the requested pad
 234   //
 235
 236   if (!GetDigits(det)) {
 237     return 0;
 238   }
 239
 240   return ((UChar_t) ((AliTRDdataArrayDigits *) GetDigits(det))->GetPadStatus(row,col,time));
 241
 242 }
 243
 244 //_____________________________________________________________________________
 245 Bool_t AliTRDdigitsManager::MakeBranch(TTree *tree)
 246 {
 247   //
 248   // Creates the tree and branches for the digits and the dictionary
 249   //
 250
 251   Int_t buffersize = 64000;
 252
 253   Bool_t status = kTRUE;
 254
 255   if (tree) {
 256     fTree = tree;
 257   }
 258
 259   // Make the branch for the digits
 260   if (fDigits) {
 261     const AliTRDdataArray *kDigits = (AliTRDdataArray *) fDigits->At(0);
 262     if (kDigits) {
 263       if (!fTree) return kFALSE;
 264       TBranch* branch = fTree->GetBranch("TRDdigits");
 265       if (!branch) fTree->Branch("TRDdigits",kDigits->IsA()->GetName()
 266                                 ,&kDigits,buffersize,99);
 267       AliDebug(1,"Making branch TRDdigits\n");
 268     }
 269     else {
 270       status = kFALSE;
 271     }
 272   }
 273   else {
 274     status = kFALSE;
 275   }
 276
 277   if (fUseDictionaries) {
 278     // Make the branches for the dictionaries
 279     for (Int_t iDict = 0; iDict < kNDict; iDict++) {
 280       Char_t branchname[15];
 281       sprintf(branchname,"TRDdictionary%d",iDict);
 282       if (fDictionary[iDict]) {
 283         const AliTRDdataArray *kDictionary =
 284                                (AliTRDdataArray *) fDictionary[iDict]->At(0);
 285         if (kDictionary) {
 286           if (!fTree) return kFALSE;
 287           TBranch* branch = fTree->GetBranch(branchname);
 288           if (!branch) fTree->Branch(branchname,kDictionary->IsA()->GetName()
 289                                     ,&kDictionary,buffersize,99);
 290           AliDebug(1,Form("Making branch %s\n",branchname));
 291         }
 292         else {
 293           status = kFALSE;
 294         }
 295       }
 296       else {
 297         status = kFALSE;
 298       }
 299     }
 300   }
 301
 302   return status;
 303
 304 }
 305
 306 //_____________________________________________________________________________
 307 Bool_t AliTRDdigitsManager::ReadDigits(TTree *tree)
 308 {
 309   //
 310   // Reads the digit information from the input file
 311   //
 312
 313   Bool_t status = kTRUE;
 314
 315   if (tree) {
 316     fTree = tree;
 317   }
 318
 319   if (!fDigits) {
 320     AliDebug(1,"Create the data arrays.\n");
 321     CreateArrays();
 322   }
 323
 324   status = fDigits->LoadArray("TRDdigits",fTree);
 325
 326   if (fUseDictionaries) {
 327     for (Int_t iDict = 0; iDict < kNDict; iDict++) {
 328       Char_t branchname[15];
 329       sprintf(branchname,"TRDdictionary%d",iDict);
 330       status = fDictionary[iDict]->LoadArray(branchname,fTree);
 331       if (status == kFALSE) {
 332         fUseDictionaries = kFALSE;
 333         AliWarning("Unable to load dict arrays. Will not use them.\n");
 334         break;
 335       }
 336     }
 337   }
 338
 339   return kTRUE;
 340
 341 }
 342
 343 //_____________________________________________________________________________
 344 Bool_t AliTRDdigitsManager::WriteDigits()
 345 {
 346   //
 347   // Writes out the TRD-digits and the dictionaries
 348   //
 349
 350   // Store the contents of the segment array in the tree
 351   if (!fDigits->StoreArray("TRDdigits",fTree)) {
 352     AliError("Error while storing digits in branch TRDdigits\n");
 353     return kFALSE;
 354   }
 355
 356   if (fUseDictionaries) {
 357     for (Int_t iDict = 0; iDict < kNDict; iDict++) {
 358       Char_t branchname[15];
 359       sprintf(branchname,"TRDdictionary%d",iDict);
 360       if (!fDictionary[iDict]->StoreArray(branchname,fTree)) {
 361         AliError(Form("Error while storing dictionary in branch %s\n",branchname));
 362         return kFALSE;
 363       }
 364     }
 365   }
 366
 367   // Write the new tree to the output file
 368   fTree->AutoSave();  // Modification by Jiri
 369
 370   return kTRUE;
 371
 372 }
 373
 374 //_____________________________________________________________________________
 375 AliTRDdigit *AliTRDdigitsManager::GetDigit(Int_t row, Int_t col
 376                                          , Int_t time, Int_t det) const
 377 {
 378   //
 379   // Creates a single digit object
 380   //
 381
 382   Int_t digits[4];
 383   Int_t amp[1];
 384
 385   digits[0] = det;
 386   digits[1] = row;
 387   digits[2] = col;
 388   digits[3] = time;
 389
 390   amp[0]    = ((AliTRDdataArrayDigits *) GetDigits(det))->GetData(row,col,time);
 391
 392   return (new AliTRDdigit(digits,amp));
 393
 394 }
 395
 396 //_____________________________________________________________________________
 397 Int_t AliTRDdigitsManager::GetTrack(Int_t track
 398                                   , Int_t row, Int_t col, Int_t time
 399                                   , Int_t det) const
 400 {
 401   //
 402   // Returns the MC-track numbers from the dictionary.
 403   //
 404
 405   if ((track < 0) || (track >= kNDict)) {
 406     AliError(Form("track %d out of bounds (size: %d, this: 0x%08x)"
 407                  ,track,kNDict,this));
 408     return -1;
 409   }
 410
 411   if (fUseDictionaries == kFALSE) {
 412     return -1;
 413   }
 414
 415   // Array contains index+1 to allow data compression
 416   return (((AliTRDdataArrayI *) GetDictionary(det,track))->GetData(row,col,time) - 1);
 417
 418 }
 419
 420 //_____________________________________________________________________________
 421 AliTRDdataArrayDigits *AliTRDdigitsManager::GetDigits(Int_t det) const
 422 {
 423   //
 424   // Returns the digits array for one detector
 425   //
 426
 427   if (!fDigits) {
 428     return 0x0;
 429   }
 430
 431   return (AliTRDdataArrayDigits *) fDigits->At(det);
 432
 433 }
 434
 435 //_____________________________________________________________________________
 436 AliTRDdataArray *AliTRDdigitsManager::GetDictionary(Int_t det, Int_t i) const
 437 {
 438   //
 439   // Returns the dictionary for one detector
 440   //
 441
 442   if (fUseDictionaries == kFALSE) {
 443     return 0x0;
 444   }
 445
 446   return (AliTRDdataArray *) fDictionary[i]->At(det);
 447
 448 }
 449
 450 //_____________________________________________________________________________
 451 Int_t AliTRDdigitsManager::GetTrack(Int_t track, AliTRDdigit *Digit) const
 452 {
 453   //
 454   // Returns the MC-track numbers from the dictionary for a given digit
 455   //
 456
 457   Int_t row  = Digit->GetRow();
 458   Int_t col  = Digit->GetCol();
 459   Int_t time = Digit->GetTime();
 460   Int_t det  = Digit->GetDetector();
 461
 462   return GetTrack(track,row,col,time,det);
 463
 464 }
 465
 466 //_____________________________________________________________________________
 467 AliTRDSignalIndex *AliTRDdigitsManager::GetIndexes(Int_t det)
 468 {
 469   //
 470   // Returns indexes of active pads
 471   //
 472
 473   return (AliTRDSignalIndex *) fSignalIndexes->At(det);
 474
 475 }
 476
 477 //_____________________________________________________________________________
 478 void AliTRDdigitsManager::RemoveDigits(Int_t det)
 479 {
 480   //
 481   // Clear memory
 482   //
 483
 484   fDigits->ClearSegment(det);
 485
 486 }
 487
 488 //_____________________________________________________________________________
 489 void AliTRDdigitsManager::RemoveDictionaries(Int_t det)
 490 {
 491   //
 492   // Clear memory
 493   //
 494
 495   if (fUseDictionaries == kFALSE) {
 496     return;
 497   }
 498
 499   for (Int_t i = 0; i < kNDict; i++) {
 500     fDictionary[i]->ClearSegment(det);
 501   }
 502
 503 }
 504
 505 //_____________________________________________________________________________
 506 void AliTRDdigitsManager::ClearIndexes(Int_t det)
 507 {
 508   //
 509   // Clear memory
 510   //
 511
 512   ((AliTRDSignalIndex *) fSignalIndexes->At(det))->ClearAll();
 513
 514 }
 515
 516 //_____________________________________________________________________________
 517 Bool_t AliTRDdigitsManager::BuildIndexes(Int_t det)
 518 {
 519   //
 520   // Build the list of indices
 521   //
 522
 523   Int_t nRows = 0;
 524   Int_t nCols = 0;
 525   Int_t nTbins = 0;
 526
 527   AliTRDgeometry    geom;
 528   AliTRDdataArrayDigits *digits = 0x0;
 529
 530   if (fHasSDigits) {
 531     return kFALSE;
 532   }
 533   else {
 534     digits = (AliTRDdataArrayDigits *) GetDigits(det);
 535   }
 536
 537   //digits should be expanded by now!!!
 538   if (digits->GetNtime() > 0) {
 539
 540     digits->Expand();
 541     nRows  = digits->GetNrow();
 542     nCols  = digits->GetNcol();
 543     nTbins = digits->GetNtime();
 544
 545     AliTRDSignalIndex *indexes = GetIndexes(det);
 546     indexes->SetSM(geom.GetSector(det));
 547     indexes->SetStack(geom.GetStack(det));
 548     indexes->SetLayer(geom.GetLayer(det));
 549     indexes->SetDetNumber(det);
 550
 551     if (indexes->IsAllocated() == kFALSE) {
 552       indexes->Allocate(nRows,nCols,nTbins);
 553     }
 554
 555     for (Int_t ir = 0; ir < nRows; ir++) {
 556       for (Int_t ic = 0; ic < nCols; ic++) {
 557         for (Int_t it = 0; it < nTbins; it++) {
 558
 559           Int_t isig = digits->GetDataUnchecked(ir,ic,it);
 560           if (isig > 0) {
 561             indexes->AddIndexTBin(ir,ic,it);
 562           }
 563         } // tbins
 564       } // cols
 565     } // rows
 566
 567   } // if GetNtime
 568   else {
 569     return kFALSE;
 570   }
 571
 572   return kTRUE;
 573
 574 }