gcc 4.3 warnings fixed
[u/mrichter/AliRoot.git] / TRD / AliTRDCalibraMode.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 // AliTRDCalibraMode                                                             
21 //                                                                             
22 // This class is for the modes of the TRD calibration.        
23 // The user has to choose with the functions SetNz and SetNrphi
24 // the precision of the calibration. 
25 // Author:
26 //   R. Bailhache (R.Bailhache@gsi.de)
27 //                            
28 //Begin_Html
29 /*
30 <br>
31 <CENTER>
32 <TABLE border=1>
33 <TR><TD><center>Nz</center></TD><TD><center> 0 </center></TD><TD><center> 1 </center></TD><TD><center> 2 </center></TD><TD><center> 3 </center></TD><TD><center> 4 </center></TD></TR>
34 <TR><TD><CENTER>group of row pads per detector</CENTER></TD><TD><CENTER>1</CENTER></TD><TD><CENTER>2</CENTER></TD><TD><CENTER>4</CENTER></TD><TD><CENTER>6(chamb2)<br> 8(others chambers)</CENTER></TD><TD><CENTER>12 (chamb2)<br> 16 (chamb0)</CENTER></TD></TR>
35 <TR><TD><CENTER>row pads per group</CENTER></TD><TD><CENTER>12 (chamb2)<br> 16 (chamb0)</CENTER></TD><TD><CENTER>6 (chamb2)<br> 8 (chamb0)</CENTER></TD><TD><CENTER>3 (chamb2)<br> 4 (chamb0)</CENTER></TD><TD><CENTER>2</CENTER></TD><TD><CENTER>1</CENTER></TD></TR>
36 <TR><TD><CENTER>~distance [cm]</CENTER></TD><TD><CENTER>106 (chamb2)<br> 130 (chamb0)</CENTER></TD><TD><CENTER>53 (chamb2)<br> 65 (chamb0)</CENTER></TD><TD><CENTER>26.5 (chamb2)<br> 32.5 (chamb0)</CENTER></TD><TD><CENTER>17 (chamb2)<br> 17 (chamb0)</CENTER></TD><TD><CENTER>9 (chamb2)<br> 9 (chamb0)</CENTER></TD></TR>
37 <CAPTION>In the z direction</CAPTION>
38 </TABLE>
39 </CENTER>
40 <CENTER>
41 <br>
42 <TABLE border=1>
43 <TR><TD><center>Nrphi</center></TD><TD><center> 0 </center></TD><TD><center> 1 </center></TD><TD><center> 2 </center></TD><TD><center> 3 </center></TD><TD><center> 4 </center></TD><TD><center> 5 </center></TD><TD><center> 6 </center></TD></TR>
44 <TR><TD><CENTER>group of col pads per detector</CENTER></TD><TD><CENTER>1</CENTER></TD><TD><CENTER>2</CENTER></TD><TD><CENTER>4</CENTER></TD><TD><CENTER>8</CENTER></TD><TD><CENTER>16</CENTER></TD><TD><center>36</center></TD><TD><center>144</center></TD></TR>
45 <TR><TD><CENTER>col pads per group</CENTER></TD><TD><CENTER>144</CENTER></TD><TD><CENTER>72</CENTER></TD><TD><CENTER>36</CENTER></TD><TD><CENTER>18</CENTER></TD><TD><CENTER>9</CENTER></TD><TD><center>4</center></TD><TD><center>1</center></TD></TR>
46 <TR><TD><CENTER>~distance [cm]</CENTER></TD><TD><CENTER>113.4</CENTER></TD><TD><CENTER>56.7</CENTER></TD><TD><CENTER>25.3</CENTER></TD><TD><CENTER>14.3</CENTER></TD><TD><CENTER>7.25</CENTER></TD><TD><center>3.2</center></TD><TD><center>0.8</center></TD></TR>
47 <CAPTION>In the rphi direction</CAPTION>
48 </TABLE>
49 </CENTER>
50 <br>
51 */
52 //End_Html 
53 //
54 //                            
55 //////////////////////////////////////////////////////////////////////////////////////
56
57 #include "AliLog.h"
58
59 #include "AliTRDCalibraMode.h"
60 #include "AliTRDgeometry.h"
61
62 ClassImp(AliTRDCalibraMode)
63
64 //______________________________________________________________________________________
65 AliTRDCalibraMode::AliTRDCalibraMode()
66   :TObject()
67   ,fGeo(0)
68 {
69   //
70   // Default constructor
71   //
72
73   for (Int_t i = 0; i < 3; i++) {
74     fNz[i]    = 0;
75     fNrphi[i] = 0;
76   }
77
78   for (Int_t k = 0; k < 3; k++) {
79     fDetChamb2[k] = 0;
80     fDetChamb0[k] = 0;
81   }
82
83   for (Int_t i = 0; i < 3; i++) {
84     fRowMin[i]    = -1;
85     fRowMax[i]    = -1;
86     fColMax[i]    = -1;
87     fColMin[i]    = -1;
88     fNnZ[i]       = -1;
89     fNnRphi[i]    = -1;
90     fNfragZ[i]    = -1;
91     fNfragRphi[i] = -1;
92     fXbins[i]     = -1;
93   }
94   
95   fGeo = new AliTRDgeometry();
96  
97 }
98
99 //______________________________________________________________________________________
100 AliTRDCalibraMode::AliTRDCalibraMode(const AliTRDCalibraMode &c)
101   :TObject(c)
102   ,fGeo(0)
103 {
104   //
105   // Copy constructor
106   //
107
108   for(Int_t k = 0; k < 3; k++){
109     fNz[k]        = c.fNz[k];
110     fNrphi[k]     = c.fNrphi[k];
111     fNnZ[k]       = c.fNnZ[k];
112     fNnRphi[k]    = c.fNnRphi[k];
113     fNfragZ[k]    = c.fNfragZ[k];
114     fNfragRphi[k] = c.fNfragRphi[k];
115     fRowMin[k]    = c.fRowMin[k];
116     fRowMax[k]    = c.fRowMax[k];
117     fColMin[k]    = c.fColMin[k];
118     fColMax[k]    = c.fColMax[k];
119     fXbins[k]     = c.fXbins[k];
120     fDetChamb0[k] = c.fDetChamb0[k];
121     fDetChamb2[k] = c.fDetChamb2[k];
122   }
123
124   if (fGeo) {
125     delete fGeo;
126   }
127   fGeo = new AliTRDgeometry();
128
129 }
130
131 //____________________________________________________________________________________
132 AliTRDCalibraMode::~AliTRDCalibraMode()
133 {
134   //
135   // AliTRDCalibraMode destructor
136   //
137
138   if (fGeo) {
139     delete fGeo;
140   }
141
142 }
143
144 //_____________________________________________________________________________
145 void AliTRDCalibraMode::SetNz(Int_t i, Short_t Nz)
146 {
147   //
148   // Set the mode of calibration group in the z direction for the parameter i
149   // 
150
151   if ((Nz >= 0) && 
152       (Nz <  5)) {
153     fNz[i] = Nz; 
154   }
155   else { 
156     AliInfo("You have to choose between 0 and 4");
157   }
158
159 }
160
161 //_____________________________________________________________________________
162 void AliTRDCalibraMode::SetNrphi(Int_t i, Short_t Nrphi)
163 {
164   //
165   // Set the mode of calibration group in the rphi direction for the parameter i
166   //
167  
168   if ((Nrphi >= 0) && 
169       (Nrphi <  7)) {
170     fNrphi[i] = Nrphi; 
171   }
172   else {
173     AliInfo("You have to choose between 0 and 6");
174   }
175
176 }
177
178 //_______________________________________________________________________________________
179 void AliTRDCalibraMode::ModePadCalibration(Int_t iChamb, Int_t i)
180 {
181   //
182   // Definition of the calibration mode
183   // from Nz and Nrphi, the number of row and col pads per calibration groups are setted
184   //
185
186
187   fNnZ[i]    = 0;
188   fNnRphi[i] = 0;
189   
190   if ((fNz[i] == 0) && (iChamb == 2)) {
191     fNnZ[i] = 12;
192   }
193   if ((fNz[i] == 0) && (iChamb != 2)) {
194     fNnZ[i] = 16;
195   }  
196   if ((fNz[i] == 1) && (iChamb == 2)) {
197     fNnZ[i] = 6;
198   }
199   if ((fNz[i] == 1) && (iChamb != 2)) {
200     fNnZ[i] = 8;
201   }
202   if ((fNz[i] == 2) && (iChamb == 2)) {
203     fNnZ[i] = 3;
204   }
205   if ((fNz[i] == 2) && (iChamb != 2)) {
206     fNnZ[i] = 4;
207   }
208   if (fNz[i] == 3) {
209     fNnZ[i] = 2;
210   }
211   if (fNz[i] == 4) {
212     fNnZ[i] = 1;
213   }
214    
215   if (fNrphi[i] == 0) {
216     fNnRphi[i] = 144;
217   }
218   if (fNrphi[i] == 1) {
219     fNnRphi[i] = 72;
220   } 
221   if (fNrphi[i] == 2) {
222     fNnRphi[i] = 36;
223   } 
224   if (fNrphi[i] == 3) {
225     fNnRphi[i] = 18;
226   } 
227   if (fNrphi[i] == 4) {
228     fNnRphi[i] = 9;
229   } 
230   if (fNrphi[i] == 5) {
231     fNnRphi[i] = 4;
232   } 
233   if (fNrphi[i] == 6) {
234     fNnRphi[i] = 1;
235   } 
236
237 }
238
239 //_____________________________________________________________________________________________
240 Bool_t AliTRDCalibraMode::ModePadFragmentation(Int_t iLayer,Int_t iStack, Int_t iSect, Int_t i)
241 {
242   //
243   // Definition of the calibration mode
244   // From the number of row and col pads per calibration groups the
245   // number of calibration groups are setted
246   //
247
248   fNfragZ[i]    = 0;
249   fNfragRphi[i] = 0;
250
251   // A little geometry:
252   Int_t rowMax = fGeo->GetRowMax(iLayer,iStack,iSect);
253   Int_t colMax = fGeo->GetColMax(iLayer);
254   
255   // The fragmentation
256   if (fNnZ[i]    != 0) {
257     fNfragZ[i]    = (Int_t) rowMax / fNnZ[i];
258   }
259
260   if (fNnRphi[i] != 0) {
261     fNfragRphi[i] = (Int_t) colMax / fNnRphi[i];
262   }
263
264   return kTRUE;
265
266 }
267
268 //_____________________________________________________________________________
269 void AliTRDCalibraMode::ReconstructionRowPadGroup(Int_t idect, Int_t i)
270 {
271   //
272   // For the calibration group idect in a detector calculate the
273   // first and last row pad and col pad.
274   // The pads in the interval will have the same calibrated coefficients
275   //
276
277   Int_t posc = -1;
278   Int_t posr = -1;
279   fRowMin[i] = -1;
280   fRowMax[i] = -1;
281   fColMin[i] = -1;
282   fColMax[i] = -1;
283   
284   if (fNfragZ[i]    != 0) {
285     posc = (Int_t) idect / fNfragZ[i];
286   }
287   if (fNfragRphi[i] != 0) {
288     posr = (Int_t) idect % fNfragZ[i];
289   }
290   fRowMin[i] = posr     * fNnZ[i];
291   fRowMax[i] = (posr+1) * fNnZ[i];
292   fColMin[i] = posc     * fNnRphi[i];
293   fColMax[i] = (posc+1) * fNnRphi[i];
294
295 }
296
297 //_____________________________________________________________________________
298 void AliTRDCalibraMode::CalculXBins(Int_t idect, Int_t i)
299 {
300   //
301   // For the detector idect calcul the first Xbins
302   //
303
304   fXbins[i] = 0;
305   AliDebug(2, Form("detector: %d", idect));
306
307   // In which sector?
308   Int_t sector = GetSector(idect);
309   fXbins[i] += sector*(6*fDetChamb2[i]+6*4*fDetChamb0[i]);
310  
311   // In which stack?
312   Int_t stack = GetStack(idect);
313   Int_t kc      = 0;
314   while (kc < stack) {
315     if (kc == 2) {
316       fXbins[i] += 6 * fDetChamb2[i];
317     }
318     else {
319       fXbins[i] += 6 * fDetChamb0[i];
320     }
321     kc ++;
322   }
323   
324   // In which layer?
325   Int_t layer = GetLayer(idect);
326   if (stack == 2) {
327     fXbins[i] += layer*fDetChamb2[i];
328   }
329   else {
330     fXbins[i] += layer*fDetChamb0[i];
331   }
332  
333 }
334
335 //_____________________________________________________________________________
336 void AliTRDCalibraMode::ResetMinMax(Int_t i)
337 {
338   //
339   // Reset fRowMin fRowMax fColMin fColMax [i]
340   //
341
342   fRowMin[i] = -1;
343   fRowMax[i] = -1;
344   fColMin[i] = -1;
345   fColMax[i] = -1;
346  
347 }
348
349 //_____________________________________________________________________________
350 void AliTRDCalibraMode::SetDetChamb0(Int_t i)
351 {
352   //
353   // Set the number of calibration group per detector != 2
354   //
355
356   fDetChamb0[i] = fNfragZ[i] * fNfragRphi[i];  
357  
358 }
359
360 //_____________________________________________________________________________
361 void AliTRDCalibraMode::SetDetChamb2(Int_t i)
362 {
363   //
364   // Set the number of calibration group per detector == 2
365   //
366
367   fDetChamb2[i] = fNfragZ[i] * fNfragRphi[i];  
368  
369 }
370
371 //_____________________________________________________________________________
372 Int_t AliTRDCalibraMode::GetLayer(Int_t d) const
373 {
374   //
375   // Reconstruct the plane number from the detector number
376   //
377
378   return ((Int_t) (d % 6));
379
380 }
381
382 //_____________________________________________________________________________
383 Int_t AliTRDCalibraMode::GetStack(Int_t d) const
384 {
385   //
386   // Reconstruct the stack number from the detector number
387   //
388
389   const Int_t kNlayer = 6;
390
391   return ((Int_t) (d % 30) / kNlayer);
392
393 }
394
395 //_____________________________________________________________________________
396 Int_t AliTRDCalibraMode::GetSector(Int_t d) const
397 {
398   //
399   // Reconstruct the sector number from the detector number
400   //
401
402   Int_t fg = 30;
403
404   return ((Int_t) (d / fg));
405
406 }