Improved quitting Event Display with close button.
[u/mrichter/AliRoot.git] / TRD / AliTRDdigitsManager.cxx
index 2279d74..fc08178 100644 (file)
 ///////////////////////////////////////////////////////////////////////////////
 //                                                                           //
 //  Manages the digits and the track dictionary in the form of               //
-//  AliTRDdataArray objects.                                                 //
+//  TObjArray objects                                                        //
 //                                                                           //
 ///////////////////////////////////////////////////////////////////////////////
 
-#include <Riostream.h>
-#include <TROOT.h>
 #include <TTree.h>                                                              
-#include <TFile.h>
 
-#include "AliRun.h"
+#include "AliLog.h"
 
 #include "AliTRDdigitsManager.h"
-#include "AliTRDsegmentArray.h"
-#include "AliTRDdataArrayI.h"
+#include "AliTRDarrayDictionary.h"
+#include "AliTRDarrayADC.h"
+#include "AliTRDarraySignal.h"
 #include "AliTRDdigit.h"
+#include "AliTRDdigitsParam.h"
+#include "AliTRDSimParam.h"
 #include "AliTRDgeometry.h"
-#include "AliTRD.h"
+#include "AliTRDSignalIndex.h"
 
 ClassImp(AliTRDdigitsManager)
 
@@ -45,33 +44,56 @@ ClassImp(AliTRDdigitsManager)
   const Int_t AliTRDdigitsManager::fgkNDict = kNDict;
 
 //_____________________________________________________________________________
-AliTRDdigitsManager::AliTRDdigitsManager():TObject()
+AliTRDdigitsManager::AliTRDdigitsManager(Bool_t rawRec)
+  :TObject()
+  ,fEvent(0)
+  ,fTree(0)
+  ,fDigits(0) 
+  ,fHasSDigits(0)
+  ,fSignalIndexes(NULL)
+  ,fUseDictionaries(kTRUE)
+  ,fDets(AliTRDgeometry::Ndet())
+  ,fRawRec(rawRec)
+  ,fDigitsParam(0)
 {
   //
   // Default constructor
   //
+  
+  if (fRawRec)
+    {
+      fDets   = 1;
+      fRawRec = kTRUE;
+    }
 
-  fIsRaw   = kFALSE;
-  fEvent   = 0;
-  fDebug   = 0;
-  fSDigits = 0;
-
-  fTree    = NULL;
-  fDigits  = NULL;
-  for (Int_t iDict = 0; iDict < kNDict; iDict++) {
-    fDictionary[iDict] = NULL;
-  }
-
+  for (Int_t iDict = 0; iDict < kNDict; iDict++) 
+    {
+      fDict[iDict] = NULL;
+    }
+  
 }
 
 //_____________________________________________________________________________
 AliTRDdigitsManager::AliTRDdigitsManager(const AliTRDdigitsManager &m)
+  :TObject(m)
+  ,fEvent(m.fEvent)
+  ,fTree(0)
+  ,fDigits(0) 
+  ,fHasSDigits(m.fHasSDigits)
+  ,fSignalIndexes(NULL)
+  ,fUseDictionaries(kTRUE)
+  ,fDets(m.fDets)
+  ,fRawRec(m.fRawRec)
+  ,fDigitsParam(NULL)
 {
   //
   // AliTRDdigitsManager copy constructor
   //
 
-  ((AliTRDdigitsManager &) m).Copy(*this);
+  for (Int_t iDict = 0; iDict < kNDict; iDict++) 
+    {
+      fDict[iDict] = NULL;
+    }
 
 }
 
@@ -82,31 +104,74 @@ AliTRDdigitsManager::~AliTRDdigitsManager()
   // AliTRDdigitsManager destructor
   //
 
-  if (fDigits) {
-    fDigits->Delete();
-    delete fDigits;
-    fDigits = NULL;
-  }
 
-  for (Int_t iDict = 0; iDict < kNDict; iDict++) {
-    fDictionary[iDict]->Delete();
-    delete fDictionary[iDict];
-    fDictionary[iDict] = NULL;
-  }
+  if (fDigits) 
+    {
+      fDigits->Delete();
+      delete fDigits;
+      fDigits = NULL;
+    }
+
+  for (Int_t iDict = 0; iDict < kNDict; iDict++) 
+    {
+      if(fDict[iDict])
+       {
+         fDict[iDict]->Delete();
+         delete fDict[iDict];
+         fDict[iDict] = NULL;
+       }
+    }
+
+  if (fSignalIndexes) 
+    {
+      fSignalIndexes->Delete();
+      delete fSignalIndexes;
+      fSignalIndexes = NULL;
+    }
+
+  if (fDigitsParam)
+    {
+      delete fDigitsParam;
+      fDigitsParam = NULL;
+    }
 
 }
 
 //_____________________________________________________________________________
-void AliTRDdigitsManager::Copy(TObject &m)
+AliTRDdigitsManager &AliTRDdigitsManager::operator=(const AliTRDdigitsManager &m)
+{
+  //
+  // Assignment operator
+  //
+
+  if (this != &m) 
+    {
+      ((AliTRDdigitsManager &) m).Copy(*this);
+    }
+
+  return *this;
+
+}
+
+//_____________________________________________________________________________
+void AliTRDdigitsManager::Copy(TObject &m) const
 {
   //
   // Copy function
   //
 
-  ((AliTRDdigitsManager &) m).fIsRaw   = fIsRaw;
-  ((AliTRDdigitsManager &) m).fEvent   = fEvent;
-  ((AliTRDdigitsManager &) m).fDebug   = fDebug;
-  ((AliTRDdigitsManager &) m).fSDigits = fSDigits;
+  ((AliTRDdigitsManager &) m).fEvent           = fEvent;
+  ((AliTRDdigitsManager &) m).fHasSDigits      = fHasSDigits;
+  ((AliTRDdigitsManager &) m).fDigits          = NULL;
+  for(Int_t i = 0; i < kNDict; i++)
+    {
+      ((AliTRDdigitsManager &) m).fDict[i]  = NULL;
+    }
+  ((AliTRDdigitsManager &) m).fSignalIndexes   = NULL;
+  ((AliTRDdigitsManager &) m).fUseDictionaries = fUseDictionaries;
+  ((AliTRDdigitsManager &) m).fDets            = fDets;
+  ((AliTRDdigitsManager &) m).fRawRec          = fRawRec;
+  ((AliTRDdigitsManager &) m).fDigitsParam     = NULL;
 
   TObject::Copy(m);
 
@@ -119,127 +184,243 @@ void AliTRDdigitsManager::CreateArrays()
   // Create the data arrays
   //
 
-  fDigits = new AliTRDsegmentArray("AliTRDdataArrayI",AliTRDgeometry::Ndet());
+  if (fHasSDigits) 
+    {
+      if (fDigits)                                        
+       {                                                   
+         fDigits->Delete();                                
+         delete fDigits;                                   
+       }                                                    
+      fDigits = new TObjArray(fDets);
+      for (Int_t index = 0; index < fDets; index++) 
+       {
+         fDigits->AddAt(new AliTRDarraySignal(),index);
+       }
+    }
+  else 
+    {
+      if (fDigits)                                          
+       {                                                    
+         fDigits->Delete();                                
+         delete fDigits;                                   
+       }                                                   
+      fDigits = new TObjArray(fDets);    
+      for (Int_t index = 0; index < fDets; index++) 
+       {
+         fDigits->AddAt(new AliTRDarrayADC(),index);
+       }
+    }
+
+  if (fUseDictionaries) 
+    {
+      for (Int_t iDict = 0; iDict < kNDict; iDict++)
+       {
+         if (fDict[iDict])                                   
+           {
+             fDict[iDict]->Delete();                                
+             delete fDict[iDict];                                    
+           }
+         fDict[iDict] = new TObjArray(fDets);
+         for (Int_t index = 0; index < fDets; index++) 
+           {
+             fDict[iDict]->AddAt(new AliTRDarrayDictionary(),index);
+           }
+       }
+    }
+  
+  if (fSignalIndexes)
+    {
+      fSignalIndexes->Delete();
+      delete fSignalIndexes;
+    }
+  fSignalIndexes = new TObjArray(fDets);
+  for (Int_t i = 0; i < fDets; i++)
+    {
+      fSignalIndexes->AddLast(new AliTRDSignalIndex());
+    }
 
-  for (Int_t iDict = 0; iDict < kNDict; iDict++) {
-    fDictionary[iDict] = new AliTRDsegmentArray("AliTRDdataArrayI"
-                                               ,AliTRDgeometry::Ndet());
-  }
+  if (fDigitsParam)
+    {
+      delete fDigitsParam;
+    }
+  fDigitsParam = new AliTRDdigitsParam();
 
 }
+
 //_____________________________________________________________________________
-void AliTRDdigitsManager::ResetArrays()
+void AliTRDdigitsManager::ClearArrays(Int_t det)
 {
   //
   // Reset the data arrays
   //
 
-  if (fDigits) {
-    delete fDigits;
-  }
-  fDigits = new AliTRDsegmentArray("AliTRDdataArrayI",AliTRDgeometry::Ndet());
+  Int_t recoDet = fRawRec ? 0 : det;
 
-  for (Int_t iDict = 0; iDict < kNDict; iDict++) {
-    if (fDictionary[iDict]) {  
-      delete fDictionary[iDict];
+  if (fHasSDigits)
+    {
+      ((AliTRDarraySignal*)fDigits->At(recoDet))->Reset();
+    }
+  else
+    {
+      ((AliTRDarrayADC*)fDigits->At(recoDet))->ConditionalReset((AliTRDSignalIndex*)fSignalIndexes->At(recoDet));
     }
-    fDictionary[iDict] = new AliTRDsegmentArray("AliTRDdataArrayI"
-                                               ,AliTRDgeometry::Ndet());
-  }
+
+  if (fUseDictionaries) 
+    {
+      for (Int_t iDict = 0; iDict < kNDict; iDict++)
+       {
+         ((AliTRDarrayDictionary*)fDict[iDict]->At(recoDet))->Reset();
+       }
+    }
+  
+  ((AliTRDSignalIndex*)fSignalIndexes->At(recoDet))->ResetContent();
 
 }
 
 //_____________________________________________________________________________
-void AliTRDdigitsManager::SetRaw()
+Short_t AliTRDdigitsManager::GetDigitAmp(Int_t row, Int_t col,Int_t time, Int_t det) const
 {
   //
-  // Switch on the raw digits flag
+  // Returns the amplitude of a digit
   //
 
-  fIsRaw = kTRUE;
-
-  fDigits->SetBit(AliTRDdigit::RawDigit());
+  if (!GetDigits(det)) return 0;
   
+  return ((Short_t) ((AliTRDarrayADC *) GetDigits(det))->GetDataBits(row,col,time));
+
 }
 
 //_____________________________________________________________________________
-Short_t AliTRDdigitsManager::GetDigitAmp(Int_t row, Int_t col,Int_t time
-                                       , Int_t det) const
+UChar_t AliTRDdigitsManager::GetPadStatus(Int_t row, Int_t col, Int_t time, Int_t det) const
 {
   //
-  // Returns the amplitude of a digit
+  // Returns the pad status for the requested pad
   //
+       
+  if (!GetDigits(det)) return 0;
 
-  return ((Short_t) GetDigits(det)->GetData(row,col,time));
-
-}
+  return ((UChar_t) ((AliTRDarrayADC *) GetDigits(det))->GetPadStatus(row,col,time));
  
+}
+
 //_____________________________________________________________________________
-Bool_t AliTRDdigitsManager::MakeBranch(TTree *tree)
+Bool_t AliTRDdigitsManager::MakeBranch(TTree * const tree)  
 {
   //
   // Creates the tree and branches for the digits and the dictionary
   //
 
-  Int_t buffersize = 64000;
+  Int_t  buffersize = 64000;
+  Bool_t status     = kTRUE;
 
-  Bool_t status = kTRUE;
+  if (tree) 
+    {
+      fTree = tree;
+    }
+
+  // Make the branch for the digits
+  if (fDigits) 
+    {
+      if (fHasSDigits)
+       {
+         const AliTRDarraySignal *kDigits = (AliTRDarraySignal *) fDigits->At(0); 
+         if (kDigits) 
+           {
+             if (!fTree) return kFALSE;
+             AliDebug(1,"Making branch for SDigits!\n");
+             TBranch *branch = fTree->GetBranch("TRDdigits");
+             if (!branch)
+               {
+                  fTree->Branch("TRDdigits","AliTRDarraySignal",&kDigits,buffersize,99);
+               }
+             AliDebug(1,"Making branch TRDdigits\n");
+           }
+         else 
+           {
+             status = kFALSE;
+           }
+       }
 
-  AliTRD *trd = (AliTRD *) gAlice->GetDetector("TRD") ;
+      if (!fHasSDigits)
+       {
+         const AliTRDarrayADC *kDigits = (AliTRDarrayADC *) fDigits->At(0);
+         if (kDigits) 
+           {
+             if (!fTree) return kFALSE;
+             AliDebug(1,"Making branch for Digits!\n");
+             TBranch *branch = fTree->GetBranch("TRDdigits");
+             if (!branch) 
+               {
+                  fTree->Branch("TRDdigits","AliTRDarrayADC",&kDigits,buffersize,99);
+               }
+             AliDebug(1,"Making branch TRDdigits\n");        
+           }
+         else 
+           {
+             status = kFALSE;
+           }
+       }
 
-  if (tree) {
-    fTree = tree;
-  }
+    }
+  else
+    {
 
-  // Make the branch for the digits
-  if (fDigits) {
-    const AliTRDdataArray *kDigits = (AliTRDdataArray *) fDigits->At(0);
-    if (kDigits) {
-      trd->MakeBranchInTree(fTree,"TRDdigits",kDigits->IsA()->GetName()
-                                 ,&kDigits,buffersize,99);
-      if (fDebug > 0) {
-        printf("<AliTRDdigitsManager::MakeBranch> ");
-        printf("Making branch TRDdigits\n");
-      }
-    }
-    else {
       status = kFALSE;
-    }
-  }
-  else {
-    status = kFALSE;
-  }
 
-  // Make the branches for the dictionaries
-  for (Int_t iDict = 0; iDict < kNDict; iDict++) {
-    Char_t branchname[15];
-    sprintf(branchname,"TRDdictionary%d",iDict);
-    if (fDictionary[iDict]) {
-      const AliTRDdataArray *kDictionary = 
-              (AliTRDdataArray *) fDictionary[iDict]->At(0);
-      if (kDictionary) {
-        trd->MakeBranchInTree(fTree,branchname,kDictionary->IsA()->GetName()
-                             ,&kDictionary,buffersize,99);
-        if (fDebug > 0) {
-          printf("<AliTRDdigitsManager::MakeBranch> ");
-          printf("Making branch %s\n",branchname);
+    }
+  
+  if (fUseDictionaries) 
+    {
+      // Make the branches for the dictionaries
+      for (Int_t iDict = 0; iDict < kNDict; iDict++) 
+       {
+          const Int_t kBranchname = 15;
+         Char_t branchname[kBranchname];
+         snprintf(branchname,kBranchname,"TRDdictionary%d",iDict); 
+         if (fDict[iDict]) 
+           {
+             const AliTRDarrayDictionary *kDictionary = (AliTRDarrayDictionary *) fDict[iDict]->At(0);
+             if (kDictionary) 
+               {
+                 if (!fTree) return kFALSE;
+                 AliDebug(2,"Making branch for dictionary!\n");
+                 TBranch *branch = fTree->GetBranch(branchname);
+                 if (!branch) 
+                   {
+                      fTree->Branch(branchname,"AliTRDarrayDictionary",&kDictionary,buffersize,99);
+                   }
+                 AliDebug(1,Form("Making branch %s\n",branchname));
+               }
+             else 
+               {
+                 status = kFALSE;
+               }
+           }
+         else 
+           {
+             status = kFALSE;
+           }
        }
-      }
-      else {
-        status = kFALSE;
-      }
     }
-    else {
-      status = kFALSE;
+
+  if (fDigitsParam)
+    {
+      const AliTRDdigitsParam *kDigitsParam = fDigitsParam;
+      if (!fTree) return kFALSE;
+      TBranch *branch = fTree->GetBranch("TRDdigitsParam");
+      if (!branch) 
+       {
+          fTree->Branch("TRDdigitsParam","AliTRDdigitsParam",&kDigitsParam,buffersize,99);
+       }
+      AliDebug(1,"Making branch AliTRDdigitsParam\n");
     }
-  }
 
   return status;
 
 }
 
 //_____________________________________________________________________________
-Bool_t AliTRDdigitsManager::ReadDigits(TTree *tree)
+Bool_t AliTRDdigitsManager::ReadDigits(TTree * const tree)
 {
   //
   // Reads the digit information from the input file
@@ -247,36 +428,42 @@ Bool_t AliTRDdigitsManager::ReadDigits(TTree *tree)
 
   Bool_t status = kTRUE;
 
-  if (tree) {
-
-    fTree = tree;
-
-  }
+  if (tree) 
+    {
+      fTree = tree;
+    }
 
-  if (!fDigits) {
-    if (fDebug > 0) {
-      printf("<AliTRDdigitsManager::ReadDigits> ");
-      printf("Create the data arrays.\n");
+  if (!fDigits) 
+    {
+      AliDebug(1,"Create the data arrays.\n");
+      CreateArrays();
     }
-    CreateArrays();
-  }
 
-  status = fDigits->LoadArray("TRDdigits",fTree);
+  status = LoadArrayDigits();
 
-  for (Int_t iDict = 0; iDict < kNDict; iDict++) {
-    Char_t branchname[15];
-    sprintf(branchname,"TRDdictionary%d",iDict);
-    status = fDictionary[iDict]->LoadArray(branchname,fTree);
-  }  
+  if (fUseDictionaries) 
+    {
+      status = LoadArrayDict();
+      if (status == kFALSE) 
+       {
+         fUseDictionaries = kFALSE;
+         AliWarning("Unable to load dict arrays. Will not use them.\n");
+       }
+    }  
 
-  if (fDigits->TestBit(AliTRDdigit::RawDigit())) {
-    fIsRaw = kTRUE;
-  }
-  else {
-    fIsRaw = kFALSE;
+  if (!LoadDigitsParam()) {
+    AliWarning("Could not read digits parameter.");
+    if (fDigitsParam) {
+      delete fDigitsParam;
+    }
+    AliWarning(Form("Create default version of digits parameter (NTimeBin=%d).\n"
+                  ,AliTRDSimParam::Instance()->GetNTimeBins()));
+    fDigitsParam = new AliTRDdigitsParam();
+    fDigitsParam->SetNTimeBinsAll(AliTRDSimParam::Instance()->GetNTimeBins());
+    fDigitsParam->SetADCbaselineAll(AliTRDSimParam::Instance()->GetADCbaseline());
   }
 
-  return kTRUE;
+  return status;
 
 }
 
@@ -284,42 +471,48 @@ Bool_t AliTRDdigitsManager::ReadDigits(TTree *tree)
 Bool_t AliTRDdigitsManager::WriteDigits()
 {
   //
-  // Writes out the TRD-digits and the dictionaries
+  // Writes out the TRD-digits, the dictionaries and the digitsPaam
   //
 
-  // Store the contents of the segment array in the tree
-  if (!fDigits->StoreArray("TRDdigits",fTree)) {
-    printf("<AliTRDdigitsManager::WriteDigits> ");
-    printf("Error while storing digits in branch TRDdigits\n");
-    return kFALSE;
-  }
-  for (Int_t iDict = 0; iDict < kNDict; iDict++) {
-    Char_t branchname[15];
-    sprintf(branchname,"TRDdictionary%d",iDict);
-    if (!fDictionary[iDict]->StoreArray(branchname,fTree)) {
-      printf("<AliTRDdigitsManager::WriteDigits> ");
-      printf("Error while storing dictionary in branch %s\n",branchname);
+  if (!StoreArrayDigits())
+    {
+      AliError("Error while storing digits\n");
       return kFALSE;
     }
-  }
 
+  if (fUseDictionaries) 
+    {
+      if (!StoreArrayDict())
+       {
+         AliError("Error while storing dictionaries in branch\n");
+         return kFALSE;
+       }
+    }
+
+  if (!StoreDigitsParam())
+    {
+      AliError("Error while storing digitsParam\n");
+      return kFALSE;
+    }
+  
   // Write the new tree to the output file
-  //fTree->Write();
-  fTree->AutoSave();  // Modification by Jiri
+  fTree->AutoSave();
 
   return kTRUE;
 
 }
 
 //_____________________________________________________________________________
-AliTRDdigit *AliTRDdigitsManager::GetDigit(Int_t row, Int_t col
-                                         , Int_t time, Int_t det) const
+AliTRDdigit *AliTRDdigitsManager::GetDigit(Int_t row
+                                         , Int_t col
+                                         , Int_t time
+                                         , Int_t det) const
 {
   // 
   // Creates a single digit object 
   //
 
-  Int_t digits[4];
+  Int_t digits[4]; 
   Int_t amp[1];
 
   digits[0] = det;
@@ -327,79 +520,557 @@ AliTRDdigit *AliTRDdigitsManager::GetDigit(Int_t row, Int_t col
   digits[2] = col;
   digits[3] = time;
 
-  amp[0]    = GetDigits(det)->GetData(row,col,time);
+  amp[0]    = ((AliTRDarrayADC *) GetDigits(det))->GetData(row,col,time);
   
-  return (new AliTRDdigit(fIsRaw,digits,amp));
+  return (new AliTRDdigit(digits,amp));
 
 }
 
 //_____________________________________________________________________________
 Int_t AliTRDdigitsManager::GetTrack(Int_t track
-                                  , Int_t row, Int_t col, Int_t time
+                                  , Int_t row
+                                  , Int_t col
+                                  , Int_t time
                                   , Int_t det) const
 {
   // 
   // Returns the MC-track numbers from the dictionary.
   //
 
-  if ((track < 0) || (track >= kNDict)) {
-    TObject::Error("GetTracks"
-                  ,"track %d out of bounds (size: %d, this: 0x%08x)"
-                  ,track,kNDict,this);
-    return -1;
-  }
+  if ((track < 0) || (track >= kNDict)) 
+    {
+      AliError(Form("track %d out of bounds (size: %d, this: 0x%p)",track,kNDict,this));
+      return -1;
+    }
+
+  if (fUseDictionaries == kFALSE) 
+    {
+      return -1;
+    }
 
-  // Array contains index+1 to allow data compression
-  return (GetDictionary(det,track)->GetData(row,col,time) - 1);
+  // Array contains index+1 to allow data compression--->Changed
+  return (((AliTRDarrayDictionary *) GetDictionary(det,track))->GetData(row,col,time) );
 
 }
 
-//_____________________________________________________________________________
-AliTRDdataArrayI *AliTRDdigitsManager::GetDigits(Int_t det) const
+//________________________________________________________________________________
+AliTRDarrayADC *AliTRDdigitsManager::GetDigits(Int_t det) const
 {
   //
   // Returns the digits array for one detector
   //
 
-  return (AliTRDdataArrayI *) fDigits->At(det);
+  Int_t recoDet = fRawRec ? 0 : det;
+
+  if (!fDigits)   
+    {
+      return 0x0;
+    }
+
+  if (!fHasSDigits)
+    {
+      ((AliTRDarrayADC *) fDigits->At(recoDet))->SetNdet(det);
+      return (AliTRDarrayADC *) fDigits->At(recoDet); 
+    }
+  else
+    {
+      AliDebug(2,"ERROR IN DATA TYPE!!!!");
+      return 0x0;
+    }
+
+}
+
+//_____________________________________________________________________________
+AliTRDarraySignal *AliTRDdigitsManager::GetSDigits(Int_t det) const
+{
+  //
+  // Returns the sdigits array for one detector
+  //
+
+  Int_t recoDet = fRawRec ? 0 : det;
+
+  if (!fDigits)   
+    {
+      //      AliDebug(1,"NO FDIGITS!");       
+      return 0x0;
+    }
+
+  if (fHasSDigits)
+    {
+      ((AliTRDarraySignal *) fDigits->At(recoDet))->SetNdet(det);
+      return (AliTRDarraySignal *) fDigits->At(recoDet);
+    }
+  else
+    {
+      AliDebug(2,"ERROR IN DATA TYPE!!!!");
+      return 0x0;
+    }
 
 }
 
 //_____________________________________________________________________________
-AliTRDdataArrayI *AliTRDdigitsManager::GetDictionary(Int_t det, Int_t i) const
+AliTRDarrayDictionary *AliTRDdigitsManager::GetDictionary(Int_t det
+                                                        , Int_t i) const
 {
   //
   // Returns the dictionary for one detector
   //
 
-  return (AliTRDdataArrayI *) fDictionary[i]->At(det);
+  Int_t recoDet = fRawRec ? 0 : det;
 
+  if (fUseDictionaries == kFALSE)
+    {
+      return 0x0;
+    }
+
+  ((AliTRDarrayDictionary *) fDigits->At(recoDet))->SetNdet(det);
+  return (AliTRDarrayDictionary *) fDict[i]->At(recoDet);
+  
 }
 
 //_____________________________________________________________________________
-Int_t AliTRDdigitsManager::GetTrack(Int_t track, AliTRDdigit *Digit) const
+Int_t AliTRDdigitsManager::GetTrack(Int_t track, const AliTRDdigit * const digit) const
 {
   // 
   // Returns the MC-track numbers from the dictionary for a given digit
   //
 
-  Int_t row  = Digit->GetRow();
-  Int_t col  = Digit->GetCol();
-  Int_t time = Digit->GetTime();
-  Int_t det  = Digit->GetDetector();
+  Int_t row  = digit->GetRow();
+  Int_t col  = digit->GetCol();
+  Int_t time = digit->GetTime();
+  Int_t det  = digit->GetDetector();
 
   return GetTrack(track,row,col,time,det);
 
 }
 
 //_____________________________________________________________________________
-AliTRDdigitsManager &AliTRDdigitsManager::operator=(const AliTRDdigitsManager &m)
+AliTRDSignalIndex *AliTRDdigitsManager::GetIndexes(Int_t det) 
 {
+  // 
+  // Returns indexes of active pads
   //
-  // Assignment operator
+
+  Int_t recoDet = fRawRec ? 0 : det;
+
+  return (AliTRDSignalIndex *) fSignalIndexes->At(recoDet);
+
+}
+
+//_____________________________________________________________________________
+void AliTRDdigitsManager::RemoveDigits(Int_t det) 
+{
+   // 
+   // Clear memory at det for Digits
+   //
+
+  Int_t recoDet = fRawRec ? 0 : det;
+
+  if (fDigits->At(recoDet))
+    {
+      if (fHasSDigits) 
+        {
+          AliTRDarraySignal *arr = (AliTRDarraySignal *) fDigits->RemoveAt(recoDet);
+          delete arr;
+       }
+      else 
+        {
+          AliTRDarrayADC    *arr = (AliTRDarrayADC *)    fDigits->RemoveAt(recoDet);
+          delete arr;
+       }
+    }
+
+}
+
+//_____________________________________________________________________________
+void AliTRDdigitsManager::RemoveDictionaries(Int_t det) 
+{
+  // 
+  // Clear memory
   //
 
-  if (this != &m) ((AliTRDdigitsManager &) m).Copy(*this);
-  return *this;
+  Int_t recoDet = fRawRec ? 0 : det;
+
+  if (fUseDictionaries == kFALSE) 
+    {
+      return;
+    }
+
+  for (Int_t i = 0; i < kNDict; i++) 
+    {
+      if (fDict[i]->At(recoDet))
+       {
+         AliTRDarrayDictionary *arr = (AliTRDarrayDictionary *) fDict[i]->RemoveAt(recoDet);
+          delete arr;
+       }
+    }
 
 }
+
+//_____________________________________________________________________________
+void AliTRDdigitsManager::RemoveIndexes(Int_t det) 
+{
+   // 
+   // Clear memory
+   //
+
+  Int_t recoDet = fRawRec ? 0 : det;
+
+  if (fSignalIndexes->At(recoDet))
+    {
+      AliTRDSignalIndex *arr = (AliTRDSignalIndex *) fSignalIndexes->RemoveAt(recoDet);
+      delete arr;
+    }
+
+}
+
+//_____________________________________________________________________________
+void AliTRDdigitsManager::ClearIndexes(Int_t det) 
+{
+  // 
+  // Clear memory
+  //
+  
+  Int_t recoDet = fRawRec ? 0 : det;
+
+  ((AliTRDSignalIndex *) fSignalIndexes->At(recoDet))->ClearAll();  
+
+}
+
+//_____________________________________________________________________________
+Bool_t AliTRDdigitsManager::BuildIndexes(Int_t det)
+{
+  //
+  // Build the list of indices
+  //
+
+  Int_t nRows  = 0;
+  Int_t nCols  = 0;
+  Int_t nTbins = 0;
+
+  AliTRDgeometry  geom;
+  AliTRDarrayADC *digits = 0x0;
+
+  if (fHasSDigits) 
+    {
+      return kFALSE;
+    }
+  else 
+    {
+      digits = (AliTRDarrayADC *) GetDigits(det);
+    }
+
+  // digits should be expanded by now!!!
+  if (digits->GetNtime() > 0) 
+    {      
+      digits->Expand(); 
+      nRows  = digits->GetNrow();
+      nCols  = digits->GetNcol();
+      nTbins = digits->GetNtime();
+      
+      AliTRDSignalIndex *indexes = GetIndexes(det);
+      indexes->SetSM(geom.GetSector(det));
+      indexes->SetStack(geom.GetStack(det));
+      indexes->SetLayer(geom.GetLayer(det));
+      indexes->SetDetNumber(det);
+
+      if (indexes->IsAllocated() == kFALSE)
+       {
+         indexes->Allocate(nRows,nCols,nTbins);
+       }
+
+      for (Int_t ir = 0; ir < nRows; ir++) 
+       {
+         for (Int_t ic = 0; ic < nCols; ic++) 
+           {
+             for (Int_t it = 0; it < nTbins; it++)
+               {         
+                 Int_t isig = digits->GetDataBits(ir,ic,it);
+                 if (isig > 0) 
+                   {
+                     indexes->AddIndexRC(ir,ic);           
+                   }
+               } // tbins
+           } // cols
+       } // rows
+
+    } // if GetNtime
+  else 
+    {
+      return kFALSE;
+    }
+  
+  return kTRUE;
+
+}
+
+//_____________________________________________________________________________
+Bool_t AliTRDdigitsManager::LoadArrayDigits()
+{
+  //
+  // Loads the (s-)digits arrays for all detectors
+  //
+
+  if (!fTree) 
+    {
+      AliError("Digits tree is not defined\n");
+      return kFALSE;
+    }
+
+  Bool_t status = kTRUE;
+
+  // Get the branch
+  TBranch *branch = fTree->GetBranch("TRDdigits");
+  if (!branch) 
+    {
+      AliError("Branch TRDdigits is not defined\n");
+      return kFALSE;
+    }
+
+  // Loop through all detectors and read them from the tree
+  for (Int_t iDet = 0; iDet < fDets; iDet++) 
+    {
+      if (fHasSDigits)
+       {
+         AliTRDarraySignal *dataArray = (AliTRDarraySignal *) fDigits->At(iDet);
+         if (!dataArray) 
+           {
+             status = kFALSE;
+             break;    
+           }
+         branch->SetAddress(&dataArray);
+         branch->GetEntry(iDet);
+       }
+      else
+       {
+         AliTRDarrayADC    *dataArray = (AliTRDarrayADC *)    fDigits->At(iDet);
+         if (!dataArray) 
+           {
+             status = kFALSE;
+             break;
+           }
+         branch->SetAddress(&dataArray);
+         branch->GetEntry(iDet);
+       }
+    }
+
+  return status;
+
+}
+
+//________________________________________________________________________________________________
+Bool_t AliTRDdigitsManager::LoadArrayDict()
+{
+  //
+  // Loads dictionary arrays for all detectors
+  //
+
+  if (!fTree) 
+    {
+      AliError("Digits tree is not defined\n");
+      return kFALSE;
+    }
+
+  Bool_t status = kTRUE;
+
+  for (Int_t iDict = 0; iDict < kNDict; iDict++) 
+    {
+
+      // Get the branch
+      Char_t branchname[15];
+      snprintf(branchname,15,"TRDdictionary%d",iDict);
+      TBranch *branch = fTree->GetBranch(branchname);
+      if (!branch) 
+        {
+          AliError(Form("Branch %s is not defined\n",branchname));
+          return kFALSE;
+        }
+
+      // Loop through all detectors and read them from the tree
+      for (Int_t iDet = 0; iDet < fDets; iDet++) 
+        {
+          AliTRDarrayDictionary *dataArray = (AliTRDarrayDictionary *) fDict[iDict]->At(iDet);
+          if (!dataArray) 
+           {
+             status = kFALSE;
+             break;    
+           }
+          branch->SetAddress(&dataArray);
+          branch->GetEntry(iDet);
+        }
+
+    }
+
+  return status;
+
+}
+
+//_____________________________________________________________________________
+Bool_t AliTRDdigitsManager::LoadDigitsParam()
+{
+  //
+  // Loads the digits parameter object from the digits tree
+  //
+
+  if (!fTree) 
+    {
+      AliError("Digits tree is not defined\n");
+      return kFALSE;
+    }
+
+  // Get the branch
+  TBranch *branch = fTree->GetBranch("TRDdigitsParam");
+  if (!branch) 
+    {
+      AliError("Branch TRDdigitsParam is not defined\n");
+      return kFALSE;
+    }
+
+  // Read the parameter object
+  AliTRDdigitsParam *digitsParam = fDigitsParam;
+  if (!digitsParam)
+    {
+      return kFALSE;
+    }
+
+  branch->SetAddress(&digitsParam);
+  branch->GetEntry();
+
+  return kTRUE;
+
+}
+
+//_____________________________________________________________________________
+Bool_t AliTRDdigitsManager::StoreArrayDigits()
+{
+  //
+  // Stores the digit arrays for all detectors
+  //
+
+  if (!fTree) 
+    {
+      AliError("Digits tree is not defined\n");
+      return kFALSE;
+    }
+
+  // Get the branch
+  TBranch *branch = fTree->GetBranch("TRDdigits");
+  if (!branch) 
+    {
+      AliError("Branch TRDdigits is not defined\n");
+      return kFALSE;
+    }
+
+  // Loop through all detectors and fill them into the tree
+  Bool_t status = kTRUE;
+  for (Int_t iDet = 0; iDet < fDets; iDet++) 
+    {
+      if (fHasSDigits)
+       {
+         const AliTRDarraySignal *kDataArray = (AliTRDarraySignal *) fDigits->At(iDet);
+         if (!kDataArray) 
+           {
+             status = kFALSE;
+             break;
+           }
+         branch->SetAddress(&kDataArray);
+         branch->Fill();
+       }
+      else
+       {
+         const AliTRDarrayADC    *kDataArray = (AliTRDarrayADC *)    fDigits->At(iDet); 
+         if (!kDataArray) 
+           {
+             status = kFALSE;
+             break;
+           }
+         branch->SetAddress(&kDataArray);
+         branch->Fill();
+       }
+    }
+
+  return status;
+
+}
+
+//_____________________________________________________________________________
+Bool_t AliTRDdigitsManager::StoreArrayDict()
+{
+  //
+  // Stores the dictionary arrays for all detectors
+  //
+
+  if (!fTree) 
+    {
+      AliError("Digits tree is not defined\n");
+      return kFALSE;
+    }
+
+  Bool_t status = kTRUE;
+
+  for (Int_t iDict = 0; iDict < kNDict; iDict++)
+     {
+
+       // Get the branch
+       Char_t branchname[15];
+       snprintf(branchname,15,"TRDdictionary%d",iDict);
+       TBranch *branch = fTree->GetBranch(branchname);
+       if (!branch) 
+         {
+           AliError(Form("Branch %s is not defined\n",branchname));
+           return kFALSE;
+         }
+
+       // Loop through all detectors and fill them into the tree
+       for (Int_t iDet = 0; iDet < fDets; iDet++) 
+         {
+           const AliTRDarrayDictionary *kDataArray = (AliTRDarrayDictionary *) fDict[iDict]->At(iDet);
+           if (!kDataArray) 
+            {
+              status = kFALSE;
+              break;
+            }
+           branch->SetAddress(&kDataArray);
+           branch->Fill();
+         }
+
+     }
+
+  return status;
+
+}
+
+//_____________________________________________________________________________
+Bool_t AliTRDdigitsManager::StoreDigitsParam()
+{
+  //
+  // Stores the digits parameter object from the digits tree
+  //
+
+  if (!fTree) 
+    {
+      AliError("Digits tree is not defined\n");
+      return kFALSE;
+    }
+
+  // Get the branch
+  TBranch *branch = fTree->GetBranch("TRDdigitsParam");
+  if (!branch) 
+    {
+      AliError("Branch TRDdigitsParam is not defined\n");
+      return kFALSE;
+    }
+
+  // Fill the digits object in the tree
+  const AliTRDdigitsParam *kDigitsParam = fDigitsParam;
+  if (!kDigitsParam)
+    {
+      return kFALSE;
+    }
+  branch->SetAddress(&kDigitsParam);
+  branch->Fill();
+
+  return kTRUE;
+
+}
+