updates to comply with AliTOFGeometryV5 becoming AliTOFGeometry and Calibration objects
[u/mrichter/AliRoot.git] / TOF / AliTOFDigitMap.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 /*
17 $Log$
18 Revision 1.12  2007/02/20 15:57:00  decaro
19 Raw data update: to read the TOF raw data defined in UNPACKED mode
20
21 */
22
23 ////////////////////////////////////////////////////////////////////////
24 //
25 // AliTOFDigitMap class
26 //
27 // digitmap enables fast check if the pad was already digit.
28
29 // The index of a AliTOFdigit is saved in the each digitmap "cell"
30 // (there is an offset +1, because the index can be zero and zero
31 // means empty cell).
32 // In TOF, number of strips varies according plate type, the highest
33 // number is in plate C. For all plates is used this number, so the
34 // size of the digitmap is a little bit greater than necessary, but it
35 // simplifies the access algorithm.
36 // 
37 //
38 // Author: F. Pierella based on AliTOFHitMap
39 //
40 // Modified by A. De Caro
41 //
42 ///////////////////////////////////////////////////////////////////////
43
44 #include "AliLog.h"
45
46 #include "AliTOFDigitMap.h"
47 #include "AliTOFGeometry.h"
48
49 ClassImp(AliTOFDigitMap)
50
51 AliTOFDigitMap::AliTOFDigitMap():
52   fNSector(-1),
53   fNplate(-1),
54   fNstrip(-1),
55   fNpx(-1),
56   fNpz(-1),
57   fMaxIndex(-1),
58   fDigitMap(0x0)
59 {
60 //
61 // Default ctor
62 //
63
64   fNSector = AliTOFGeometry::NSectors();
65   fNplate = AliTOFGeometry::NPlates();
66   fNstrip = AliTOFGeometry::NStripC();
67   fNpx  = AliTOFGeometry::NpadX();
68   fNpz  = AliTOFGeometry::NpadZ();
69   fMaxIndex=fNSector*fNplate*fNstrip*fNpx*fNpz;
70
71   fDigitMap = new Int_t*[fMaxIndex];
72   for (Int_t i=0; i<fMaxIndex; i++) fDigitMap[i] = new Int_t[kMaxDigitsPerPad];
73   Clear();
74 }
75
76 ////////////////////////////////////////////////////////////////////////
77 AliTOFDigitMap::AliTOFDigitMap(const AliTOFDigitMap & /*digitMap*/):
78   TObject(),
79   fNSector(-1),
80   fNplate(-1),
81   fNstrip(-1),
82   fNpx(-1),
83   fNpz(-1),
84   fMaxIndex(-1),
85   fDigitMap(0x0)
86 {
87 //
88 // Dummy copy constructor
89 //
90   ;
91
92 }
93
94  
95 ////////////////////////////////////////////////////////////////////////
96 AliTOFDigitMap::~AliTOFDigitMap()
97 {
98 //
99 // Destructor
100 //
101   if (fDigitMap) {
102     for (Int_t i=0; i<fMaxIndex; i++)  delete[] fDigitMap[i];
103   }
104
105
106 }
107
108 ////////////////////////////////////////////////////////////////////////
109 void AliTOFDigitMap::Clear(const Option_t*)
110 {
111   //
112   // Clear digitmap
113   //
114
115   for(Int_t ii=0; ii<fMaxIndex; ii++) {
116     for (Int_t jj=0; jj<kMaxDigitsPerPad; jj++) {
117       fDigitMap[ii][jj] = 0;
118     }
119   }
120  
121 }
122
123 ////////////////////////////////////////////////////////////////////////
124 Int_t AliTOFDigitMap::CheckedIndex(Int_t *vol) const
125 {
126   //
127   // Return checked index for vol
128   //
129
130   Int_t index =
131     vol[0]*fNplate*fNstrip*fNpx*fNpz+             // sector
132     vol[1]*fNstrip*fNpx*fNpz+                     // plate
133     vol[2]*fNpx*fNpz+                             // strip
134     vol[3]*fNpz+                                  // padx
135     vol[4];                                       // padz
136
137     if (index >= fMaxIndex || index < 0) {
138       AliError("CheckedIndex - input outside bounds");
139       return -1;
140     } else {
141       return index;
142     }
143 }
144
145 ////////////////////////////////////////////////////////////////////////
146 void AliTOFDigitMap::AddDigit(Int_t *vol, Int_t idigit)
147 {
148   //
149   // Assign digit to pad vol
150   //
151   // 0 means empty pad, we need to shift indeces by 1
152
153   for (Int_t slot=0; slot<kMaxDigitsPerPad; slot++) {
154
155     if (fDigitMap[CheckedIndex(vol)][slot]==0) {
156       fDigitMap[CheckedIndex(vol)][slot]=idigit+1;
157       break;
158     }
159     //else continue;
160
161   }
162 }
163
164 ////////////////////////////////////////////////////////////////////////
165 void AliTOFDigitMap::GetDigitIndex(Int_t *vol, Int_t *digitLabels) const
166 {
167   //
168   // Get all contents (digitLabels) of pad volume (vol)
169   //
170
171   // 0 means empty pad, we need to shift indeces by 1
172
173   Int_t dummy;
174     for (Int_t j=0; j<kMaxDigitsPerPad; j++) {
175       dummy = GetDigitIndex(vol,j);
176       if (dummy>=0) digitLabels[j] = dummy;
177       else break;
178     }
179 }
180
181 ////////////////////////////////////////////////////////////////////////
182 Int_t AliTOFDigitMap::GetDigitIndex(Int_t *vol, Int_t label) const
183 {
184   //
185   // Get one of the contents (label) of pad volume (vol)
186   //
187
188   // 0 means empty pad, we need to shift indeces by 1
189
190   if (!(label<kMaxDigitsPerPad)) {
191     AliWarning(Form("label (=%i) >= kMaxDigitsPerPad (=%i)", label, kMaxDigitsPerPad));
192     return -1;
193   }
194
195   if (CheckedIndex(vol)==-1) return -1;
196   
197   Int_t dummy = fDigitMap[CheckedIndex(vol)][label];
198   
199   if (dummy>0) return dummy-1;
200   else return -1;
201
202 }
203
204 ////////////////////////////////////////////////////////////////////////
205 FlagType AliTOFDigitMap::TestDigit(Int_t *vol) const
206 {
207 //
208 // Check if hit cell is empty, used or unused
209 //
210   Int_t inf=fDigitMap[CheckedIndex(vol)][0]; // to be modified
211     if (inf > 0) {
212         return kUsed;
213     } else if (inf == 0) {
214         return kEmpty;
215     } else {
216         return kUnused;
217     }
218 }
219
220 ////////////////////////////////////////////////////////////////////////
221 AliTOFDigitMap & AliTOFDigitMap::operator = (const AliTOFDigitMap & /*rhs*/) 
222 {
223 // Dummy assignment operator
224     return *this;
225 }
226 ////////////////////////////////////////////////////////////////////////
227 Int_t AliTOFDigitMap::GetFilledCellNumber() const
228 {
229   //
230   // Returns the number of filled cells of the TOF digit map
231   //
232
233   Int_t volume[5] = {-1, -1, -1, -1, -1};
234   Int_t counter = 0;
235
236   for (Int_t iSector=0; iSector<fNSector; iSector++)
237     for (Int_t iPlate=0; iPlate<fNplate; iPlate++)
238       for (Int_t iStrip=0; iStrip<fNstrip; iStrip++)
239         for (Int_t iPadX=0; iPadX<fNpx; iPadX++)
240           for (Int_t iPadZ=0; iPadZ<fNpz; iPadZ++)
241             {
242
243               volume[0] = iSector;
244               volume[1] = iPlate;
245               volume[2] = iStrip;
246               volume[3] = iPadX;
247               volume[4] = iPadZ;
248
249               //if (CheckedIndex(volume)!=-1) counter++;
250               if (GetDigitIndex(volume, 0)>0) counter++;
251             }
252
253   return counter;
254
255 }