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