Added two missing includes to allow macro compilation (thanks to Laurent for remarkin...
[u/mrichter/AliRoot.git] / ITS / AliITSgeomSSD.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 Strip Detector, SSD, specific geometry.
20 // It is being replaced by AliITSsegmentationSSD class. This file also
21 // constains classes derived from AliITSgeomSSD which do nothing but
22 // initilize this one with predefined values.
23 ////////////////////////////////////////////////////////////////////////
24
25 #include <stdlib.h>
26
27 #include <Riostream.h>
28 #include <TBRIK.h>
29 #include <TMath.h>
30 #include <TShape.h>
31
32 #include "AliITSgeomSSD.h"
33
34 ClassImp(AliITSgeomSSD)
35
36
37 AliITSgeomSSD::AliITSgeomSSD():
38 TObject(),
39 fName(),
40 fTitle(),
41 fMat(),
42 fDx(0.0),
43 fDy(0.0),
44 fDz(0.0),
45 fNp(0),
46 fNn(0),
47 fLowEdgeP(0),
48 fLowEdgeN(0),
49 fAngleP(0.0),
50 fAngleN(0.0){
51 // Default constructor
52     fNp       = 0;
53     fNn       = 0;
54     fLowEdgeP = 0;
55     fLowEdgeN = 0;
56     fAngleP   = 0.0;
57     fAngleN   = 0.0;
58 }
59 //----------------------------------------------------------------------
60 AliITSgeomSSD::AliITSgeomSSD(const Float_t *box,Float_t ap,Float_t an,
61                              Int_t np,Float_t *p,Int_t nn,Float_t *n):
62 TObject(),
63 fName(),
64 fTitle(),
65 fMat(),
66 fDx(0.0),
67 fDy(0.0),
68 fDz(0.0),
69 fNp(0),
70 fNn(0),
71 fLowEdgeP(0),
72 fLowEdgeN(0),
73 fAngleP(0.0),
74 fAngleN(0.0){
75 ////////////////////////////////////////////////////////////////////////
76 //    Standard Constructor. *box={dx,dy,dz}, ap=anode angle, an=cathode angle,
77 // nn= number of cathodes+1,*n= array of cathode low edges+highest edge,
78 // np= number of anodes+1, *p= array of anode low edges+lighest edge.
79 ///////////////////////////////////////////////////////////////////////
80     fNp       = 0;
81     fNn       = 0;
82     fLowEdgeP = 0;
83     fLowEdgeN = 0;
84     fAngleP   = 0.0;
85     fAngleN   = 0.0;
86     ResetSSD(box,ap,an,np,p,nn,n);
87 }
88 //----------------------------------------------------------------------
89 void AliITSgeomSSD::ResetSSD(const Float_t *box,Float_t ap,Float_t an,
90                              Int_t np,Float_t *p,Int_t nn,Float_t *n){
91 ////////////////////////////////////////////////////////////////////////
92 //    Standard Filler. *box={dx,dy,dz}, ap=anode angle, an=cathode angle,
93 // nn= number of cathodes+1,*n= array of cathode low edges+highest edge,
94 // np= number of anodes+1, *p= array of anode low edges+lighest edge.
95 ///////////////////////////////////////////////////////////////////////
96     Int_t i;
97
98     fName = "ActiveSSD";
99     fTitle = "Active volume of SSD";
100     fMat = "SSD Si Det";
101     fDx  = box[0];
102     fDy  = box[1];
103     fDz  = box[2];
104     if(fLowEdgeP!=0) delete fLowEdgeP;
105     if(fLowEdgeN!=0) delete fLowEdgeN;
106     fNp = np;
107     fNn = nn;
108     fAngleP = ap;
109     fAngleN = an;
110     fLowEdgeP = new Float_t[fNp];
111     fLowEdgeN = new Float_t[fNn];
112     for(i=0;i<fNp;i++) fLowEdgeP[i] = p[i];
113     for(i=0;i<fNn;i++) fLowEdgeN[i] = n[i];
114 }
115 //______________________________________________________________________
116 AliITSgeomSSD::~AliITSgeomSSD(){
117     // Destructor.
118
119     if(fLowEdgeP) delete [] fLowEdgeP; fLowEdgeP = 0;
120     if(fLowEdgeN) delete [] fLowEdgeN; fLowEdgeN = 0;
121     fNp = 0;
122     fNn = 0;
123     fAngleP = 0.0;
124     fAngleN = 0.0;
125 }
126 //______________________________________________________________________
127 AliITSgeomSSD::AliITSgeomSSD(const AliITSgeomSSD &source) : TObject(source),
128 fName(source.fName),fTitle(source.fTitle),fMat(source.fMat),fDx(source.fDx),fDy(source.fDy),fDz(source.fDz),fNp(source.fNp),fNn(source.fNn),fLowEdgeP(0),fLowEdgeN(0),fAngleP(source.fAngleP),fAngleN(source.fAngleN){
129 ////////////////////////////////////////////////////////////////////////
130 //    copy  constructor
131 ////////////////////////////////////////////////////////////////////////
132     Int_t i;
133
134     fLowEdgeP = new Float_t[fNp];
135     fLowEdgeN = new Float_t[fNn];
136     for(i=0;i<fNp;i++) this->fLowEdgeP[i] = source.fLowEdgeP[i];
137     for(i=0;i<fNn;i++) this->fLowEdgeN[i] = source.fLowEdgeN[i];
138     return;
139 }  
140
141 AliITSgeomSSD& AliITSgeomSSD::operator=(const AliITSgeomSSD &source) {
142 ////////////////////////////////////////////////////////////////////////
143 //    assignment operator
144 ////////////////////////////////////////////////////////////////////////
145
146   this->~AliITSgeomSSD();
147   new(this) AliITSgeomSSD(source);
148   return *this;
149
150 }
151 //______________________________________________________________________
152 void AliITSgeomSSD::Local2Det(Float_t x,Float_t z,Int_t &a,Int_t &c){
153     // Given a GEANT detector local coordinate, cm, this function returns
154     // the detector specific P and N side strip numbers.
155     // Inputs are:
156     // Float_t x   Geant detector local x coordinate in cm
157     // Float_t z   Geant detector local z coordinate in cm
158     // outputs are:
159     // Int_t &a    Detector anode strip number (P side)
160     // Int_t &c    Detector cathode strip number (N side)
161     Float_t d,b;
162     Int_t i;
163
164     // project on to bonding edges.
165     d = x*TMath::Cos(fAngleP)+z*TMath::Sin(fAngleP);
166     b = x*TMath::Cos(fAngleN)+z*TMath::Sin(fAngleN);
167     if(d<fLowEdgeP[0]) i=-1;
168     else for(i=0;i<fNp;i++){
169         if(fLowEdgeP[i]<d) break;
170     } // end for i
171     a = i;
172     if(b<fLowEdgeN[0]) i=-1;
173     else for(i=0;i<fNn;i++){
174         if(fLowEdgeN[i]<b) break;
175     } // end for i
176     c = i;
177     return;
178 }
179 //______________________________________________________________________
180 void AliITSgeomSSD::Det2Local(Int_t a,Int_t c,Float_t &x,Float_t &z){
181 //    Float_t d,b;
182 //    Int_t i;
183     // use AliITSsegmentationSSD.
184
185     x=a;
186     z=c;
187     Error("Det2Locat","Use AliITSsegmentationSSD");
188     return;
189 }
190 //______________________________________________________________________
191 void AliITSgeomSSD::Print(ostream *os) const {
192 ////////////////////////////////////////////////////////////////////////
193 // Standard output format for this class.
194 ////////////////////////////////////////////////////////////////////////
195     Int_t i;
196 #if defined __GNUC__
197 #if __GNUC__ > 2
198     ios::fmtflags fmt;
199 #else
200     Int_t fmt;
201 #endif
202 #else
203 #if defined __ICC || defined __ECC || defined __xlC__
204     ios::fmtflags fmt;
205 #else
206     Int_t fmt;
207 #endif
208 #endif
209
210     fmt = os->setf(ios::scientific);  // set scientific floating point output
211     *os << "TBRIK" << " ";
212     *os << setprecision(16) << GetDx() << " ";
213     *os << setprecision(16) << GetDy() << " ";
214     *os << setprecision(16) << GetDz() << " ";
215     *os << fNp << " " << fNn << " ";
216     *os << setprecision(16) << fAngleP << " ";
217     *os << setprecision(16) << fAngleN << " ";
218     for(i=0;i<fNp;i++) *os << setprecision(16) << fLowEdgeP[i] << " ";
219     for(i=0;i<fNn;i++) *os << setprecision(16) << fLowEdgeN[i] << " ";
220     *os << endl;
221     os->flags(fmt); // reset back to old formating.
222     return;
223 }
224 //______________________________________________________________________
225 void AliITSgeomSSD::Read(istream *is){
226 ////////////////////////////////////////////////////////////////////////
227 // Standard input format for this class.
228 ////////////////////////////////////////////////////////////////////////
229     Int_t i;
230     char shp[20];
231
232     *is >> shp;
233     *is >> fDx >> fDy >> fDz;
234     *is >> fNp >> fNn;
235     *is >> fAngleP >> fAngleN;
236     if(fLowEdgeP !=0) delete fLowEdgeP;
237     if(fLowEdgeN !=0) delete fLowEdgeN;
238     fLowEdgeP = new Float_t[fNp];
239     fLowEdgeN = new Float_t[fNn];
240     for(i=0;i<fNp;i++) *is >> fLowEdgeP[i];
241     for(i=0;i<fNn;i++) *is >> fLowEdgeN[i];
242     return;
243 }
244 //----------------------------------------------------------------------
245 ostream &operator<<(ostream &os,AliITSgeomSSD &p){
246 ////////////////////////////////////////////////////////////////////////
247 // Standard output streaming function.
248 ////////////////////////////////////////////////////////////////////////
249
250     p.Print(&os);
251     return os;
252 }
253 //----------------------------------------------------------------------
254 istream &operator>>(istream &is,AliITSgeomSSD &r){
255 ////////////////////////////////////////////////////////////////////////
256 // Standard input streaming function.
257 ////////////////////////////////////////////////////////////////////////
258
259     r.Read(&is);
260     return is;
261 }
262 //======================================================================
263
264 ClassImp(AliITSgeomSSD175)
265
266 AliITSgeomSSD175::AliITSgeomSSD175() : AliITSgeomSSD(){
267 ////////////////////////////////////////////////////////////////////////
268 //    default constructor
269 ////////////////////////////////////////////////////////////////////////
270     const Float_t kDxyz[] ={3.6500,0.0150,2.000};//cm. (Geant 3.12 units)
271     // Size of sensitive detector area x,y(thickness),z
272     const Float_t kangle   = 0.0175; // angle in rad. of anode and cathodes
273     const Float_t kpitch   = 0.0095;// cm anode separation.
274     const Int_t   kNstrips = 768; // number of anode or cathode strips.
275     Float_t *leA,*leC; // array of low edges anode and cathorde.
276     Int_t i;
277
278     leA = new Float_t[kNstrips+1];
279     leC = new Float_t[kNstrips+1];
280     leA[0] = -kDxyz[0];
281     leA[1] = -kpitch*(0.5*kNstrips-1);
282     leC[0] =  kDxyz[0];
283     leC[1] =  kpitch*(0.5*kNstrips-1);
284     for(i=1;i<kNstrips;i++){
285         leA[i+1] = leA[i] + kpitch;
286         leC[i+1] = leC[i] - kpitch;
287     } // end for i
288     leA[kNstrips] =  kDxyz[0];
289     leC[kNstrips] = -kDxyz[0];
290     AliITSgeomSSD::ResetSSD(kDxyz,kangle,-kangle,
291                                  kNstrips+1,leA,kNstrips+1,leC);
292     delete leA;
293     delete leC;
294 }
295 //________________________________________________________________________
296 ostream &operator<<(ostream &os,AliITSgeomSSD175 &p){
297 ////////////////////////////////////////////////////////////////////////
298 // Standard output streaming function.
299 ////////////////////////////////////////////////////////////////////////
300
301     p.Print(&os);
302     return os;
303 }
304 //----------------------------------------------------------------------
305 istream &operator>>(istream &is,AliITSgeomSSD175 &r){
306 ////////////////////////////////////////////////////////////////////////
307 // Standard input streaming function.
308 ////////////////////////////////////////////////////////////////////////
309
310     r.Read(&is);
311     return is;
312 }
313 AliITSgeomSSD175& AliITSgeomSSD175::operator=(const AliITSgeomSSD175 &source) {
314 ////////////////////////////////////////////////////////////////////////
315 //    assignment operator
316 ////////////////////////////////////////////////////////////////////////
317   
318
319     if(this == &source) return *this;
320     Error("AliITSgeomSSD175","Not allowed to make a = with "
321           "AliITSgeomSSD175 Using default creater instead");
322
323     return *this;
324 }
325 //======================================================================
326
327 ClassImp(AliITSgeomSSD275and75)
328
329 AliITSgeomSSD275and75::AliITSgeomSSD275and75() : AliITSgeomSSD(){
330 ////////////////////////////////////////////////////////////////////////
331 //    default constructor
332 ////////////////////////////////////////////////////////////////////////
333 }
334 //----------------------------------------------------------------------
335 AliITSgeomSSD275and75::AliITSgeomSSD275and75(Int_t npar,Float_t *par) : 
336                                                             AliITSgeomSSD(){
337     // Default constructor for AliITSgeomSSD with strip angles of
338     // 275 miliradians and 75 miliradians. This constructor initlizes
339     // AliITSgeomSSD with the correct values. This is the miror image
340     // of the AliITSgeomSSD75and275 class.
341     const Float_t kDxyz[] ={3.6500,0.0150,2.000};//cm. (Geant 3.12 units)
342     // Size of sensitive detector area x,y(thickness),z
343     const Float_t kangleA  = 0.0275; // angle in rad. of anode and cathodes
344     const Float_t kangleC  = 0.0075; // angle in rad. of anode and cathodes
345     const Float_t kpitch   = 0.0095;// cm anode separation.
346     const Int_t   kNstrips = 768; // number of anode or cathode strips.
347     Float_t *leA,*leC; // array of low edges anode and cathorde.
348     Int_t i;
349
350     if(npar<3){
351         Error("AliITSgeomSSD275and75",
352               "npar=%d<3. array par must be [3] or larger.",npar);
353         return;
354     } // end if
355     leA = new Float_t[kNstrips+1];
356     leC = new Float_t[kNstrips+1];
357     leA[0] = -kDxyz[0];
358     leA[1] = -kpitch*(0.5*kNstrips-1);
359     leC[0] =  kDxyz[0];
360     leC[1] =  kpitch*(0.5*kNstrips-1);
361     for(i=1;i<kNstrips;i++){
362         leA[i+1] = leA[i] + kpitch;
363         leC[i+1] = leC[i] - kpitch;
364     } // end for i
365     leA[kNstrips] =  kDxyz[0];
366     leC[kNstrips] = -kDxyz[0];
367     AliITSgeomSSD::ResetSSD(par,kangleA,kangleC,
368                                  kNstrips+1,leA,kNstrips+1,leC);
369     delete [] leA;
370     delete [] leC;
371 }
372
373 //________________________________________________________________________
374 ostream &operator<<(ostream &os,AliITSgeomSSD275and75 &p){
375 ////////////////////////////////////////////////////////////////////////
376 // Standard output streaming function.
377 ////////////////////////////////////////////////////////////////////////
378
379     p.Print(&os);
380     return os;
381 }
382 //----------------------------------------------------------------------
383 istream &operator>>(istream &is,AliITSgeomSSD275and75 &r){
384 ////////////////////////////////////////////////////////////////////////
385 // Standard input streaming function.
386 ////////////////////////////////////////////////////////////////////////
387
388     r.Read(&is);
389     return is;
390 }
391 AliITSgeomSSD275and75& AliITSgeomSSD275and75::operator=(const AliITSgeomSSD275and75 &source) {
392 ////////////////////////////////////////////////////////////////////////
393 //    assignment operator
394 ////////////////////////////////////////////////////////////////////////
395   
396
397     if(this == &source) return *this;
398     Error("AliITSgeomSSD275and75","Not allowed to make a = with "
399           "AliITSgeomSSD275and75 Using default creater instead");
400
401     return *this;
402 }
403
404 //======================================================================
405
406 ClassImp(AliITSgeomSSD75and275)
407
408 AliITSgeomSSD75and275::AliITSgeomSSD75and275() : AliITSgeomSSD(){
409 ////////////////////////////////////////////////////////////////////////
410 //    default constructor
411 ////////////////////////////////////////////////////////////////////////
412 }
413 AliITSgeomSSD75and275::AliITSgeomSSD75and275(Int_t npar,Float_t *par) : 
414                                                             AliITSgeomSSD(){
415     // Default constructor for AliITSgeomSSD with strip angles of
416     // 75 miliradians and 275 miliradians. This constructor initlizes
417     // AliITSgeomSSD with the correct values. This is the miror image
418     // of the AliITSgeomSSD275and75 class.
419     const Float_t kDxyz[] ={3.6500,0.0150,2.000};//cm. (Geant 3.12 units)
420     // Size of sensitive detector area x,y(thickness),z
421     const Float_t kangleA  = 0.0075; // angle in rad. of anode and cathodes
422     const Float_t kangleC  = 0.0275; // angle in rad. of anode and cathodes
423     const Float_t kpitch   = 0.0095;// cm anode separation.
424     const Int_t   kNstrips = 768; // number of anode or cathode strips.
425     Float_t *leA,*leC; // array of low edges anode and cathorde.
426     Int_t i;
427
428     if(npar<3){
429         Error("AliITSgeomSSD75and275",
430               "npar=%d<3. array par must be [3] or larger.",npar);
431         return;
432     } // end if
433     leA = new Float_t[kNstrips+1];
434     leC = new Float_t[kNstrips+1];
435     leA[0] = -kDxyz[0];
436     leA[1] = -kpitch*(0.5*kNstrips-1);
437     leC[0] =  kDxyz[0];
438     leC[1] =  kpitch*(0.5*kNstrips-1);
439     for(i=1;i<kNstrips;i++){
440         leA[i+1] = leA[i] + kpitch;
441         leC[i+1] = leC[i] - kpitch;
442     } // end for i
443     leA[kNstrips] =  kDxyz[0];
444     leC[kNstrips] = -kDxyz[0];
445     AliITSgeomSSD::ResetSSD(par,kangleA,kangleC,
446                                  kNstrips+1,leA,kNstrips+1,leC);
447     delete leA;
448     delete leC;
449 }
450 //________________________________________________________________________
451 ostream &operator<<(ostream &os,AliITSgeomSSD75and275 &p){
452 ////////////////////////////////////////////////////////////////////////
453 // Standard output streaming function.
454 ////////////////////////////////////////////////////////////////////////
455
456     p.Print(&os);
457     return os;
458 }
459 //----------------------------------------------------------------------
460 istream &operator>>(istream &is,AliITSgeomSSD75and275 &r){
461 ////////////////////////////////////////////////////////////////////////
462 // Standard input streaming function.
463 ////////////////////////////////////////////////////////////////////////
464
465     r.Read(&is);
466     return is;
467 }
468 AliITSgeomSSD75and275& AliITSgeomSSD75and275::operator=(const AliITSgeomSSD75and275 &source) {
469 ////////////////////////////////////////////////////////////////////////
470 //    assignment operator
471 ////////////////////////////////////////////////////////////////////////
472   
473
474     if(this == &source) return *this;
475     Error("AliITSgeomSSD75and275","Not allowed to make a = with "
476           "AliITSgeomSSD75and275 Using default creater instead");
477
478     return *this;
479 }
480
481 //======================================================================