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 Bool_t AliTRDdigitsManager::MakeBranch(TTree *tree)
 245 {
 246   //
 247   // Creates the tree and branches for the digits and the dictionary
 248   //
 249
 250   Int_t buffersize = 64000;
 251
 252   Bool_t status = kTRUE;
 253
 254   if (tree) {
 255     fTree = tree;
 256   }
 257
 258   // Make the branch for the digits
 259   if (fDigits) {
 260     const AliTRDdataArray *kDigits = (AliTRDdataArray *) fDigits->At(0);
 261     if (kDigits) {
 262       if (!fTree) return kFALSE;
 263       TBranch* branch = fTree->GetBranch("TRDdigits");
 264       if (!branch) fTree->Branch("TRDdigits",kDigits->IsA()->GetName()
 265                                 ,&kDigits,buffersize,99);
 266       AliDebug(1,"Making branch TRDdigits\n");
 267     }
 268     else {
 269       status = kFALSE;
 270     }
 271   }
 272   else {
 273     status = kFALSE;
 274   }
 275
 276   if (fUseDictionaries) {
 277     // Make the branches for the dictionaries
 278     for (Int_t iDict = 0; iDict < kNDict; iDict++) {
 279       Char_t branchname[15];
 280       sprintf(branchname,"TRDdictionary%d",iDict);
 281       if (fDictionary[iDict]) {
 282         const AliTRDdataArray *kDictionary =
 283                                (AliTRDdataArray *) fDictionary[iDict]->At(0);
 284         if (kDictionary) {
 285           if (!fTree) return kFALSE;
 286           TBranch* branch = fTree->GetBranch(branchname);
 287           if (!branch) fTree->Branch(branchname,kDictionary->IsA()->GetName()
 288                                     ,&kDictionary,buffersize,99);
 289           AliDebug(1,Form("Making branch %s\n",branchname));
 290         }
 291         else {
 292           status = kFALSE;
 293         }
 294       }
 295       else {
 296         status = kFALSE;
 297       }
 298     }
 299   }
 300
 301   return status;
 302
 303 }
 304
 305 //_____________________________________________________________________________
 306 Bool_t AliTRDdigitsManager::ReadDigits(TTree *tree)
 307 {
 308   //
 309   // Reads the digit information from the input file
 310   //
 311
 312   Bool_t status = kTRUE;
 313
 314   if (tree) {
 315     fTree = tree;
 316   }
 317
 318   if (!fDigits) {
 319     AliDebug(1,"Create the data arrays.\n");
 320     CreateArrays();
 321   }
 322
 323   status = fDigits->LoadArray("TRDdigits",fTree);
 324
 325   if (fUseDictionaries) {
 326     for (Int_t iDict = 0; iDict < kNDict; iDict++) {
 327       Char_t branchname[15];
 328       sprintf(branchname,"TRDdictionary%d",iDict);
 329       status = fDictionary[iDict]->LoadArray(branchname,fTree);
 330       if (status == kFALSE) {
 331         fUseDictionaries = kFALSE;
 332         AliWarning("Unable to load dict arrays. Will not use them.\n");
 333         break;
 334       }
 335     }
 336   }
 337
 338   return kTRUE;
 339
 340 }
 341
 342 //_____________________________________________________________________________
 343 Bool_t AliTRDdigitsManager::WriteDigits()
 344 {
 345   //
 346   // Writes out the TRD-digits and the dictionaries
 347   //
 348
 349   // Store the contents of the segment array in the tree
 350   if (!fDigits->StoreArray("TRDdigits",fTree)) {
 351     AliError("Error while storing digits in branch TRDdigits\n");
 352     return kFALSE;
 353   }
 354
 355   if (fUseDictionaries) {
 356     for (Int_t iDict = 0; iDict < kNDict; iDict++) {
 357       Char_t branchname[15];
 358       sprintf(branchname,"TRDdictionary%d",iDict);
 359       if (!fDictionary[iDict]->StoreArray(branchname,fTree)) {
 360         AliError(Form("Error while storing dictionary in branch %s\n",branchname));
 361         return kFALSE;
 362       }
 363     }
 364   }
 365
 366   // Write the new tree to the output file
 367   fTree->AutoSave();  // Modification by Jiri
 368
 369   return kTRUE;
 370
 371 }
 372
 373 //_____________________________________________________________________________
 374 AliTRDdigit *AliTRDdigitsManager::GetDigit(Int_t row, Int_t col
 375                                          , Int_t time, Int_t det) const
 376 {
 377   //
 378   // Creates a single digit object
 379   //
 380
 381   Int_t digits[4];
 382   Int_t amp[1];
 383
 384   digits[0] = det;
 385   digits[1] = row;
 386   digits[2] = col;
 387   digits[3] = time;
 388
 389   amp[0]    = ((AliTRDdataArrayDigits *) GetDigits(det))->GetData(row,col,time);
 390
 391   return (new AliTRDdigit(digits,amp));
 392
 393 }
 394
 395 //_____________________________________________________________________________
 396 Int_t AliTRDdigitsManager::GetTrack(Int_t track
 397                                   , Int_t row, Int_t col, Int_t time
 398                                   , Int_t det) const
 399 {
 400   //
 401   // Returns the MC-track numbers from the dictionary.
 402   //
 403
 404   if ((track < 0) || (track >= kNDict)) {
 405     AliError(Form("track %d out of bounds (size: %d, this: 0x%08x)"
 406                  ,track,kNDict,this));
 407     return -1;
 408   }
 409
 410   if (fUseDictionaries == kFALSE) {
 411     return -1;
 412   }
 413
 414   // Array contains index+1 to allow data compression
 415   return (((AliTRDdataArrayI *) GetDictionary(det,track))->GetData(row,col,time) - 1);
 416
 417 }
 418
 419 //_____________________________________________________________________________
 420 AliTRDdataArrayDigits *AliTRDdigitsManager::GetDigits(Int_t det) const
 421 {
 422   //
 423   // Returns the digits array for one detector
 424   //
 425
 426   if (!fDigits) {
 427     return 0x0;
 428   }
 429
 430   return (AliTRDdataArrayDigits *) fDigits->At(det);
 431
 432 }
 433
 434 //_____________________________________________________________________________
 435 AliTRDdataArray *AliTRDdigitsManager::GetDictionary(Int_t det, Int_t i) const
 436 {
 437   //
 438   // Returns the dictionary for one detector
 439   //
 440
 441   if (fUseDictionaries == kFALSE) {
 442     return 0x0;
 443   }
 444
 445   return (AliTRDdataArray *) fDictionary[i]->At(det);
 446
 447 }
 448
 449 //_____________________________________________________________________________
 450 Int_t AliTRDdigitsManager::GetTrack(Int_t track, AliTRDdigit *Digit) const
 451 {
 452   //
 453   // Returns the MC-track numbers from the dictionary for a given digit
 454   //
 455
 456   Int_t row  = Digit->GetRow();
 457   Int_t col  = Digit->GetCol();
 458   Int_t time = Digit->GetTime();
 459   Int_t det  = Digit->GetDetector();
 460
 461   return GetTrack(track,row,col,time,det);
 462
 463 }
 464
 465 //_____________________________________________________________________________
 466 AliTRDSignalIndex *AliTRDdigitsManager::GetIndexes(Int_t det)
 467 {
 468   //
 469   // Returns indexes of active pads
 470   //
 471
 472   return (AliTRDSignalIndex *) fSignalIndexes->At(det);
 473
 474 }
 475
 476 //_____________________________________________________________________________
 477 void AliTRDdigitsManager::RemoveDigits(Int_t det)
 478 {
 479   //
 480   // Clear memory
 481   //
 482
 483   fDigits->ClearSegment(det);
 484
 485 }
 486
 487 //_____________________________________________________________________________
 488 void AliTRDdigitsManager::RemoveDictionaries(Int_t det)
 489 {
 490   //
 491   // Clear memory
 492   //
 493
 494   if (fUseDictionaries == kFALSE) {
 495     return;
 496   }
 497
 498   for (Int_t i = 0; i < kNDict; i++) {
 499     fDictionary[i]->ClearSegment(det);
 500   }
 501
 502 }
 503
 504 //_____________________________________________________________________________
 505 void AliTRDdigitsManager::ClearIndexes(Int_t det)
 506 {
 507   //
 508   // Clear memory
 509   //
 510
 511   fSignalIndexes->At(det)->Clear();
 512
 513 }
 514
 515 //_____________________________________________________________________________
 516 Bool_t AliTRDdigitsManager::BuildIndexes(Int_t det)
 517 {
 518   //
 519   // Build the list of indices
 520   //
 521
 522   Int_t nRows = 0;
 523   Int_t nCols = 0;
 524   Int_t nTbins = 0;
 525
 526   AliTRDgeometry    geom;
 527   AliTRDdataArrayDigits *digits = 0x0;
 528
 529   if (fHasSDigits) {
 530     return kFALSE;
 531   }
 532   else {
 533     digits = (AliTRDdataArrayDigits *) GetDigits(det);
 534   }
 535
 536   //digits should be expanded by now!!!
 537   if (digits->GetNtime() > 0) {
 538
 539     digits->Expand();
 540     nRows  = digits->GetNrow();
 541     nCols  = digits->GetNcol();
 542     nTbins = digits->GetNtime();
 543
 544     AliTRDSignalIndex *indexes = GetIndexes(det);
 545     indexes->SetSM(geom.GetSector(det));
 546     indexes->SetChamber(geom.GetChamber(det));
 547     indexes->SetPlane(geom.GetPlane(det));
 548     indexes->SetDetNumber(det);
 549
 550     if (indexes->IsAllocated() == kFALSE) {
 551       indexes->Allocate(nRows,nCols,nTbins);
 552     }
 553
 554     for (Int_t ir = 0; ir < nRows; ir++) {
 555       for (Int_t ic = 0; ic < nCols; ic++) {
 556         for (Int_t it = 0; it < nTbins; it++) {
 557
 558           Int_t isig = digits->GetDataUnchecked(ir,ic,it);
 559           if (isig > 0) {
 560             indexes->AddIndexTBin(ir,ic,it);
 561           }
 562         } // tbins
 563       } // cols
 564     } // rows
 565
 566   } // if GetNtime
 567   else {
 568     return kFALSE;
 569   }
 570
 571   return kTRUE;
 572
 573 }