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