1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
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 **************************************************************************/
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 ////////////////////////////////////////////////////////////////////////
25 #include <Riostream.h>
30 #include "AliITSgeomSSD.h"
32 ClassImp(AliITSgeomSSD)
35 AliITSgeomSSD::AliITSgeomSSD(){
36 // Default constructor
45 //----------------------------------------------------------------------
46 AliITSgeomSSD::AliITSgeomSSD(const Float_t *box,Float_t ap,Float_t an,
47 Int_t np,Float_t *p,Int_t nn,Float_t *n){
48 ////////////////////////////////////////////////////////////////////////
49 // Standard Constructor. *box={dx,dy,dz}, ap=anode angle, an=cathode angle,
50 // nn= number of cathodes+1,*n= array of cathode low edges+highest edge,
51 // np= number of anodes+1, *p= array of anode low edges+lighest edge.
52 ///////////////////////////////////////////////////////////////////////
60 ResetSSD(box,ap,an,np,p,nn,n);
62 //----------------------------------------------------------------------
63 void AliITSgeomSSD::ResetSSD(const Float_t *box,Float_t ap,Float_t an,
64 Int_t np,Float_t *p,Int_t nn,Float_t *n){
65 ////////////////////////////////////////////////////////////////////////
66 // Standard Filler. *box={dx,dy,dz}, ap=anode angle, an=cathode angle,
67 // nn= number of cathodes+1,*n= array of cathode low edges+highest edge,
68 // np= number of anodes+1, *p= array of anode low edges+lighest edge.
69 ///////////////////////////////////////////////////////////////////////
72 fShapeSSD = new TBRIK("ActiveSSD","Active volume of SSD","SSD SI DET",
73 box[0],box[1],box[2]);
74 // if(fLowEdgeP!=0) delete fLowEdgeP;
75 // if(fLowEdgeN!=0) delete fLowEdgeN;
80 fLowEdgeP = new Float_t[fNp];
81 fLowEdgeN = new Float_t[fNn];
82 for(i=0;i<fNp;i++) fLowEdgeP[i] = p[i];
83 for(i=0;i<fNn;i++) fLowEdgeN[i] = n[i];
85 //______________________________________________________________________
86 AliITSgeomSSD::~AliITSgeomSSD(){
89 if(fLowEdgeP) delete [] fLowEdgeP; fLowEdgeP = 0;
90 if(fLowEdgeN) delete [] fLowEdgeN; fLowEdgeN = 0;
91 if(fShapeSSD) delete fShapeSSD; fShapeSSD = 0;
97 //______________________________________________________________________
98 AliITSgeomSSD::AliITSgeomSSD(const AliITSgeomSSD &source) : TObject(source){
99 ////////////////////////////////////////////////////////////////////////
101 ////////////////////////////////////////////////////////////////////////
104 if(this == &source) return;
105 this->fShapeSSD = new TBRIK(*(source.fShapeSSD));
106 this->fNp = source.fNp;
107 this->fNn = source.fNn;
110 this->fAngleP = source.fAngleP;
111 this->fAngleN = source.fAngleN;
112 fLowEdgeP = new Float_t[fNp];
113 fLowEdgeN = new Float_t[fNn];
114 for(i=0;i<fNp;i++) this->fLowEdgeP[i] = source.fLowEdgeP[i];
115 for(i=0;i<fNn;i++) this->fLowEdgeN[i] = source.fLowEdgeN[i];
119 AliITSgeomSSD& AliITSgeomSSD::operator=(const AliITSgeomSSD &source) {
120 ////////////////////////////////////////////////////////////////////////
121 // assignment operator
122 ////////////////////////////////////////////////////////////////////////
125 if(this == &source) return *this;
126 this->fShapeSSD = new TBRIK(*(source.fShapeSSD));
127 this->fNp = source.fNp;
128 this->fNn = source.fNn;
131 this->fAngleP = source.fAngleP;
132 this->fAngleN = source.fAngleN;
133 fLowEdgeP = new Float_t[fNp];
134 fLowEdgeN = new Float_t[fNn];
135 for(i=0;i<fNp;i++) this->fLowEdgeP[i] = source.fLowEdgeP[i];
136 for(i=0;i<fNn;i++) this->fLowEdgeN[i] = source.fLowEdgeN[i];
139 //______________________________________________________________________
140 void AliITSgeomSSD::Local2Det(Float_t x,Float_t z,Int_t &a,Int_t &c){
141 // Given a GEANT detector local coordinate, cm, this function returns
142 // the detector specific P and N side strip numbers.
144 // Float_t x Geant detector local x coordinate in cm
145 // Float_t z Geant detector local z coordinate in cm
147 // Int_t &a Detector anode strip number (P side)
148 // Int_t &c Detector cathode strip number (N side)
152 // project on to bonding edges.
153 d = x*TMath::Cos(fAngleP)+z*TMath::Sin(fAngleP);
154 b = x*TMath::Cos(fAngleN)+z*TMath::Sin(fAngleN);
155 if(d<fLowEdgeP[0]) i=-1;
156 else for(i=0;i<fNp;i++){
157 if(fLowEdgeP[i]<d) break;
160 if(b<fLowEdgeN[0]) i=-1;
161 else for(i=0;i<fNn;i++){
162 if(fLowEdgeN[i]<b) break;
167 //______________________________________________________________________
168 void AliITSgeomSSD::Det2Local(Int_t a,Int_t c,Float_t &x,Float_t &z){
171 // use AliITSsegmentationSSD.
175 Error("Det2Locat","Use AliITSsegmentationSSD");
178 //______________________________________________________________________
179 void AliITSgeomSSD::Print(ostream *os) const {
180 ////////////////////////////////////////////////////////////////////////
181 // Standard output format for this class.
182 ////////////////////////////////////////////////////////////////////////
191 #if defined __ICC || defined __ECC || defined __xlC__
198 fmt = os->setf(ios::scientific); // set scientific floating point output
199 *os << "TBRIK" << " ";
200 *os << setprecision(16) << GetDx() << " ";
201 *os << setprecision(16) << GetDy() << " ";
202 *os << setprecision(16) << GetDz() << " ";
203 *os << fNp << " " << fNn << " ";
204 *os << setprecision(16) << fAngleP << " ";
205 *os << setprecision(16) << fAngleN << " ";
206 for(i=0;i<fNp;i++) *os << setprecision(16) << fLowEdgeP[i] << " ";
207 for(i=0;i<fNn;i++) *os << setprecision(16) << fLowEdgeN[i] << " ";
209 os->flags(fmt); // reset back to old formating.
212 //______________________________________________________________________
213 void AliITSgeomSSD::Read(istream *is){
214 ////////////////////////////////////////////////////////////////////////
215 // Standard input format for this class.
216 ////////////////////////////////////////////////////////////////////////
222 *is >> dx >> dy >> dz;
223 if(fShapeSSD!=0) delete fShapeSSD;
224 fShapeSSD = new TBRIK("ActiveSSD","Active volume of SSD","SSD SI DET",
227 *is >> fAngleP >> fAngleN;
228 if(fLowEdgeP !=0) delete fLowEdgeP;
229 if(fLowEdgeN !=0) delete fLowEdgeN;
230 fLowEdgeP = new Float_t[fNp];
231 fLowEdgeN = new Float_t[fNn];
232 for(i=0;i<fNp;i++) *is >> fLowEdgeP[i];
233 for(i=0;i<fNn;i++) *is >> fLowEdgeN[i];
236 //----------------------------------------------------------------------
237 ostream &operator<<(ostream &os,AliITSgeomSSD &p){
238 ////////////////////////////////////////////////////////////////////////
239 // Standard output streaming function.
240 ////////////////////////////////////////////////////////////////////////
245 //----------------------------------------------------------------------
246 istream &operator>>(istream &is,AliITSgeomSSD &r){
247 ////////////////////////////////////////////////////////////////////////
248 // Standard input streaming function.
249 ////////////////////////////////////////////////////////////////////////
254 //======================================================================
256 ClassImp(AliITSgeomSSD175)
258 AliITSgeomSSD175::AliITSgeomSSD175() : AliITSgeomSSD(){
259 ////////////////////////////////////////////////////////////////////////
260 // default constructor
261 ////////////////////////////////////////////////////////////////////////
262 const Float_t kDxyz[] ={3.6500,0.0150,2.000};//cm. (Geant 3.12 units)
263 // Size of sensitive detector area x,y(thickness),z
264 const Float_t kangle = 0.0175; // angle in rad. of anode and cathodes
265 const Float_t kpitch = 0.0095;// cm anode separation.
266 const Int_t kNstrips = 768; // number of anode or cathode strips.
267 Float_t *leA,*leC; // array of low edges anode and cathorde.
270 leA = new Float_t[kNstrips+1];
271 leC = new Float_t[kNstrips+1];
273 leA[1] = -kpitch*(0.5*kNstrips-1);
275 leC[1] = kpitch*(0.5*kNstrips-1);
276 for(i=1;i<kNstrips;i++){
277 leA[i+1] = leA[i] + kpitch;
278 leC[i+1] = leC[i] - kpitch;
280 leA[kNstrips] = kDxyz[0];
281 leC[kNstrips] = -kDxyz[0];
282 // cout << "AliITSgeomSSD175 default creator called: start" << endl;
283 AliITSgeomSSD::ResetSSD(kDxyz,kangle,-kangle,
284 kNstrips+1,leA,kNstrips+1,leC);
287 // cout << "AliITSgeomSSD175 default creator called: end" << endl;
289 //________________________________________________________________________
290 ostream &operator<<(ostream &os,AliITSgeomSSD175 &p){
291 ////////////////////////////////////////////////////////////////////////
292 // Standard output streaming function.
293 ////////////////////////////////////////////////////////////////////////
298 //----------------------------------------------------------------------
299 istream &operator>>(istream &is,AliITSgeomSSD175 &r){
300 ////////////////////////////////////////////////////////////////////////
301 // Standard input streaming function.
302 ////////////////////////////////////////////////////////////////////////
307 AliITSgeomSSD& AliITSgeomSSD175::operator=(const AliITSgeomSSD &source) {
308 ////////////////////////////////////////////////////////////////////////
309 // assignment operator
310 ////////////////////////////////////////////////////////////////////////
313 if(this == &source) return *this;
314 Error("AliITSgeomSSD175","Not allowed to make a = with "
315 "AliITSgeomSSD175 Using default creater instead");
319 //======================================================================
321 ClassImp(AliITSgeomSSD275and75)
323 AliITSgeomSSD275and75::AliITSgeomSSD275and75() : AliITSgeomSSD(){
324 ////////////////////////////////////////////////////////////////////////
325 // default constructor
326 ////////////////////////////////////////////////////////////////////////
328 //----------------------------------------------------------------------
329 AliITSgeomSSD275and75::AliITSgeomSSD275and75(Int_t npar,Float_t *par) :
331 // Default constructor for AliITSgeomSSD with strip angles of
332 // 275 miliradians and 75 miliradians. This constructor initlizes
333 // AliITSgeomSSD with the correct values. This is the miror image
334 // of the AliITSgeomSSD75and275 class.
335 const Float_t kDxyz[] ={3.6500,0.0150,2.000};//cm. (Geant 3.12 units)
336 // Size of sensitive detector area x,y(thickness),z
337 const Float_t kangleA = 0.0275; // angle in rad. of anode and cathodes
338 const Float_t kangleC = 0.0075; // angle in rad. of anode and cathodes
339 const Float_t kpitch = 0.0095;// cm anode separation.
340 const Int_t kNstrips = 768; // number of anode or cathode strips.
341 Float_t *leA,*leC; // array of low edges anode and cathorde.
345 Error("AliITSgeomSSD275and75",
346 "npar=%d<3. array par must be [3] or larger.",npar);
349 leA = new Float_t[kNstrips+1];
350 leC = new Float_t[kNstrips+1];
352 leA[1] = -kpitch*(0.5*kNstrips-1);
354 leC[1] = kpitch*(0.5*kNstrips-1);
355 for(i=1;i<kNstrips;i++){
356 leA[i+1] = leA[i] + kpitch;
357 leC[i+1] = leC[i] - kpitch;
359 leA[kNstrips] = kDxyz[0];
360 leC[kNstrips] = -kDxyz[0];
361 // cout << "AliITSgeomSSD275and75 default creator called: start" << endl;
362 AliITSgeomSSD::ResetSSD(par,kangleA,kangleC,
363 kNstrips+1,leA,kNstrips+1,leC);
366 // cout << "AliITSgeomSSD275and75 default creator called: end" << endl;
368 //________________________________________________________________________
369 ostream &operator<<(ostream &os,AliITSgeomSSD275and75 &p){
370 ////////////////////////////////////////////////////////////////////////
371 // Standard output streaming function.
372 ////////////////////////////////////////////////////////////////////////
377 //----------------------------------------------------------------------
378 istream &operator>>(istream &is,AliITSgeomSSD275and75 &r){
379 ////////////////////////////////////////////////////////////////////////
380 // Standard input streaming function.
381 ////////////////////////////////////////////////////////////////////////
386 AliITSgeomSSD& AliITSgeomSSD275and75::operator=(const AliITSgeomSSD &source) {
387 ////////////////////////////////////////////////////////////////////////
388 // assignment operator
389 ////////////////////////////////////////////////////////////////////////
392 if(this == &source) return *this;
393 Error("AliITSgeomSSD275and75","Not allowed to make a = with "
394 "AliITSgeomSSD275and75 Using default creater instead");
399 //======================================================================
401 ClassImp(AliITSgeomSSD75and275)
403 AliITSgeomSSD75and275::AliITSgeomSSD75and275() : AliITSgeomSSD(){
404 ////////////////////////////////////////////////////////////////////////
405 // default constructor
406 ////////////////////////////////////////////////////////////////////////
408 AliITSgeomSSD75and275::AliITSgeomSSD75and275(Int_t npar,Float_t *par) :
410 // Default constructor for AliITSgeomSSD with strip angles of
411 // 75 miliradians and 275 miliradians. This constructor initlizes
412 // AliITSgeomSSD with the correct values. This is the miror image
413 // of the AliITSgeomSSD275and75 class.
414 const Float_t kDxyz[] ={3.6500,0.0150,2.000};//cm. (Geant 3.12 units)
415 // Size of sensitive detector area x,y(thickness),z
416 const Float_t kangleA = 0.0075; // angle in rad. of anode and cathodes
417 const Float_t kangleC = 0.0275; // angle in rad. of anode and cathodes
418 const Float_t kpitch = 0.0095;// cm anode separation.
419 const Int_t kNstrips = 768; // number of anode or cathode strips.
420 Float_t *leA,*leC; // array of low edges anode and cathorde.
424 Error("AliITSgeomSSD75and275",
425 "npar=%d<3. array par must be [3] or larger.",npar);
428 leA = new Float_t[kNstrips+1];
429 leC = new Float_t[kNstrips+1];
431 leA[1] = -kpitch*(0.5*kNstrips-1);
433 leC[1] = kpitch*(0.5*kNstrips-1);
434 for(i=1;i<kNstrips;i++){
435 leA[i+1] = leA[i] + kpitch;
436 leC[i+1] = leC[i] - kpitch;
438 leA[kNstrips] = kDxyz[0];
439 leC[kNstrips] = -kDxyz[0];
440 // cout << "AliITSgeomSSD275and75 default creator called: start" << endl;
441 AliITSgeomSSD::ResetSSD(par,kangleA,kangleC,
442 kNstrips+1,leA,kNstrips+1,leC);
445 // cout << "AliITSgeomSSD275and75 default creator called: end" << endl;
447 //________________________________________________________________________
448 ostream &operator<<(ostream &os,AliITSgeomSSD75and275 &p){
449 ////////////////////////////////////////////////////////////////////////
450 // Standard output streaming function.
451 ////////////////////////////////////////////////////////////////////////
456 //----------------------------------------------------------------------
457 istream &operator>>(istream &is,AliITSgeomSSD75and275 &r){
458 ////////////////////////////////////////////////////////////////////////
459 // Standard input streaming function.
460 ////////////////////////////////////////////////////////////////////////
465 AliITSgeomSSD& AliITSgeomSSD75and275::operator=(const AliITSgeomSSD &source) {
466 ////////////////////////////////////////////////////////////////////////
467 // assignment operator
468 ////////////////////////////////////////////////////////////////////////
471 if(this == &source) return *this;
472 Error("AliITSgeomSSD75and275","Not allowed to make a = with "
473 "AliITSgeomSSD75and275 Using default creater instead");
478 //======================================================================