variables names changed according to ALICE convention
[u/mrichter/AliRoot.git] / PMD / AliPMDUtility.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 //                                                     //
18 //  Date   : August 05 2003                            //
19 //                                                     //
20 //  Utility code for ALICE-PMD                         //
21 //                                                     //
22 //-----------------------------------------------------//
23
24 #include "Riostream.h"
25 #include "AliPMDUtility.h"
26 #include "TMath.h"
27 #include <stdio.h>
28 #include <math.h>
29
30
31 ClassImp(AliPMDUtility)
32
33 AliPMDUtility::AliPMDUtility()
34 {
35   // Default constructor
36   fPx    = 0.;
37   fPy    = 0.;
38   fPz    = 0.;
39   fTheta = 0.;
40   fEta   = 0.;
41   fPhi   = 0.;
42 }
43
44 AliPMDUtility::AliPMDUtility(Float_t px, Float_t py, Float_t pz)
45 {
46   // Constructor
47   fPx = px;
48   fPy = py;
49   fPz = pz;
50   fTheta = 0.;
51   fEta   = 0.;
52   fPhi   = 0.;
53 }
54
55 AliPMDUtility::~AliPMDUtility()
56 {
57   // Default destructor
58 }
59 void AliPMDUtility::HexGeomCellPos(Int_t ism, Int_t xpad, Int_t ypad, Float_t &xpos, Float_t &ypos)
60 {
61   // This converts PMD cluster or CELL coordinates
62   // to Global coordinates.
63   // Written by Prof. S.C. Phatak
64
65   const Float_t  kCellDia = 0.5;
66   const Float_t  kPi      = TMath::Pi();    //3.14159;
67   const Double_t kSqroot3by2   = 0.8660254;  // sqrth = sqrt(3.)/2.
68
69   Int_t i;
70   Int_t j = xpad;
71   Int_t k = ypad;
72
73   /*
74     Supermodeule number starting from 0
75     ism --> supermodule no ( 0 - 26 )
76     idet --> detector ( pmd or cpv : not required now )
77     j --> xpad ( goes from 1 to 72 )
78     k --> ypad ( goes from 1 to 72 )
79     xp --> global x coordinate
80     yp --> global y coordinate
81     
82     (xp0,yp0) corner positions of all supermodules in global
83     coordinate system. That is the origin
84     of the local ( supermodule ) coordinate system.
85   */ 
86   
87   Float_t xp0[27] = 
88   {
89     -17.9084, 18.2166, 54.3416, -35.9709, 0.154144, 
90     36.2791, -54.0334, -17.9084, 18.2166, 36.7791, 
91     18.7166, 0.654194, 72.9041, 54.8416, 36.7792, 
92     109.029, 90.9666, 72.9042, -18.8708, -36.9334, 
93     -54.996, -36.9332, -54.9958, -73.0584, -54.9956, 
94     -73.0582, -91.1208
95   };
96
97   Float_t yp0[27] = 
98   {
99     -32.1395, -32.1395, -32.1395, -63.4247, -63.4247, 
100     -63.4247, -94.7098, -94.7098, -94.7098, 0.545689, 
101     31.8309, 63.1161, 0.545632, 31.8308, 63.116, 
102     0.545573, 31.8308, 63.116, 31.5737, 0.288616, 
103     -30.9965, 62.859, 31.5738, 0.288733, 94.1442, 
104     62.8591, 31.574
105   };
106
107   /* 
108      angles of rotation for three sets of supermodules
109      The angle is same for first nine, next nine and last nine 
110      supermodules 
111   */
112   
113   Float_t th[3] = {0., -2.*kPi/3., 2.*kPi/3.};
114   Float_t xr, yr, xinit, yinit, cs, sn;
115   
116   /* 
117      xinit and yinit are coordinates of the cell in local coordinate system
118   */
119   
120   xinit = (j)*kCellDia+(k)/2.*kCellDia;
121   yinit = kSqroot3by2*(k)/2.;
122   i=ism/9;
123   cs=cos(th[i]);
124   sn=sin(th[i]);
125   //
126   // rotate first
127   //
128   xr=cs*xinit+sn*yinit;
129   yr=-sn*xinit+cs*yinit;
130   //
131   // then translate
132   //
133   xpos=xr+xp0[ism];
134   ypos=yr+yp0[ism];
135
136 }
137
138 void AliPMDUtility::RectGeomCellPos(Int_t ism, Int_t ium, Int_t xpad, Int_t ypad, Float_t &xpos, Float_t &ypos)
139 {
140   // This routine finds the cell eta,phi for the new PMD rectangular 
141   // geometry in ALICE
142   // Authors : Bedanga Mohanty and Dipak Mishra - 29.4.2003
143   // modified by B. K. Nnadi for change of coordinate sys
144   //
145   // SMA  ---> Supermodule Type A           ( SM - 0)
146   // SMAR ---> Supermodule Type A ROTATED   ( SM - 1)
147   // SMB  ---> Supermodule Type B           ( SM - 2)
148   // SMBR ---> Supermodule Type B ROTATED   ( SM - 3)
149   //
150   // ism   : number of supermodules in one plane = 4
151   // ium   : number of unitmodules  in one SM    = 6
152   // gbum  : (global) unit module numbering in a supermodule
153   //
154
155   Int_t gbum = ism*6 + ium;
156   Int_t irow  = xpad;
157   Int_t icol  = ypad;
158
159   // Corner positions (x,y) of the 24 unit moudles in ALICE PMD
160   
161   Double_t xcorner[24] =
162   {
163     85.15,  60.85,  36.55,  85.15,  60.85,  36.55, //SMA 
164     -85.15, -60.85, -36.55, -85.15, -60.85, -36.55, //SMAR
165     84.90,  36.60,  84.90,  36.60,  84.90,  36.60, //SMB
166     -84.90, -36.60, -84.90, -36.60, -84.90, -36.60  //SMBR
167   };
168   
169   Double_t ycorner[24] =
170   { 
171     32.45708755,  32.45708755,  32.45708755,        //SMA
172     -9.30645245,  -9.30645245,  -9.30645245,        //SMA
173     -32.45708755, -32.45708755, -32.45708755,        //SMAR
174     9.30645245,   9.30645245,   9.30645245,        //SMAR
175     -31.63540818, -31.63540818, -52.61435544,        //SMB
176     -52.61435544, -73.59330270, -73.59330270,        //SMB
177     31.63540818,  31.63540818,  52.61435544,        //SMBR
178     52.61435544,  73.59330270,  73.59330270         //SMBR
179   };
180   
181   const Float_t kSqroot3      = 1.73205;  // sqrt(3.);
182   const Float_t kCellRadius   = 0.25;
183   
184   //
185   //Every even row of cells is shifted and placed
186   //in geant so this condition
187   //
188   Float_t shift = 0.0;
189   if(irow%2 == 0)
190     {
191       shift = 0.25;
192     }
193   else
194     {
195       shift = 0.0;
196     }
197   if(ism == 0 || ism == 2)
198     {
199       ypos = ycorner[gbum] + 
200         irow*kCellRadius*kSqroot3;
201
202       xpos = xcorner[gbum] - 
203         icol*2.0*kCellRadius - shift;
204     }
205   else if(ism == 1 || ism == 3)
206     {
207       ypos = ycorner[gbum] -
208         irow*kCellRadius*kSqroot3;
209
210       xpos = xcorner[gbum] +
211         icol*2.0*kCellRadius + shift;
212     }
213 }
214
215 void AliPMDUtility::RectGeomCellPos(Int_t ism, Int_t ium, Float_t xpad, Float_t ypad, Float_t &xpos, Float_t &ypos)
216 {
217   // If the xpad and ypad inputs are float, then 0.5 is added to it
218   // to find the layer which is shifted.
219   // This routine finds the cell eta,phi for the new PMD rectangular 
220   // geometry in ALICE
221   // Authors : Bedanga Mohanty and Dipak Mishra - 29.4.2003
222   // modified by B. K. Nnadi for change of coordinate sys
223   //
224   // SMA  ---> Supermodule Type A           ( SM - 0)
225   // SMAR ---> Supermodule Type A ROTATED   ( SM - 1)
226   // SMB  ---> Supermodule Type B           ( SM - 2)
227   // SMBR ---> Supermodule Type B ROTATED   ( SM - 3)
228   //
229   // ism   : number of supermodules in one plane = 4
230   // ium   : number of unitmodules  in one SM    = 6
231   // gbum  : (global) unit module numbering in a supermodule
232   //
233
234   Int_t gbum    = ism*6 + ium;
235   Float_t irow  = xpad;
236   Float_t icol  = ypad;
237
238   // Corner positions (x,y) of the 24 unit moudles in ALICE PMD
239   
240   Double_t xcorner[24] =
241   {
242     85.15,  60.85,  36.55,  85.15,  60.85,  36.55, //SMA 
243     -85.15, -60.85, -36.55, -85.15, -60.85, -36.55, //SMAR
244     84.90,  36.60,  84.90,  36.60,  84.90,  36.60, //SMB
245     -84.90, -36.60, -84.90, -36.60, -84.90, -36.60  //SMBR
246   };
247   
248   Double_t ycorner[24] =
249   { 
250     32.45708755,  32.45708755,  32.45708755,        //SMA
251     -9.30645245,  -9.30645245,  -9.30645245,        //SMA
252     -32.45708755, -32.45708755, -32.45708755,        //SMAR
253     9.30645245,   9.30645245,   9.30645245,        //SMAR
254     -31.63540818, -31.63540818, -52.61435544,        //SMB
255     -52.61435544, -73.59330270, -73.59330270,        //SMB
256     31.63540818,  31.63540818,  52.61435544,        //SMBR
257     52.61435544,  73.59330270,  73.59330270         //SMBR
258   };
259   
260   const Float_t kSqroot3    = 1.73205;  // sqrt(3.);
261   const Float_t kCellRadius = 0.25;
262   
263   //
264   //Every even row of cells is shifted and placed
265   //in geant so this condition
266   //
267   Float_t shift = 0.0;
268   Int_t iirow = (Int_t) (irow+0.5);
269   if(iirow%2 == 0)
270     {
271       shift = 0.25;
272     }
273   else
274     {
275       shift = 0.0;
276     }
277   if(ism == 0 || ism == 2)
278     {
279       ypos = ycorner[gbum] + 
280         irow*kCellRadius*kSqroot3;
281
282       xpos = xcorner[gbum] - 
283         icol*2.0*kCellRadius - shift;
284     }
285   else if(ism == 1 || ism == 3)
286     {
287       ypos = ycorner[gbum] -
288         irow*kCellRadius*kSqroot3;
289
290       xpos = xcorner[gbum] +
291         icol*2.0*kCellRadius + shift;
292     }
293 }
294
295 void AliPMDUtility::SetPxPyPz(Float_t px, Float_t py, Float_t pz)
296 {
297   fPx = px;
298   fPy = py;
299   fPz = pz;
300 }
301
302 void AliPMDUtility::SetXYZ(Float_t xpos, Float_t ypos, Float_t zpos)
303 {
304   fPx = xpos;
305   fPy = ypos;
306   fPz = zpos;
307 }
308 void AliPMDUtility::CalculateEta()
309 {
310   Float_t rpxpy, theta, eta;
311
312   rpxpy  = TMath::Sqrt(fPx*fPx + fPy*fPy);
313   theta  = TMath::ATan2(rpxpy,fPz);
314   eta    = -TMath::Log(TMath::Tan(0.5*theta));
315   fTheta = theta;
316   fEta   = eta;
317 }
318 void AliPMDUtility::CalculatePhi()
319 {
320   Float_t pybypx, phi = 0., phi1;
321
322   if(fPx==0)
323     {
324       if(fPy>0) phi = 90.;
325       if(fPy<0) phi = 270.;
326     }
327   if(fPx != 0)
328     {
329       pybypx = fPy/fPx;
330       if(pybypx < 0) pybypx = - pybypx;
331       phi1 = TMath::ATan(pybypx)*180./3.14159;
332
333       if(fPx > 0 && fPy > 0) phi = phi1;        // 1st Quadrant
334       if(fPx < 0 && fPy > 0) phi = 180 - phi1;  // 2nd Quadrant
335       if(fPx < 0 && fPy < 0) phi = 180 + phi1;  // 3rd Quadrant
336       if(fPx > 0 && fPy < 0) phi = 360 - phi1;  // 4th Quadrant
337
338     }
339   phi = phi*3.14159/180.;
340
341   fPhi = phi;
342
343 }
344 void AliPMDUtility::CalculateEtaPhi()
345 {
346   Float_t rpxpy, theta, eta;
347   Float_t pybypx, phi = 0., phi1;
348
349   rpxpy = TMath::Sqrt(fPx*fPx + fPy*fPy);
350   theta = TMath::ATan2(rpxpy,fPz);
351   eta   = -TMath::Log(TMath::Tan(0.5*theta));
352   
353   if(fPx==0)
354     {
355       if(fPy>0) phi = 90.;
356       if(fPy<0) phi = 270.;
357     }
358   if(fPx != 0)
359     {
360       pybypx = fPy/fPx;
361       if(pybypx < 0) pybypx = - pybypx;
362       phi1 = TMath::ATan(pybypx)*180./3.14159;
363       if(fPx > 0 && fPy > 0) phi = phi1;        // 1st Quadrant
364       if(fPx < 0 && fPy > 0) phi = 180 - phi1;  // 2nd Quadrant
365       if(fPx < 0 && fPy < 0) phi = 180 + phi1;  // 3rd Quadrant
366       if(fPx > 0 && fPy < 0) phi = 360 - phi1;  // 4th Quadrant
367
368     }
369   phi = phi*3.14159/180.;
370
371   fTheta = theta;
372   fEta   = eta;
373   fPhi   = phi;
374 }
375 Float_t AliPMDUtility::GetTheta() const
376 {
377   return fTheta;
378 }
379 Float_t AliPMDUtility::GetEta() const
380 {
381   return fEta;
382 }
383 Float_t AliPMDUtility::GetPhi() const
384 {
385   return fPhi;
386 }
387