Flag for xlC compiler on MacOSX
[u/mrichter/AliRoot.git] / ITS / AliITSgeomSPD.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 // This class is for the Silicon Pixel Detector, SPD, specific geometry.
20 // It is being replaced by AliITSsegmentationSPD class. This file also
21 // constains classes derived from AliITSgeomSPD which do nothing but
22 // initilize this one with predefined values.
23 ////////////////////////////////////////////////////////////////////////
24
25 #include <Riostream.h>
26 #include <TShape.h>
27 #include <TMath.h>
28
29 #include "AliITSgeomSPD.h"
30
31 ClassImp(AliITSgeomSPD)
32
33 AliITSgeomSPD::AliITSgeomSPD(){
34 // Default Constructor. Set everthing to null.
35
36     fShapeSPD    = 0;
37     fNbinx       = 0;
38     fNbinz       = 0;
39     fLowBinEdgeX = 0;
40     fLowBinEdgeZ = 0;
41 }
42 //______________________________________________________________________
43 AliITSgeomSPD::AliITSgeomSPD(Float_t dy,Int_t nx,Float_t *bx,
44                              Int_t nz,Float_t *bz){
45 // Standard Constructor. Set everthing to null.
46
47     fShapeSPD    = 0;
48     fNbinx       = 0;
49     fNbinz       = 0;
50     fLowBinEdgeX = 0;
51     fLowBinEdgeZ = 0;
52     ReSetBins(dy,nx,bx,nz,bz);
53     return;
54 }
55 //______________________________________________________________________
56 void AliITSgeomSPD::ReSetBins(Float_t dy,Int_t nx,Float_t *bx,
57                               Int_t nz,Float_t *bz){
58 // delets the contents of this and replaces it with the given values.
59     Int_t i;
60     Float_t dx = 0.0, dz = 0.0;
61
62     // Compute size in x and z (based on bins).
63     for(i=0;i<nx;i++) dx += bx[i];
64     for(i=0;i<nz;i++) dz += bz[i];
65     dx *= 0.5;
66     dz *= 0.5;
67
68     delete fShapeSPD; // delete existing shape
69     if(this->fLowBinEdgeX) delete[] this->fLowBinEdgeX; // delete existing
70     if(this->fLowBinEdgeZ) delete[] this->fLowBinEdgeZ; // delete existing
71
72     SetNbinX(nx);
73     SetNbinZ(nz);
74     InitLowBinEdgeX();
75     InitLowBinEdgeZ();
76     fLowBinEdgeX[0] = -dx;
77     fLowBinEdgeZ[0] = -dz;
78     for(i=0;i<nx;i++) fLowBinEdgeX[i+1] = fLowBinEdgeX[i] + bx[i];
79     for(i=0;i<nz;i++) fLowBinEdgeZ[i+1] = fLowBinEdgeZ[i] + bz[i];
80     SetShape("ActiveSPD","Active volume of SPD","SPD SI DET",dx,dy,dz);
81     return;
82 }
83 //______________________________________________________________________
84 AliITSgeomSPD::AliITSgeomSPD(AliITSgeomSPD &source) : TObject(source){
85     // Copy constructor
86
87     *this = source; // just use the = operator for now.
88     return;
89 }
90 //______________________________________________________________________
91 AliITSgeomSPD& AliITSgeomSPD::operator=(AliITSgeomSPD &source){
92     // = operator
93     Int_t i;
94
95     if(&source == this) return *this;
96     this->fShapeSPD = new TBRIK(*(source.fShapeSPD));
97     if(this->fLowBinEdgeX) delete[] this->fLowBinEdgeX;
98     if(this->fLowBinEdgeZ) delete[] this->fLowBinEdgeZ;
99     this->fNbinx = source.fNbinx;
100     this->fNbinz = source.fNbinz;
101     this->InitLowBinEdgeX();
102     this->InitLowBinEdgeZ();
103     for(i=0;i<fNbinx;i++) this->fLowBinEdgeX[i] = source.fLowBinEdgeX[i];
104     for(i=0;i<fNbinz;i++) this->fLowBinEdgeZ[i] = source.fLowBinEdgeZ[i];
105     return *this;
106 }
107 //______________________________________________________________________
108 AliITSgeomSPD::~AliITSgeomSPD(){
109 // Destructor
110
111     delete fShapeSPD;
112     if(this->fLowBinEdgeX) delete[] this->fLowBinEdgeX;
113     if(this->fLowBinEdgeZ) delete[] this->fLowBinEdgeZ;
114     fShapeSPD    = 0;
115     fNbinx       = 0;
116     fNbinz       = 0;
117     fLowBinEdgeX = 0;
118     fLowBinEdgeZ = 0;
119 }
120 //______________________________________________________________________
121 void AliITSgeomSPD::LToDet(Float_t xl,Float_t zl,Int_t &row,Int_t &col){
122 // Returns the row and column pixel numbers for a given local coordinate
123 // system. If they are outside then it will return -1 or fNbinx/z.
124     Int_t i;
125
126     if(xl<fLowBinEdgeX[0]) row = -1;
127     else{
128         for(i=0;i<fNbinx;i++) if(xl<=fLowBinEdgeX[i]) break;
129         row = i;
130     } //end if too low.
131     if(zl<fLowBinEdgeX[0]) col = -1;
132     else{
133         for(i=0;i<fNbinz;i++) if(zl<=fLowBinEdgeZ[i]) break;
134         col = i;
135     } //end if too low.
136     return;
137 }
138 //______________________________________________________________________
139 void AliITSgeomSPD::DetToL(Int_t row,Int_t col,Float_t &xl,Float_t &zl){
140 // returns the pixel center local coordinate system location for a given
141 // row and column number. It the row or column number is outside of the 
142 // defined range then it will return the nearest detector edge.
143
144     if(row>=0||row<fNbinx-1) xl = 0.5*(fLowBinEdgeX[row]+fLowBinEdgeX[row+1]);
145     else if(row<0) xl = fLowBinEdgeX[0];else xl = fLowBinEdgeX[fNbinx-1];
146     if(col>=0||col<fNbinz-1) zl = 0.5*(fLowBinEdgeZ[col]+fLowBinEdgeZ[col+1]);
147     else if(col<0) zl = fLowBinEdgeZ[0];else zl = fLowBinEdgeZ[fNbinz-1];
148     return;
149 }
150 //______________________________________________________________________
151 void AliITSgeomSPD::Print(ostream *os) const {
152 // Standard output format for this class
153     Int_t i;
154 #if defined __GNUC__
155 #if __GNUC__ > 2
156     ios::fmtflags fmt;
157 #else
158     Int_t fmt;
159 #endif
160 #else
161 #if defined __ICC || defined __ECC || defined _xlc_
162     ios::fmtflags fmt;
163 #else
164     Int_t fmt;
165 #endif
166 #endif
167
168     fmt = os->setf(ios::scientific); // set scientific floating point output
169     *os << "TBRIK" << " ";
170     *os << setprecision(16) << GetDx() << " ";
171     *os << setprecision(16) << GetDy() << " ";
172     *os << setprecision(16) << GetDz() << " ";
173     *os << fNbinx-1 << " " << fNbinz-1 << " ";
174     for(i=0;i<fNbinx;i++) *os << setprecision(16) << fLowBinEdgeX[i] << " ";
175     for(i=0;i<fNbinz;i++) *os << setprecision(16) << fLowBinEdgeZ[i] << " ";
176     *os << endl;
177     os->flags(fmt);
178     return;
179 }
180 //______________________________________________________________________
181 void AliITSgeomSPD::Read(istream *is){
182 // Standard input format for this class
183     Int_t i,j;
184     Float_t dx,dy,dz;
185     char shape[20];
186
187     for(i=0;i<20;i++) shape[i]='\0';
188     *is >> shape;
189     if(strcmp(shape,"TBRIK")) Warning("::Read","Shape not a TBRIK");
190     *is >> dx >> dy >> dz;
191     if(fShapeSPD!=0) delete fShapeSPD;
192     SetShape("ActiveSPD","Active volume of SPD","SPD SI DET",dx,dy,dz);
193     *is >> i >> j;
194     SetNbinX(i);
195     SetNbinZ(j);
196     InitLowBinEdgeX();
197     InitLowBinEdgeZ();
198     for(i=0;i<fNbinx;i++) *is >> fLowBinEdgeX[i];
199     for(i=0;i<fNbinz;i++) *is >> fLowBinEdgeZ[i];
200     return;
201 }
202 //----------------------------------------------------------------------
203 ostream &operator<<(ostream &os,AliITSgeomSPD &p){
204 ////////////////////////////////////////////////////////////////////////
205 // Standard output streaming function.
206 ////////////////////////////////////////////////////////////////////////
207
208     p.Print(&os);
209     return os;
210 }
211 //----------------------------------------------------------------------
212 istream &operator>>(istream &is,AliITSgeomSPD &r){
213 ////////////////////////////////////////////////////////////////////////
214 // Standard input streaming function.
215 ////////////////////////////////////////////////////////////////////////
216
217     r.Read(&is);
218     return is;
219 }
220 //=====================================================================
221
222 ClassImp(AliITSgeomSPD300)
223
224 AliITSgeomSPD300::AliITSgeomSPD300() : AliITSgeomSPD(){
225 ////////////////////////////////////////////////////////////////////////
226 //    default constructor, for ITS TDR geometry. This only consists of
227 // a default constructor to construct the defalut TDR SPD detector geometry
228 // 256 X 279 300 by 50 micron pixels.
229 ////////////////////////////////////////////////////////////////////////
230 const Float_t kdx=0.6400,kdy=0.0075,kdz=4.1900; // cm; Standard pixel detector
231                                                 // size is 2dx wide, 2dz long,
232                                                 // and 2dy thick. Geant 3.12
233                                                 // units.
234 const Float_t kbinx0 = 0.0050; // cm; Standard pixel size in x direction.
235 const Int_t   knbinx = 256;    // number of pixels along x direction.
236 const Float_t kbinz0 = 0.0300; // cm; Standard pixel size in z direction.
237 const Float_t kbinz1 = 0.0350; // cm; Edge pixel size in z direction.
238 const Int_t   knbinz = 279;    // number of pixels along z direction.
239     Int_t i;
240     Float_t dx=0.0,dz=0.0;
241
242 //    cout << "AliITSgeomSPD300 default creator called: start" << endl;
243
244     SetNbinX(knbinx); // default number of bins in x.
245     SetNbinZ(knbinz); // default number of bins in z.
246
247     for(i=0;i<knbinx;i++) dx += kbinx0; // Compute size x.
248     dx *= 0.5;
249     for(i=0;i<knbinz;i++) dz += kbinz0; // Compute size z.
250     dz += 2.0*(kbinz1-kbinz0);
251     dz *= 0.5;
252     InitLowBinEdgeX();
253     InitLowBinEdgeZ();
254     SetLowBinEdgeX(0,-dx); // Starting position X
255     for(i=0;i<knbinx;i++) SetLowBinEdgeX(i+1,GetBinLowEdgeX(i)+kbinx0);
256     SetLowBinEdgeZ(0,-dz); // Starting position z
257     SetLowBinEdgeZ(1,GetBinLowEdgeZ(0)+kbinz1);
258     for(i=1;i<knbinz;i++) SetLowBinEdgeZ(i+1,GetBinLowEdgeZ(i)+kbinz0);
259     SetLowBinEdgeZ(knbinz,GetBinLowEdgeZ(knbinz-1)+kbinz1);
260
261     if(TMath::Abs(dx-kdx)>1.0E-4 || TMath::Abs(dz-kdz)>1.0E-4) 
262         Warning("Default Creator","Detector size may not be write.");
263     SetShape("ActiveSPD","Active volume of SPD","SPD SI DET",dx,kdy,dz);
264 //    cout << "AliITSgeomSPD300 default creator called: end" << endl;
265 }
266 //----------------------------------------------------------------------
267 ostream &operator<<(ostream &os,AliITSgeomSPD300 &p){
268 ////////////////////////////////////////////////////////////////////////
269 // Standard output streaming function.
270 ////////////////////////////////////////////////////////////////////////
271
272     p.Print(&os);
273     return os;
274 }
275 //----------------------------------------------------------------------
276 istream &operator>>(istream &is,AliITSgeomSPD300 &r){
277 ////////////////////////////////////////////////////////////////////////
278 // Standard input streaming function.
279 ////////////////////////////////////////////////////////////////////////
280
281     r.Read(&is);
282     return is;
283 }
284 //=====================================================================
285
286 ClassImp(AliITSgeomSPD425Short)
287
288 AliITSgeomSPD425Short::AliITSgeomSPD425Short() : AliITSgeomSPD(){
289 ////////////////////////////////////////////////////////////////////////
290 //    default constructor, for ITS post TDR geometry. This only consists of
291 // a default constructor to construct the defalut post TDR SPD detector 
292 // geometry 256 X 197 425 by 50 micron pixels with interleaved 625 by 50
293 // micron pixels (large detector).
294 ////////////////////////////////////////////////////////////////////////
295 }
296 //----------------------------------------------------------------------
297 AliITSgeomSPD425Short::AliITSgeomSPD425Short(Int_t npar,Float_t *par) :
298                                                               AliITSgeomSPD(){
299 ////////////////////////////////////////////////////////////////////////
300 //    Standard constructor, for ITS post TDR geometry. This only consists of
301 // a default constructor to construct the defalut post TDR SPD detector 
302 // geometry 256 X 197 425 by 50 micron pixels with interleaved 625 by 50
303 // micron pixels (large detector).
304 ////////////////////////////////////////////////////////////////////////
305
306     const Float_t kdx=0.6400/*,kdy=0.015*/,kdz=3.480; // cm; Standard pixel
307                                                       // detector size is 2dx
308                                                       //  wide, 2dz long, and
309                                                       //  2dy thick. Geant 3.12
310                                                       // units.
311     const Float_t kbinx0 = 0.0050; // cm; Standard pixel size in x direction.
312     const Int_t   knbinx = 256;    // number of pixels along x direction.
313     const Float_t kbinz0 = 0.0425; // cm; Standard pixel size in z direction.
314     const Float_t kbinz1 = 0.0625; // cm; Special pixel size in z direction.
315     const Int_t   knbinz = 160;    // number of pixels along z direction.
316     Int_t i;
317     Float_t dx,dz,*binSizeX,*binSizeZ;
318
319     SetNbinX(knbinx); // default number of bins in x.
320     SetNbinZ(knbinz); // default number of bins in z.
321
322     binSizeX = new Float_t[knbinx]; // array of bin sizes along x.
323     for(i=0;i<knbinx;i++) binSizeX[i] = kbinx0; // default x bin size.
324     binSizeZ = new Float_t[knbinz]; // array of bin sizes along z.
325     for(i=0;i<knbinz;i++) binSizeZ[i] = kbinz0; // default z bin size.
326     binSizeZ[ 31] = kbinz1;
327     binSizeZ[ 32] = kbinz1;
328
329     binSizeZ[ 63] = kbinz1;
330     binSizeZ[ 64] = kbinz1;
331
332     binSizeZ[ 95] = kbinz1;
333     binSizeZ[ 96] = kbinz1;
334
335     binSizeZ[127] = kbinz1;
336     binSizeZ[128] = kbinz1;
337
338     // correct detector size for bin size.
339     dx = 0.0;
340     for(i=0;i<knbinx;i++) dx += binSizeX[i];
341     dx *= 0.5;
342     dz = 0.0;
343     for(i=0;i<knbinz;i++) dz += binSizeZ[i];
344     dz *= 0.5;
345
346     if(npar<3){
347         Error("AliITSgeomSPD425Short",
348               "npar=%d<3 array par must be at least [3] or larger",npar);
349         return;
350     } // end if
351     SetShape("ActiveSPD","Active volume of SPD","SPD SI DET",
352              par[0],par[1],par[2]);
353     if(TMath::Abs(dx-kdx)>1.0E-4 || TMath::Abs(dz-kdz)>1.0E-4) 
354         Warning("Default Creator","Detector size may not be write.");
355
356     InitLowBinEdgeX(); // array of bin sizes along x.
357     InitLowBinEdgeZ(); // array of bin sizes along x.
358     SetLowBinEdgeX(0,-dx);
359     SetLowBinEdgeZ(0,-dz);
360     for(i=0;i<knbinx;i++) SetLowBinEdgeX(i+1,GetBinLowEdgeX(i)+binSizeX[i]);
361     for(i=0;i<knbinz;i++) SetLowBinEdgeZ(i+1,GetBinLowEdgeZ(i)+binSizeZ[i]);
362 }
363 //----------------------------------------------------------------------
364 ostream &operator<<(ostream &os,AliITSgeomSPD425Short &p){
365 ////////////////////////////////////////////////////////////////////////
366 // Standard output streaming function.
367 ////////////////////////////////////////////////////////////////////////
368
369     p.Print(&os);
370     return os;
371 }
372 //----------------------------------------------------------------------
373 istream &operator>>(istream &is,AliITSgeomSPD425Short &r){
374 ////////////////////////////////////////////////////////////////////////
375 // Standard input streaming function.
376 ////////////////////////////////////////////////////////////////////////
377
378     r.Read(&is);
379     return is;
380 }
381 //======================================================================
382
383 ClassImp(AliITSgeomSPD425Long)
384
385 AliITSgeomSPD425Long::AliITSgeomSPD425Long(){
386 ////////////////////////////////////////////////////////////////////////
387 //    default constructor, for ITS post TDR geometry. This only consists of
388 // a default constructor to construct the defalut post TDR SPD detector 
389 // geometry 256 X 197 425 by 50 micron pixels with interleaved 625 by 50
390 // micron pixels (large detector).
391 ////////////////////////////////////////////////////////////////////////
392
393     const Float_t kdx=0.6400,kdy=0.0075,kdz=4.2650; // cm; Standard pixel
394                                                     // detector size is 2dx
395                                                     //  wide, 2dz long, and
396                                                     //  2dy thick. Geant 3.12
397                                                     // units.
398     const Float_t kbinx0 = 0.0050; // cm; Standard pixel size in x direction.
399     const Int_t   knbinx = 256;    // number of pixels along x direction.
400     const Float_t kbinz0 = 0.0425; // cm; Standard pixel size in z direction.
401     const Float_t kbinz1 = 0.0625; // cm; Special pixel size in z direction.
402     const Int_t   knbinz = 192;    // number of pixels along z direction.
403     Int_t i;
404     Float_t dx,dz,*binSizeX,*binSizeZ;
405
406     SetNbinX(knbinx); // default number of bins in x.
407     SetNbinZ(knbinz); // default number of bins in z.
408
409     binSizeX = new Float_t[knbinx]; // array of bin sizes along x.
410     for(i=0;i<knbinx;i++) binSizeX[i] = kbinx0; // default x bin size.
411     binSizeZ = new Float_t[knbinz]; // array of bin sizes along z.
412     for(i=0;i<knbinz;i++) binSizeZ[i] = kbinz0; // default z bin size.
413     binSizeZ[ 31] = kbinz1;
414     binSizeZ[ 32] = kbinz1;
415
416     binSizeZ[ 63] = kbinz1;
417     binSizeZ[ 64] = kbinz1;
418
419     binSizeZ[ 95] = kbinz1;
420     binSizeZ[ 96] = kbinz1;
421
422     binSizeZ[127] = kbinz1;
423     binSizeZ[128] = kbinz1;
424
425     binSizeZ[159] = kbinz1;
426     binSizeZ[160] = kbinz1;
427
428     // correct detector size for bin size.
429     dx = 0.0;
430     for(i=0;i<knbinx;i++) dx += binSizeX[i];
431     dx *= 0.5;
432     dz = 0.0;
433     for(i=0;i<knbinz;i++) dz += binSizeZ[i];
434     dz *= 0.5;
435
436     SetShape("ActiveSPD","Active volume of SPD","SPD SI DET",dx,kdy,dz);
437     if(TMath::Abs(dx-kdx)>1.0E-4 || TMath::Abs(dz-kdz)>1.0E-4) 
438         Warning("Default Creator","Detector size may not be write.");
439
440     InitLowBinEdgeX(); // array of bin sizes along x.
441     InitLowBinEdgeZ(); // array of bin sizes along x.
442     SetLowBinEdgeX(0,-dx);
443     SetLowBinEdgeZ(0,-dz);
444     for(i=0;i<knbinx;i++) SetLowBinEdgeX(i+1,GetBinLowEdgeX(i)+binSizeX[i]);
445     for(i=0;i<knbinz;i++) SetLowBinEdgeZ(i+1,GetBinLowEdgeZ(i)+binSizeZ[i]);
446 }
447 //----------------------------------------------------------------------
448 ostream &operator<<(ostream &os,AliITSgeomSPD425Long &p){
449 ////////////////////////////////////////////////////////////////////////
450 // Standard output streaming function.
451 ////////////////////////////////////////////////////////////////////////
452
453     p.Print(&os);
454     return os;
455 }
456 //----------------------------------------------------------------------
457 istream &operator>>(istream &is,AliITSgeomSPD425Long &r){
458 ////////////////////////////////////////////////////////////////////////
459 // Standard input streaming function.
460 ////////////////////////////////////////////////////////////////////////
461
462     r.Read(&is);
463     return is;
464 }
465 //======================================================================