Fix to avoid deleting cached CDB objects - modified fix by Peter.
[u/mrichter/AliRoot.git] / FMD / AliFMDRing.cxx
1 /**************************************************************************
2  * Copyright(c) 2004, 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 /* $Id$ */
16 /** @file    AliFMDRing.cxx
17     @author  Christian Holm Christensen <cholm@nbi.dk>
18     @date    Mon Mar 27 12:47:43 2006
19     @brief   FMD ring geometry parameters 
20 */
21 //__________________________________________________________________
22 //
23 // Utility class to help implement collection of FMD modules into
24 // rings.  This is used by AliFMDDetector and AliFMDGeometry.
25 // The AliFMDGeometry object owns the AliFMDRing objects, and the
26 // AliFMDDetector objects reference these.  That is, the AliFMDRing
27 // objects are share amoung the AliFMDDetector objects.
28 //
29 // Latest changes by Christian Holm Christensen
30 //
31
32 #include <TMath.h>              // ROOT_TMath
33 #include <TVector2.h>           // ROOT_TVector2
34
35 // #include <AliLog.h>          // ALILOG_H
36 #include "AliFMDRing.h"         // ALIFMDRING_H
37
38 //====================================================================
39 ClassImp(AliFMDRing)
40 #if 0
41   ; // This is here to keep Emacs for indenting the next line
42 #endif
43
44 //____________________________________________________________________
45 AliFMDRing::AliFMDRing(Char_t id) 
46   : TNamed(Form("FMD%c", id), "Forward multiplicity ring"), 
47     fId(id), 
48     fBondingWidth(0),
49     fWaferRadius(0),
50     fSiThickness(0),
51     fLowR(0),
52     fHighR(0),
53     fMinR(0),
54     fMaxR(0),
55     fTheta(0),
56     fNStrips(0),
57     fRingDepth(0),
58     fLegRadius(0),
59     fLegLength(0),
60     fLegOffset(0),
61     fModuleSpacing(0),
62     fPrintboardThickness(0),
63     fCopperThickness(0),
64     fChipThickness(0),
65     fSpacing(0),
66     fHoneycombThickness(0.),
67     fAlThickness(0.),
68     fVerticies(0), 
69     fSensorVerticies(0),
70     fHybridVerticies(0),
71     fFeetPositions(0)
72 {
73   // Constructor 
74   // 
75   // Parameters: 
76   //    id      Type of ring (either 'I' or 'O') 
77   // 
78   SetBondingWidth();
79   SetWaferRadius();
80   SetSiThickness();
81   SetLegRadius();
82   SetLegLength();
83   SetLegOffset();
84   SetModuleSpacing();
85   SetPrintboardThickness();
86   SetCopperThickness();
87   SetChipThickness();
88   SetSpacing();
89   SetHoneycombThickness();
90   SetAlThickness();
91   
92   if (fId == 'I' || fId == 'i') {
93     SetLowR(4.3);
94     SetHighR(17.2);
95     SetTheta(36/2);
96     SetNStrips(512);
97     Double_t base = 0; // 4.1915;
98     fFeetPositions.Add(new TVector2( 0.0551687, 8.0534-base));
99     fFeetPositions.Add(new TVector2( 2.9993,   12.9457-base));
100     fFeetPositions.Add(new TVector2(-2.9062,   12.9508-base));
101     
102     fHybridVerticies.Add(new TVector2(0.0000,  4.1700));
103     fHybridVerticies.Add(new TVector2(1.0574,  4.1700));
104     fHybridVerticies.Add(new TVector2(4.6614, 15.2622));
105     fHybridVerticies.Add(new TVector2(0.9643, 17.4000));
106     fHybridVerticies.Add(new TVector2(0.0000, 17.4000));
107
108     fSensorVerticies.Add(new TVector2(0.0000,  4.1915));
109     fSensorVerticies.Add(new TVector2(1.5793,  4.1915));
110     fSensorVerticies.Add(new TVector2(5.2293, 15.4251));
111     fSensorVerticies.Add(new TVector2(1.9807, 17.3035));
112     fSensorVerticies.Add(new TVector2(0.0000, 17.3035));
113
114     fVerticies.Add(new TVector2(0.0000,  4.3000));
115     fVerticies.Add(new TVector2(1.3972,  4.3000));
116     fVerticies.Add(new TVector2(4.9895, 15.3560));
117     fVerticies.Add(new TVector2(1.8007, 17.2000));
118     fVerticies.Add(new TVector2(0.0000, 17.2000));
119   }
120   else if (fId == 'O' || fId == 'o') {
121     SetLowR(15.6);
122     SetHighR(28.0);
123     SetTheta(18/2);
124     SetNStrips(256);
125     Double_t base = 0; // 14.9104;
126     fFeetPositions.Add(new TVector2(-1.72540000, 20.6267-base));
127     fFeetPositions.Add(new TVector2( 1.72900000, 20.6267-base));
128     fFeetPositions.Add(new TVector2( 0.00177616, 26.6007-base));
129
130     fHybridVerticies.Add(new TVector2(0.0000, 14.9104));
131     fHybridVerticies.Add(new TVector2(2.0783, 14.9104));
132     fHybridVerticies.Add(new TVector2(3.9202, 26.5395));
133     fHybridVerticies.Add(new TVector2(0.6784, 28.2500));
134     fHybridVerticies.Add(new TVector2(0.0000, 28.2500));
135
136     fSensorVerticies.Add(new TVector2(0.0000, 15.0104));
137     fSensorVerticies.Add(new TVector2(2.5799, 15.0104));
138     fSensorVerticies.Add(new TVector2(4.4439, 26.7766));
139     fSensorVerticies.Add(new TVector2(1.8350, 28.1500));
140     fSensorVerticies.Add(new TVector2(0.0000, 28.1500));
141
142     fVerticies.Add(new TVector2(0.0000, 15.2104));
143     fVerticies.Add(new TVector2(2.4091, 15.2104));
144     fVerticies.Add(new TVector2(4.2231, 26.6638));
145     fVerticies.Add(new TVector2(1.8357, 27.9500));
146     fVerticies.Add(new TVector2(0.0000, 27.9500));
147   }
148 }
149
150 //____________________________________________________________________
151 void
152 AliFMDRing::Init()
153 {
154   // Initialize 
155   // 
156   // All derived quantities are calculated here. 
157   // 
158 #if 0
159   Double_t tanTheta  = TMath::Tan(fTheta * TMath::Pi() / 180.);
160   Double_t tanTheta2 = TMath::Power(tanTheta,2);
161   Double_t r2        = TMath::Power(fWaferRadius,2);
162   Double_t yA        = tanTheta * fLowR;
163   Double_t lr2       = TMath::Power(fLowR, 2);
164   Double_t hr2       = TMath::Power(fHighR,2);
165   Double_t xD        = fLowR + TMath::Sqrt(r2 - tanTheta2 * lr2);
166   Double_t xD2       = TMath::Power(xD,2);
167   Double_t yB        = TMath::Sqrt(r2 - hr2 + 2 * fHighR * xD - xD2);
168   Double_t xC        = ((xD + TMath::Sqrt(-tanTheta2 * xD2 + r2
169                                           + r2 * tanTheta2)) 
170                         / (1 + tanTheta2));
171   Double_t yC        = tanTheta * xC;
172   
173   fVerticies.Expand(6);
174   fVerticies.AddAt(new TVector2(fLowR,  -yA), 0);
175   fVerticies.AddAt(new TVector2(xC,     -yC), 1);
176   fVerticies.AddAt(new TVector2(fHighR, -yB), 2);
177   fVerticies.AddAt(new TVector2(fHighR,  yB), 3);
178   fVerticies.AddAt(new TVector2(xC,      yC), 4);
179   fVerticies.AddAt(new TVector2(fLowR,   yA), 5);  
180 #endif
181
182   // A's length. Corresponds to distance from nominal beam line to the
183   // cornor of the active silicon element. 
184   fMinR = GetVertex(1)->Mod(); // GetVertex(5)->Mod();
185   // A's length. Corresponds to distance from nominal beam line to the
186   // cornor of the active silicon element. 
187   fMaxR = fHighR;
188
189   fRingDepth = (fSiThickness + fPrintboardThickness 
190                 + fCopperThickness + fChipThickness 
191                 + fLegLength + fModuleSpacing + fSpacing);
192 }
193
194 //____________________________________________________________________
195 TVector2*
196 AliFMDRing::GetVertex(Int_t i) const
197 {
198   // Get the i'th vertex of polygon shape
199   // 
200   // the polygon shape describes the shape of the rings' sensors
201   // 
202   // Parameters: 
203   //     i    The vertex number to get (from 0 to 5)
204   return static_cast<TVector2*>(fVerticies.At(i));
205 }
206
207 //____________________________________________________________________
208 TVector2*
209 AliFMDRing::GetSensorVertex(Int_t i) const
210 {
211   // Get the i'th vertex of polygon shape
212   // 
213   // the polygon shape describes the shape of the rings' sensors
214   // 
215   // Parameters: 
216   //     i    The vertex number to get (from 0 to 5)
217   return static_cast<TVector2*>(fSensorVerticies.At(i));
218 }
219
220 //____________________________________________________________________
221 TVector2*
222 AliFMDRing::GetHybridVertex(Int_t i) const
223 {
224   // Get the i'th vertex of polygon shape
225   // 
226   // the polygon shape describes the shape of the rings' hybrid cards
227   // 
228   // Parameters: 
229   //     i    The vertex number to get (from 0 to 5)
230   return static_cast<TVector2*>(fHybridVerticies.At(i));
231 }
232
233 //____________________________________________________________________
234 TVector2*
235 AliFMDRing::GetFootPosition(Int_t i) const
236 {
237   // Get the i'th vertex of polygon shape
238   // 
239   // The feet are attached to the hybrid cards
240   // 
241   // Parameters: 
242   //     i    The foot number to get (from 0 to 2)
243   return static_cast<TVector2*>(fFeetPositions.At(i));
244 }
245
246 //____________________________________________________________________
247 Double_t
248 AliFMDRing::GetStripRadius(UShort_t strip) const
249 {
250   // Return the nominal strip radius 
251   // 
252   // Parameter 
253   //   strip    Strip number (0-511 for inners, 0-255 for outers)
254   Double_t rmax     = GetMaxR();
255   Double_t stripoff = GetMinR();
256   Double_t dstrip   = (rmax - stripoff) / GetNStrips();
257   return (strip + .5) * dstrip + stripoff; // fLowR
258 }
259  
260 //____________________________________________________________________
261 Double_t
262 AliFMDRing::GetModuleDepth() const
263 {
264   // Get the total depth of a module (sensor + hybrid card) 
265   // 
266   // The depth is the sum of 
267   // 
268   //   The silicon thickness 
269   //   The thickness of spacers between the silicon and hybrid
270   //   The thickness of the hybrid PCB
271   //   The thickness of the copper layer in the PCB
272   //   The thickness of the chip layer in the PCB
273   //   The height of the legs
274   return (GetSiThickness() 
275           + GetSpacing() 
276           + GetPrintboardThickness()
277           + GetCopperThickness()
278           + GetChipThickness()
279           + GetLegLength());
280   
281 }
282
283 //____________________________________________________________________
284 Double_t
285 AliFMDRing::GetFullDepth() const
286 {
287   // Get the full depth of this ring, including the honeycomb, 
288   // digitizer and card. 
289   return (GetModuleDepth() 
290           + GetModuleSpacing()
291           + GetHoneycombThickness()
292           + GetFMDDPrintboardThickness()
293           + GetFMDDCopperThickness()
294           + GetFMDDChipThickness() 
295           + 0.5);
296 }
297
298 //____________________________________________________________________
299 void
300 AliFMDRing::Detector2XYZ(UShort_t sector,
301                          UShort_t strip, 
302                          Double_t& x, 
303                          Double_t& y, 
304                          Double_t& z) const
305 {
306   // Translate detector coordinates (this,sector,strip) to global
307   // coordinates (x,y,z)
308   // 
309   // Parameters 
310   //    sector        Sector number in this ring 
311   //    strip         Strip number in this ring 
312   //    x             On return, the global X coordinate
313   //    y             On return, the global Y coordinate 
314   //    z             On return, the z coordinate in the ring plane 
315   //
316   // The ring plane is the plane half way between the two sensor
317   // layers. 
318   if (sector >= GetNSectors()) {
319     Error("Detector2XYZ", "Invalid sector number %d (>=%d) in ring %c", 
320           sector, GetNSectors(), fId);
321     return;
322   }
323   if (strip >= GetNStrips()) {
324     Error("Detector2XYZ", "Invalid strip number %d (>=%d) for ring type '%c'", 
325           strip, GetNStrips(), fId);
326     return;
327   }
328   Double_t phi = Float_t(sector + .5) / GetNSectors() * 2 * TMath::Pi();
329   Double_t r   = Float_t(strip + .5) / GetNStrips() * (fHighR - fLowR) + fLowR;
330   x = r * TMath::Cos(phi);
331   y = r * TMath::Sin(phi);
332   if (((sector / 2) % 2) == 1) 
333     z += TMath::Sign(fModuleSpacing, z);
334 }
335
336 //____________________________________________________________________
337 Bool_t
338 AliFMDRing::XYZ2Detector(Double_t  x, 
339                          Double_t  y, 
340                          Double_t  z,
341                          UShort_t& sector,
342                          UShort_t& strip) const
343 {
344   // Translate global coordinates (x,y,z) to detector coordinates
345   // (this,sector,strip)
346   // 
347   //  Parameters: 
348   //     x       Global x coordinate 
349   //     y       Global y coordinate
350   //     z       Global y coordinate
351   //     sector  On return, the sector number in this ring
352   //     strip   On return, the strip number in this ring
353   // 
354   sector = strip = 0;
355   Double_t r = TMath::Sqrt(x * x + y * y);
356   Int_t str = Int_t((r - fMinR) / GetPitch());
357   if (str < 0 || str >= GetNStrips()) return kFALSE;
358
359   Double_t phi = TMath::ATan2(y, x) * 180. / TMath::Pi();
360   if (phi < 0) phi = 360. + phi;
361   Int_t sec = Int_t(phi / fTheta);
362   if (sec < 0 || sec >= GetNSectors()) return kFALSE;
363   if ((sec / 2) % 2 == 1) {
364     if (TMath::Abs(z - TMath::Sign(fModuleSpacing, z)) >= 0.01)
365       return kFALSE;
366   }
367   else if (TMath::Abs(z) >= 0.01) return kFALSE;
368
369   strip  = str;
370   sector = sec;
371   return kTRUE;
372 }
373 //____________________________________________________________________
374 Float_t 
375 AliFMDRing::GetStripLength(UShort_t strip) const 
376 {
377   // Get the length of a strip 
378   // 
379   // Parameters:
380   //   strip     Strip number (0-511 for inners, 0-255 for outers)
381   // 
382   if(strip >= GetNStrips())
383     Error("GetStripLength", "Invalid strip number %d (>=%d) for ring type %c", 
384           strip, GetNStrips(), fId);
385   
386   Float_t rad        = GetMaxR()-GetMinR();
387   
388   Float_t segment    = rad / GetNStrips();
389   
390   TVector2* corner1  = GetVertex(2);  
391   TVector2* corner2  = GetVertex(3);
392   
393   Float_t slope      = ((corner1->Y() - corner2->Y()) / 
394                         (corner1->X() - corner2->X()));
395   Float_t constant   = ((corner2->Y() * corner1->X() - 
396                          (corner2->X()*corner1->Y())) / 
397                         (corner1->X() - corner2->X()));
398   Float_t radius     = GetMinR() + strip*segment;
399   
400   Float_t d          = (TMath::Power(TMath::Abs(radius*slope),2) + 
401                         TMath::Power(radius,2) - TMath::Power(constant,2));
402   
403   Float_t arclength  = GetBaseStripLength(strip);
404   if(d>0) {
405     Float_t x        = ((-1 * TMath::Sqrt(d) -slope*constant) / 
406                         (1 + TMath::Power(slope,2)));
407     Float_t y        = slope*x + constant;
408     Float_t theta    = TMath::ATan2(x,y);
409     
410     if(x < corner1->X() && y > corner1->Y()) {
411       //One sector since theta is by definition half-hybrid
412       arclength = radius*theta;
413     }
414   }
415   
416   return arclength;
417   
418   
419 }
420 //____________________________________________________________________
421 Float_t 
422 AliFMDRing::GetBaseStripLength(UShort_t strip) const 
423 {  
424   // Get the basic strip length 
425   // 
426   // Parameters:
427   //   strip    Strip number
428   Float_t rad             = GetMaxR()-GetMinR();
429   Float_t segment         = rad / GetNStrips();
430   Float_t basearc         = 2*TMath::Pi() / (0.5*GetNSectors()); 
431   Float_t radius          = GetMinR() + strip*segment;
432   Float_t basearclength   = 0.5*basearc * radius;                
433   
434   return basearclength;
435 }
436 //
437 // EOF
438 //