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