Bug fix in the local y (Jens Wiechula, Marian)
[u/mrichter/AliRoot.git] / TPC / AliTPCROC.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 //                                                                           //
19 //  Geometry        class for a single ROC                                   //
20 //                                                                           //
21 //                                                                           //
22 ///////////////////////////////////////////////////////////////////////////////
23 #include "AliTPCROC.h"
24 #include "TMath.h"
25
26 ClassImp(AliTPCROC)
27
28
29 AliTPCROC* AliTPCROC::fgInstance = 0;
30
31
32
33
34 //_ singleton implementation __________________________________________________
35 AliTPCROC* AliTPCROC::Instance()
36 {
37   //
38   // Singleton implementation
39   // Returns an instance of this class, it is created if neccessary
40   //
41   if (fgInstance == 0){
42     fgInstance = new AliTPCROC();
43     fgInstance->Init();    
44   }
45   return fgInstance;
46 }
47
48
49
50
51 void AliTPCROC::Init(){
52   //
53   // initialize static variables
54   //
55   if (AliTPCROC::fNSectorsAll>0) return;
56   fNSectorsAll =72;
57   fNSectors[0] =36;
58   fNSectors[1] =36;
59   //
60   fNRows[0]= 63;
61   fNRows[1]= 96;
62   //
63   // number of pads in padrow
64   fNPads[0] = new UInt_t[fNRows[0]];
65   fNPads[1] = new UInt_t[fNRows[1]];  
66   //
67   // padrow index in array
68   //
69   fRowPosIndex[0] = new UInt_t[fNRows[0]];
70   fRowPosIndex[1] = new UInt_t[fNRows[1]];
71   //
72   // inner sectors
73   //
74   UInt_t index =0;
75   for (UInt_t irow=0; irow<fNRows[0];irow++){
76     UInt_t npads = (irow==0) ? 68 : 2 *Int_t(Double_t(irow)/3. +33.67);
77     fNPads[0][irow] = npads;
78     fRowPosIndex[0][irow] = index;
79     index+=npads;
80   }
81   fNChannels[0] = index;
82   //
83   index =0;
84   Double_t k1 = 10.*TMath::Tan(10*TMath::DegToRad())/6.;
85   Double_t k2 = 15.*TMath::Tan(10*TMath::DegToRad())/6.;
86   for (UInt_t irow=0; irow<fNRows[1];irow++){    
87     UInt_t npads = (irow<64) ? 
88       2*Int_t(k1*Double_t(irow)+37.75):
89       2*Int_t(k2*Double_t(irow-64)+56.66);
90     fNPads[1][irow] = npads;
91     fRowPosIndex[1][irow] = index;
92     index+=npads;
93   }
94   fNChannels[1] = index;
95   SetGeometry();
96 }
97
98
99
100
101 void AliTPCROC::SetGeometry()
102 {
103   //
104   //set ROC geometry parameters
105   //
106   const  Float_t kInnerRadiusLow = 83.65;
107   const  Float_t kInnerRadiusUp  = 133.3;
108   const  Float_t kOuterRadiusLow = 133.5;
109   const  Float_t kOuterRadiusUp  = 247.7;
110   const  Float_t kInnerFrameSpace = 1.5;
111   const  Float_t kOuterFrameSpace = 1.5;
112   const  Float_t kInnerWireMount = 1.2;
113   const  Float_t kOuterWireMount = 1.4;
114   const  Float_t kZLength =250.;
115   const  UInt_t   kNRowLow = 63;
116   const  UInt_t   kNRowUp1 = 64;
117   const  UInt_t   kNRowUp2 = 32;
118   const  UInt_t   kNRowUp  = 96;
119   const  Float_t kInnerAngle = 20; // 20 degrees
120   const  Float_t kOuterAngle = 20; // 20 degrees
121   //
122   //  pad     parameters
123   // 
124   const Float_t  kInnerPadPitchLength = 0.75;
125   const Float_t  kInnerPadPitchWidth = 0.40;
126   const Float_t  kInnerPadLength = 0.75;
127   const Float_t  kInnerPadWidth = 0.40;
128   const Float_t  kOuter1PadPitchLength = 1.0;
129   const Float_t  kOuterPadPitchWidth = 0.6;
130   const Float_t  kOuter1PadLength = 1.0;
131   const Float_t  kOuterPadWidth = 0.6;
132   const Float_t  kOuter2PadPitchLength = 1.5;
133   const Float_t  kOuter2PadLength = 1.5;  
134
135   //
136   //wires default parameters
137   //
138 //   const UInt_t    kNInnerWiresPerPad = 3;
139 //   const UInt_t    kInnerDummyWire = 2;
140 //   const Float_t  kInnerWWPitch = 0.25;
141 //   const Float_t  kRInnerFirstWire = 84.475;
142 //   const Float_t  kRInnerLastWire = 132.475;
143 //   const Float_t  kInnerOffWire = 0.5;
144 //   const UInt_t    kNOuter1WiresPerPad = 4;
145 //   const UInt_t    kNOuter2WiresPerPad = 6;
146 //   const Float_t  kOuterWWPitch = 0.25;  
147 //   const Float_t  kROuterFirstWire = 134.225;
148 //   const Float_t  kROuterLastWire = 246.975;
149 //   const UInt_t    kOuterDummyWire = 2;
150 //   const Float_t  kOuterOffWire = 0.5;
151   //
152   //set sector parameters
153   //
154   fInnerRadiusLow = kInnerRadiusLow;
155   fOuterRadiusLow = kOuterRadiusLow;
156   fInnerRadiusUp  = kInnerRadiusUp;
157   fOuterRadiusUp  = kOuterRadiusUp;  
158   fInnerFrameSpace = kInnerFrameSpace;
159   fOuterFrameSpace = kOuterFrameSpace;
160   fInnerWireMount  = kInnerWireMount;
161   fOuterWireMount  = kOuterWireMount;
162   fZLength         = kZLength;
163   fInnerAngle      =  TMath::DegToRad()*kInnerAngle;
164   fOuterAngle      =  TMath::DegToRad()*kOuterAngle;
165
166   fNRowLow       = kNRowLow;
167   fNRowUp1      = kNRowUp1;
168   fNRowUp2       = kNRowUp2;
169   fNRowUp        = kNRowUp;
170   //
171   //set pad parameter
172   //
173   fInnerPadPitchLength = kInnerPadPitchLength;
174   fInnerPadPitchWidth  = kInnerPadPitchWidth;
175   fInnerPadLength      = kInnerPadLength;
176   fInnerPadWidth       = kInnerPadWidth;
177   fOuter1PadPitchLength = kOuter1PadPitchLength; 
178   fOuter2PadPitchLength = kOuter2PadPitchLength;
179   fOuterPadPitchWidth   = kOuterPadPitchWidth;
180   fOuter1PadLength      = kOuter1PadLength;
181   fOuter2PadLength      = kOuter2PadLength;
182   fOuterPadWidth        = kOuterPadWidth; 
183
184   //
185   //set wire parameters
186   //
187   // SetInnerNWires(kNInnerWiresPerPad);
188   //   SetInnerDummyWire(kInnerDummyWire);
189   //   SetInnerOffWire(kInnerOffWire);
190   //   SetOuter1NWires(kNOuter1WiresPerPad);
191   //   SetOuter2NWire(kNOuter2WiresPerPad);
192   //   SetOuterDummyWire(kOuterDummyWire);
193   //   SetOuterOffWire(kOuterOffWire);
194   //   SetInnerWWPitch(kInnerWWPitch);
195   //   SetRInnerFirstWire(kRInnerFirstWire);
196   //   SetRInnerLastWire(kRInnerLastWire);
197   //   SetOuterWWPitch(kOuterWWPitch);
198   //   SetROuterFirstWire(kROuterFirstWire);
199   //   SetROuterLastWire(kROuterLastWire);  
200
201   UInt_t i=0;
202   Float_t firstrow = fInnerRadiusLow + 1.575;   
203   for( i= 0;i<fNRowLow;i++)
204     {
205       Float_t x = firstrow + fInnerPadPitchLength*(Float_t)i;  
206       fPadRowLow[i]=x;
207       fYInner[i+1]  = x*TMath::Tan(fInnerAngle/2.)-fInnerWireMount;
208       fNPadsLow[i] = GetNPads(0,i) ;     // ROC implement     
209     }
210   // cross talk rows
211   fYInner[0]=(fPadRowLow[0]-fInnerPadPitchLength)*TMath::Tan(fInnerAngle/2.)-fInnerWireMount;
212   fYInner[fNRowLow+1]=(fPadRowLow[fNRowLow-1]+fInnerPadPitchLength)*TMath::Tan(fInnerAngle/2.)-fInnerWireMount; 
213   firstrow = fOuterRadiusLow + 1.6;
214   for(i=0;i<fNRowUp;i++)
215     {
216       if(i<fNRowUp1){
217         Float_t x = firstrow + fOuter1PadPitchLength*(Float_t)i; 
218         fPadRowUp[i]=x;
219         fYOuter[i+1]= x*TMath::Tan(fOuterAngle/2.)-fOuterWireMount;
220         fNPadsUp[i] =  GetNPads(36,i) ;     // ROC implement      
221         if(i==fNRowUp1-1) {
222           fLastWireUp1=fPadRowUp[i] +0.625;
223           firstrow = fPadRowUp[i] + 0.5*(fOuter1PadPitchLength+fOuter2PadPitchLength);
224         }
225       }
226       else
227         {
228           Float_t x = firstrow + fOuter2PadPitchLength*(Float_t)(i-64);
229           fPadRowUp[i]=x;
230           fNPadsUp[i] =  GetNPads(36,i) ;     // ROC implement
231         }
232       fYOuter[i+1]  = fPadRowUp[i]*TMath::Tan(fOuterAngle/2.)-fOuterWireMount;
233     }
234   
235
236
237
238
239
240
241
242 //_____________________________________________________________________________
243 AliTPCROC::AliTPCROC()
244           :TObject(), 
245            fNSectorsAll(0),
246            fInnerRadiusLow(0.),
247            fInnerRadiusUp(0.),
248            fOuterRadiusUp(0.),
249            fOuterRadiusLow(0.),
250            fInnerFrameSpace(0.),
251            fOuterFrameSpace(0.),
252            fInnerWireMount(0.),
253            fOuterWireMount(0.),
254            fZLength(0.),
255            fInnerAngle(0.),
256            fOuterAngle(0.),
257            fNInnerWiresPerPad(0),
258            fInnerWWPitch(0.),
259            fInnerDummyWire(0),
260            fInnerOffWire(0.),
261            fRInnerFirstWire(0.),
262            fRInnerLastWire(0.),
263            fLastWireUp1(0.),
264            fNOuter1WiresPerPad(0),
265            fNOuter2WiresPerPad(0),
266            fOuterWWPitch(0.),
267            fOuterDummyWire(0),
268            fOuterOffWire(0),
269            fROuterFirstWire(0.),
270            fROuterLastWire(0),
271            fInnerPadPitchLength(0.),
272            fInnerPadPitchWidth(0.),
273            fInnerPadLength(0.),
274            fInnerPadWidth(0.),
275            fOuter1PadPitchLength(0.),
276            fOuter2PadPitchLength(0),
277            fOuterPadPitchWidth(0),
278            fOuter1PadLength(0.),
279            fOuter2PadLength(0),
280            fOuterPadWidth(0),
281            fNRowLow(0),
282            fNRowUp1(0),
283            fNRowUp2(0),
284            fNRowUp(0),
285            fNtRows(0)
286 {
287   //
288   // Default constructor
289   for (UInt_t i=0;i<2;i++){
290     fNSectors[i]  = 0;
291     fNRows[i]     = 0;
292     fNChannels[i] = 0;
293     fNPads[i]     = 0;
294     fRowPosIndex[i]= 0;
295   }
296 }
297
298
299 //_____________________________________________________________________________
300 AliTPCROC::AliTPCROC(const AliTPCROC &roc)
301           :TObject(roc),
302            fNSectorsAll(0),
303            fInnerRadiusLow(0.),
304            fInnerRadiusUp(0.),
305            fOuterRadiusUp(0.),
306            fOuterRadiusLow(0.),
307            fInnerFrameSpace(0.),
308            fOuterFrameSpace(0.),
309            fInnerWireMount(0.),
310            fOuterWireMount(0.),
311            fZLength(0.),
312            fInnerAngle(0.),
313            fOuterAngle(0.),
314            fNInnerWiresPerPad(0),
315            fInnerWWPitch(0.),
316            fInnerDummyWire(0),
317            fInnerOffWire(0.),
318            fRInnerFirstWire(0.),
319            fRInnerLastWire(0.),
320            fLastWireUp1(0.),
321            fNOuter1WiresPerPad(0),
322            fNOuter2WiresPerPad(0),
323            fOuterWWPitch(0.),
324            fOuterDummyWire(0),
325            fOuterOffWire(0),
326            fROuterFirstWire(0.),
327            fROuterLastWire(0),
328            fInnerPadPitchLength(0.),
329            fInnerPadPitchWidth(0.),
330            fInnerPadLength(0.),
331            fInnerPadWidth(0.),
332            fOuter1PadPitchLength(0.),
333            fOuter2PadPitchLength(0),
334            fOuterPadPitchWidth(0),
335            fOuter1PadLength(0.),
336            fOuter2PadLength(0),
337            fOuterPadWidth(0),
338            fNRowLow(0),
339            fNRowUp1(0),
340            fNRowUp2(0),
341            fNRowUp(0),
342            fNtRows(0)
343
344 {
345   //
346   // AliTPCROC copy constructor
347   //
348   fNSectorsAll = roc.fNSectorsAll;
349   fNSectors[0] = roc.fNSectors[0];
350   fNSectors[1] = roc.fNSectors[1];
351   fNRows[0]    = roc.fNRows[0];
352   fNRows[1]    = roc.fNRows[1];
353   fNChannels[0]= roc.fNChannels[0];
354   fNChannels[1]= roc.fNChannels[1];
355   //
356   // number of pads in padrow
357   fNPads[0] = new UInt_t[fNRows[0]];
358   fNPads[1] = new UInt_t[fNRows[1]];  
359   //
360   // padrow index in array
361   //
362   fRowPosIndex[0] = new UInt_t[fNRows[0]];
363   fRowPosIndex[1] = new UInt_t[fNRows[1]];
364   //
365   for (UInt_t irow =0; irow<fNRows[0];irow++){
366     fNPads[0][irow]       = roc.fNPads[0][irow];
367     fRowPosIndex[0][irow] = roc.fRowPosIndex[0][irow];
368   }
369   for (UInt_t irow =0; irow<fNRows[1];irow++){
370     fNPads[1][irow]       = roc.fNPads[1][irow];
371     fRowPosIndex[1][irow] = roc.fRowPosIndex[1][irow];
372   }
373 }
374 //____________________________________________________________________________
375 AliTPCROC & AliTPCROC::operator =(const AliTPCROC & roc)
376 {
377   //
378   // assignment operator - dummy
379   //
380   fZLength = roc.fZLength;
381   return (*this);
382 }
383 //_____________________________________________________________________________
384 AliTPCROC::~AliTPCROC()
385 {
386   //
387   // AliTPCROC destructor
388   //
389   delete [] fNPads[0];
390   delete [] fNPads[1];
391   delete [] fRowPosIndex[0];
392   delete [] fRowPosIndex[1];
393   fgInstance = 0x0;
394   
395 }
396
397
398
399
400 void AliTPCROC::GetPositionLocal(UInt_t sector, UInt_t row, UInt_t pad, Float_t *pos){
401   //
402   // get position of center of pad - ideal frame used
403   //
404   pos[2]=fZLength;
405   if (sector<36){
406    pos[0] = fPadRowLow[row];
407    pos[1] = fInnerPadPitchWidth*(Int_t(pad)+0.5-Int_t(fNPads[0][row])/2);
408   }else{
409     pos[0] = fPadRowUp[row];
410     pos[1] = fOuterPadPitchWidth*(Int_t(pad)+0.5-Int_t(fNPads[1][row])/2);    
411   }
412   if ((sector%36)>=18){
413     pos[2] *= -1.;
414     pos[1] *= -1.;
415   }
416 }
417
418
419 void AliTPCROC::GetPositionGlobal(UInt_t sector, UInt_t row, UInt_t pad, Float_t *pos){
420   //
421   // get position of center of pad - ideal frame used 
422   //
423   GetPositionLocal(sector,row,pad,pos);
424   Double_t alpha = TMath::DegToRad()*(10.+20.*(sector%18));
425   Float_t gx = pos[0]*TMath::Cos(alpha)-pos[1]*TMath::Sin(alpha);
426   Float_t gy = pos[1]*TMath::Cos(alpha)+pos[0]*TMath::Sin(alpha);
427   pos[0] = gx;
428   pos[1] = gy;
429 }