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