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