Next update of the pad status encoding
[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 //  AliTRDdataArray objects.                                                 //
22 //                                                                           //
23 ///////////////////////////////////////////////////////////////////////////////
24
25 #include <Riostream.h>
26  
27 #include <TROOT.h>
28 #include <TTree.h>                                                              
29 #include <TFile.h>
30
31 #include "AliRun.h"
32 #include "AliLog.h"
33
34 #include "AliTRDdigitsManager.h"
35 #include "AliTRDsegmentArray.h"
36 #include "AliTRDdataArray.h"
37 #include "AliTRDdataArrayI.h"
38 #include "AliTRDdataArrayS.h"
39 #include "AliTRDdataArrayDigits.h"
40 #include "AliTRDdigit.h"
41 #include "AliTRDgeometry.h"
42
43 #include "AliTRDSignalIndex.h"
44
45 ClassImp(AliTRDdigitsManager)
46
47 //_____________________________________________________________________________
48
49   // Number of track dictionary arrays
50   const Int_t AliTRDdigitsManager::fgkNDict = kNDict;
51
52 //_____________________________________________________________________________
53 AliTRDdigitsManager::AliTRDdigitsManager()
54   :TObject()
55   ,fEvent(0)
56   ,fTree(0)
57   ,fDigits(0)
58   ,fHasSDigits(0)
59   ,fSignalIndexes(NULL)
60   ,fUseDictionaries(kTRUE)
61 {
62   //
63   // Default constructor
64   //
65
66   for (Int_t iDict = 0; iDict < kNDict; iDict++) {
67     fDictionary[iDict] = NULL;
68   }
69   
70   fSignalIndexes = new TObjArray(AliTRDgeometry::Ndet());
71   
72 }
73
74 //_____________________________________________________________________________
75 AliTRDdigitsManager::AliTRDdigitsManager(const AliTRDdigitsManager &m)
76   :TObject(m)
77   ,fEvent(m.fEvent)
78   ,fTree(0)
79   ,fDigits(0)
80   ,fHasSDigits(m.fHasSDigits)
81   ,fSignalIndexes(NULL)
82   ,fUseDictionaries(kTRUE)
83 {
84   //
85   // AliTRDdigitsManager copy constructor
86   //
87
88 }
89
90 //_____________________________________________________________________________
91 AliTRDdigitsManager::~AliTRDdigitsManager()
92 {
93   //
94   // AliTRDdigitsManager destructor
95   //
96
97   if (fDigits) {
98     fDigits->Delete();
99     delete fDigits;
100     fDigits            = NULL;
101   }
102
103   for (Int_t iDict = 0; iDict < kNDict; iDict++) {
104     fDictionary[iDict]->Delete();
105     delete fDictionary[iDict];
106     fDictionary[iDict] = NULL;
107   }
108
109   if (fSignalIndexes) {
110     fSignalIndexes->Delete();
111     delete fSignalIndexes;
112     fSignalIndexes     = NULL;
113   }
114
115 }
116
117 //_____________________________________________________________________________
118 AliTRDdigitsManager &AliTRDdigitsManager::operator=(const AliTRDdigitsManager &m)
119 {
120   //
121   // Assignment operator
122   //
123
124   if (this != &m) {
125     ((AliTRDdigitsManager &) m).Copy(*this);
126   }
127
128   return *this;
129
130 }
131
132 //_____________________________________________________________________________
133 void AliTRDdigitsManager::Copy(TObject &m) const
134 {
135   //
136   // Copy function
137   //
138
139   ((AliTRDdigitsManager &) m).fEvent           = fEvent;
140   ((AliTRDdigitsManager &) m).fHasSDigits      = fHasSDigits;
141   
142   ((AliTRDdigitsManager &) m).fSignalIndexes   = fSignalIndexes;
143   ((AliTRDdigitsManager &) m).fUseDictionaries = fUseDictionaries;
144
145   TObject::Copy(m);
146
147 }
148
149 //_____________________________________________________________________________
150 void AliTRDdigitsManager::CreateArrays()
151 {
152   //
153   // Create the data arrays
154   //
155
156   if (fHasSDigits) {
157     fDigits = new AliTRDsegmentArray("AliTRDdataArrayF",AliTRDgeometry::Ndet());
158   }
159   else {
160     fDigits = new AliTRDsegmentArray("AliTRDdataArrayDigits",AliTRDgeometry::Ndet());
161   }
162
163   if (fUseDictionaries) {
164     for (Int_t iDict = 0; iDict < kNDict; iDict++) {
165       fDictionary[iDict] = new AliTRDsegmentArray("AliTRDdataArrayI"
166                                                  ,AliTRDgeometry::Ndet());
167     }
168   }
169
170   for (Int_t i = 0; i < AliTRDgeometry::Ndet(); i++) {
171     fSignalIndexes->AddLast(new AliTRDSignalIndex());
172   }
173
174 }
175
176 //_____________________________________________________________________________
177 void AliTRDdigitsManager::ResetArrays()
178 {
179   //
180   // Reset the data arrays
181   //
182
183   if (fDigits) {
184     fDigits->Delete();
185     delete fDigits;
186   }
187   if (fHasSDigits) {
188     fDigits = new AliTRDsegmentArray("AliTRDdataArrayF",AliTRDgeometry::Ndet());
189   }
190   else {
191     fDigits = new AliTRDsegmentArray("AliTRDdataArrayS",AliTRDgeometry::Ndet());
192   }
193
194   if (fUseDictionaries) {
195     for (Int_t iDict = 0; iDict < kNDict; iDict++) {
196       if (fDictionary[iDict]) { 
197         fDictionary[iDict]->Delete();
198         delete fDictionary[iDict];
199       }
200       fDictionary[iDict] = new AliTRDsegmentArray("AliTRDdataArrayI"
201                                                  ,AliTRDgeometry::Ndet());
202     }
203   }
204
205   for (Int_t i = 0; i < AliTRDgeometry::Ndet(); i++) {
206     AliTRDSignalIndex *idx = (AliTRDSignalIndex *)fSignalIndexes->At(i);
207     if (idx) idx->Reset();
208   }
209
210 }
211
212 //_____________________________________________________________________________
213 Short_t AliTRDdigitsManager::GetDigitAmp(Int_t row, Int_t col,Int_t time
214                                        , Int_t det) const
215 {
216   //
217   // Returns the amplitude of a digit
218   //
219
220   if (!GetDigits(det)) {
221     return 0;
222   }
223
224   return ((Short_t) ((AliTRDdataArrayDigits *) GetDigits(det))->GetData(row,col,time));
225
226 }
227  
228 //_____________________________________________________________________________
229 Bool_t AliTRDdigitsManager::MakeBranch(TTree *tree)
230 {
231   //
232   // Creates the tree and branches for the digits and the dictionary
233   //
234
235   Int_t buffersize = 64000;
236
237   Bool_t status = kTRUE;
238
239   if (tree) {
240     fTree = tree;
241   }
242
243   // Make the branch for the digits
244   if (fDigits) {
245     const AliTRDdataArray *kDigits = (AliTRDdataArray *) fDigits->At(0);
246     if (kDigits) {
247       if (!fTree) return kFALSE;
248       TBranch* branch = fTree->GetBranch("TRDdigits");
249       if (!branch) fTree->Branch("TRDdigits",kDigits->IsA()->GetName()
250                                 ,&kDigits,buffersize,99);
251       AliDebug(1,"Making branch TRDdigits\n");
252     }
253     else {
254       status = kFALSE;
255     }
256   }
257   else {
258     status = kFALSE;
259   }
260
261   if (fUseDictionaries) {
262     // Make the branches for the dictionaries
263     for (Int_t iDict = 0; iDict < kNDict; iDict++) {
264       Char_t branchname[15];
265       sprintf(branchname,"TRDdictionary%d",iDict);
266       if (fDictionary[iDict]) {
267         const AliTRDdataArray *kDictionary = 
268                                (AliTRDdataArray *) fDictionary[iDict]->At(0);
269         if (kDictionary) {
270           if (!fTree) return kFALSE;
271           TBranch* branch = fTree->GetBranch(branchname);
272           if (!branch) fTree->Branch(branchname,kDictionary->IsA()->GetName()
273                                     ,&kDictionary,buffersize,99);
274           AliDebug(1,Form("Making branch %s\n",branchname));
275         }
276         else {
277           status = kFALSE;
278         }
279       }
280       else {
281         status = kFALSE;
282       }
283     }
284   }
285
286   return status;
287
288 }
289
290 //_____________________________________________________________________________
291 Bool_t AliTRDdigitsManager::ReadDigits(TTree *tree)
292 {
293   //
294   // Reads the digit information from the input file
295   //
296
297   Bool_t status = kTRUE;
298
299   if (tree) {
300     fTree = tree;
301   }
302
303   if (!fDigits) {
304     AliDebug(1,"Create the data arrays.\n");
305     CreateArrays();
306   }
307
308   status = fDigits->LoadArray("TRDdigits",fTree);
309
310   if (fUseDictionaries) {
311     for (Int_t iDict = 0; iDict < kNDict; iDict++) {
312       Char_t branchname[15];
313       sprintf(branchname,"TRDdictionary%d",iDict);
314       status = fDictionary[iDict]->LoadArray(branchname,fTree);
315       if (status == kFALSE) {
316         fUseDictionaries = kFALSE;
317         AliWarning("Unable to load dict arrays. Will not use them.\n");
318         break;
319       }
320     }  
321   }
322
323   return kTRUE;
324
325 }
326
327 //_____________________________________________________________________________
328 Bool_t AliTRDdigitsManager::WriteDigits()
329 {
330   //
331   // Writes out the TRD-digits and the dictionaries
332   //
333
334   // Store the contents of the segment array in the tree
335   if (!fDigits->StoreArray("TRDdigits",fTree)) {
336     AliError("Error while storing digits in branch TRDdigits\n");
337     return kFALSE;
338   }
339
340   if (fUseDictionaries) {
341     for (Int_t iDict = 0; iDict < kNDict; iDict++) {
342       Char_t branchname[15];
343       sprintf(branchname,"TRDdictionary%d",iDict);
344       if (!fDictionary[iDict]->StoreArray(branchname,fTree)) {
345         AliError(Form("Error while storing dictionary in branch %s\n",branchname));
346         return kFALSE;
347       }
348     }
349   }
350
351   // Write the new tree to the output file
352   fTree->AutoSave();  // Modification by Jiri
353
354   return kTRUE;
355
356 }
357
358 //_____________________________________________________________________________
359 AliTRDdigit *AliTRDdigitsManager::GetDigit(Int_t row, Int_t col
360                                          , Int_t time, Int_t det) const
361 {
362   // 
363   // Creates a single digit object 
364   //
365
366   Int_t digits[4];
367   Int_t amp[1];
368
369   digits[0] = det;
370   digits[1] = row;
371   digits[2] = col;
372   digits[3] = time;
373
374   amp[0]    = ((AliTRDdataArrayDigits *) GetDigits(det))->GetData(row,col,time);
375   
376   return (new AliTRDdigit(digits,amp));
377
378 }
379
380 //_____________________________________________________________________________
381 Int_t AliTRDdigitsManager::GetTrack(Int_t track
382                                   , Int_t row, Int_t col, Int_t time
383                                   , Int_t det) const
384 {
385   // 
386   // Returns the MC-track numbers from the dictionary.
387   //
388
389   if ((track < 0) || (track >= kNDict)) {
390     AliError(Form("track %d out of bounds (size: %d, this: 0x%08x)"
391                  ,track,kNDict,this));
392     return -1;
393   }
394
395   if (fUseDictionaries == kFALSE) {
396     return -1;
397   }
398
399   // Array contains index+1 to allow data compression
400   return (((AliTRDdataArrayI *) GetDictionary(det,track))->GetData(row,col,time) - 1);
401
402 }
403
404 //_____________________________________________________________________________
405 AliTRDdataArrayDigits *AliTRDdigitsManager::GetDigits(Int_t det) const
406 {
407   //
408   // Returns the digits array for one detector
409   //
410
411   if (!fDigits) {
412     return 0x0;
413   }
414
415   return (AliTRDdataArrayDigits *) fDigits->At(det);
416
417 }
418
419 //_____________________________________________________________________________
420 AliTRDdataArray *AliTRDdigitsManager::GetDictionary(Int_t det, Int_t i) const
421 {
422   //
423   // Returns the dictionary for one detector
424   //
425
426   if (fUseDictionaries == kFALSE) {
427     return 0x0;
428   }
429
430   return (AliTRDdataArray *) fDictionary[i]->At(det);
431
432 }
433
434 //_____________________________________________________________________________
435 Int_t AliTRDdigitsManager::GetTrack(Int_t track, AliTRDdigit *Digit) const
436 {
437   // 
438   // Returns the MC-track numbers from the dictionary for a given digit
439   //
440
441   Int_t row  = Digit->GetRow();
442   Int_t col  = Digit->GetCol();
443   Int_t time = Digit->GetTime();
444   Int_t det  = Digit->GetDetector();
445
446   return GetTrack(track,row,col,time,det);
447
448 }
449
450 //_____________________________________________________________________________
451 AliTRDSignalIndex *AliTRDdigitsManager::GetIndexes(Int_t det) 
452 {
453   // 
454   // Returns indexes of active pads
455   //
456
457   return (AliTRDSignalIndex *) fSignalIndexes->At(det);
458
459 }
460
461 //_____________________________________________________________________________
462 void AliTRDdigitsManager::RemoveDigits(Int_t det) 
463 {
464   // 
465   // Clear memory
466   //
467
468   fDigits->ClearSegment(det);
469
470 }
471
472 //_____________________________________________________________________________
473 void AliTRDdigitsManager::RemoveDictionaries(Int_t det) 
474 {
475   // 
476   // Clear memory
477   //
478
479   if (fUseDictionaries == kFALSE) {
480     return;
481   }
482
483   for (Int_t i = 0; i < kNDict; i++) {
484     fDictionary[i]->ClearSegment(det);
485   }
486
487 }
488
489 //_____________________________________________________________________________
490 void AliTRDdigitsManager::ClearIndexes(Int_t det) 
491 {
492   // 
493   // Clear memory
494   //
495
496   fSignalIndexes->At(det)->Clear();  
497
498 }
499
500 //_____________________________________________________________________________
501 Bool_t AliTRDdigitsManager::BuildIndexes(Int_t det)
502 {
503   //
504   // Build the list of indices
505   //
506
507   Int_t nRows = 0;
508   Int_t nCols = 0;
509   Int_t nTbins = 0;
510
511   AliTRDgeometry    geom;
512   AliTRDdataArrayDigits *digits = 0x0;
513
514   if (fHasSDigits) {
515     return kFALSE;
516   }
517   else {
518     digits = (AliTRDdataArrayDigits *) GetDigits(det);
519   }
520
521   //digits should be expanded by now!!!
522   if (digits->GetNtime() > 0) {
523
524     digits->Expand();
525     nRows  = digits->GetNrow();
526     nCols  = digits->GetNcol();
527     nTbins = digits->GetNtime();
528
529     AliTRDSignalIndex *indexes = GetIndexes(det);
530     indexes->SetSM(geom.GetSector(det));
531     indexes->SetChamber(geom.GetChamber(det));
532     indexes->SetPlane(geom.GetPlane(det));
533     indexes->SetDetNumber(det);
534
535     if (indexes->IsAllocated() == kFALSE) {
536       indexes->Allocate(nRows,nCols,nTbins);
537     }
538
539     for (Int_t ir = 0; ir < nRows; ir++) {
540       for (Int_t ic = 0; ic < nCols; ic++) {
541         for (Int_t it = 0; it < nTbins; it++) {   
542   
543           Int_t isig = digits->GetDataUnchecked(ir,ic,it);
544           if (isig > 0) {
545             indexes->AddIndexTBin(ir,ic,it);        
546           }
547         } // tbins
548       } // cols
549     } // rows
550
551   } // if GetNtime
552   else {
553     return kFALSE;
554   }
555
556   return kTRUE;
557
558 }