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