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 <Riostream.h>
  26 #include <stdlib.h>
  27 #include <TShape.h>
  28 #include <TBRIK.h>
  29
  30 #include "AliITSgeomSSD.h"
  31
  32 ClassImp(AliITSgeomSSD)
  33
  34
  35 AliITSgeomSSD::AliITSgeomSSD(){
  36 // Default constructor
  37     fShapeSSD = 0;
  38     fNp       = 0;
  39     fNn       = 0;
  40     fLowEdgeP = 0;
  41     fLowEdgeN = 0;
  42     fAngleP   = 0.0;
  43     fAngleN   = 0.0;
  44 }
  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 ///////////////////////////////////////////////////////////////////////
  53     fShapeSSD = 0;
  54     fNp       = 0;
  55     fNn       = 0;
  56     fLowEdgeP = 0;
  57     fLowEdgeN = 0;
  58     fAngleP   = 0.0;
  59     fAngleN   = 0.0;
  60     ResetSSD(box,ap,an,np,p,nn,n);
  61 }
  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 ///////////////////////////////////////////////////////////////////////
  70     Int_t i;
  71
  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;
  76     fNp = np;
  77     fNn = nn;
  78     fAngleP = ap;
  79     fAngleN = an;
  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];
  84 }
  85 //______________________________________________________________________
  86 AliITSgeomSSD::~AliITSgeomSSD(){
  87     // Destructor.
  88
  89     if(fLowEdgeP) delete [] fLowEdgeP; fLowEdgeP = 0;
  90     if(fLowEdgeN) delete [] fLowEdgeN; fLowEdgeN = 0;
  91     if(fShapeSSD) delete  fShapeSSD; fShapeSSD = 0;
  92     fNp = 0;
  93     fNn = 0;
  94     fAngleP = 0.0;
  95     fAngleN = 0.0;
  96 }
  97 AliITSgeomSSD::AliITSgeomSSD(const AliITSgeomSSD &source){
  98 ////////////////////////////////////////////////////////////////////////
  99 //    copy  constructor
 100 ////////////////////////////////////////////////////////////////////////
 101     Int_t i;
 102
 103     if(this == &source) return;
 104     this->fShapeSSD = new TBRIK(*(source.fShapeSSD));
 105     this->fNp = source.fNp;
 106     this->fNn = source.fNn;
 107     delete fLowEdgeP;
 108     delete fLowEdgeN;
 109     this->fAngleP = source.fAngleP;
 110     this->fAngleN = source.fAngleN;
 111     fLowEdgeP = new Float_t[fNp];
 112     fLowEdgeN = new Float_t[fNn];
 113     for(i=0;i<fNp;i++) this->fLowEdgeP[i] = source.fLowEdgeP[i];
 114     for(i=0;i<fNn;i++) this->fLowEdgeN[i] = source.fLowEdgeN[i];
 115     return;
 116 }
 117
 118 AliITSgeomSSD& AliITSgeomSSD::operator=(const AliITSgeomSSD &source) {
 119 ////////////////////////////////////////////////////////////////////////
 120 //    assignment operator
 121 ////////////////////////////////////////////////////////////////////////
 122     Int_t i;
 123
 124     if(this == &source) return *this;
 125     this->fShapeSSD = new TBRIK(*(source.fShapeSSD));
 126     this->fNp = source.fNp;
 127     this->fNn = source.fNn;
 128     delete fLowEdgeP;
 129     delete fLowEdgeN;
 130     this->fAngleP = source.fAngleP;
 131     this->fAngleN = source.fAngleN;
 132     fLowEdgeP = new Float_t[fNp];
 133     fLowEdgeN = new Float_t[fNn];
 134     for(i=0;i<fNp;i++) this->fLowEdgeP[i] = source.fLowEdgeP[i];
 135     for(i=0;i<fNn;i++) this->fLowEdgeN[i] = source.fLowEdgeN[i];
 136     return *this;
 137 }
 138 //______________________________________________________________________
 139 void AliITSgeomSSD::Local2Det(Float_t x,Float_t z,Int_t &a,Int_t &c){
 140     // Given a GEANT detector local coordinate, cm, this function returns
 141     // the detector specific P and N side strip numbers.
 142     // Inputs are:
 143     // Float_t x   Geant detector local x coordinate in cm
 144     // Float_t z   Geant detector local z coordinate in cm
 145     // outputs are:
 146     // Int_t &a    Detector anode strip number (P side)
 147     // Int_t &c    Detector cathode strip number (N side)
 148     Float_t d,b;
 149     Int_t i;
 150
 151     // project on to bonding edges.
 152     d = x*TMath::Cos(fAngleP)+z*TMath::Sin(fAngleP);
 153     b = x*TMath::Cos(fAngleN)+z*TMath::Sin(fAngleN);
 154     if(d<fLowEdgeP[0]) i=-1;
 155     else for(i=0;i<fNp;i++){
 156         if(fLowEdgeP[i]<d) break;
 157     } // end for i
 158     a = i;
 159     if(b<fLowEdgeN[0]) i=-1;
 160     else for(i=0;i<fNn;i++){
 161         if(fLowEdgeN[i]<b) break;
 162     } // end for i
 163     c = i;
 164     return;
 165 }
 166 //______________________________________________________________________
 167 void AliITSgeomSSD::Det2Local(Int_t a,Int_t c,Float_t &x,Float_t &z){
 168 //    Float_t d,b;
 169 //    Int_t i;
 170
 171     return;
 172 }
 173 //______________________________________________________________________
 174 void AliITSgeomSSD::Print(ostream *os) const {
 175 ////////////////////////////////////////////////////////////////////////
 176 // Standard output format for this class.
 177 ////////////////////////////////////////////////////////////////////////
 178     Int_t i;
 179 #if defined __GNUC__
 180 #if __GNUC__ > 2
 181     ios::fmtflags fmt;
 182 #else
 183     Int_t fmt;
 184 #endif
 185 #else
 186 #if defined __ICC || defined __ECC
 187     ios::fmtflags fmt;
 188 #else
 189     Int_t fmt;
 190 #endif
 191 #endif
 192
 193     fmt = os->setf(ios::scientific);  // set scientific floating point output
 194     *os << "TBRIK" << " ";
 195     *os << setprecision(16) << GetDx() << " ";
 196     *os << setprecision(16) << GetDy() << " ";
 197     *os << setprecision(16) << GetDz() << " ";
 198     *os << fNp << " " << fNn << " ";
 199     *os << setprecision(16) << fAngleP << " ";
 200     *os << setprecision(16) << fAngleN << " ";
 201     for(i=0;i<fNp;i++) *os << setprecision(16) << fLowEdgeP[i] << " ";
 202     for(i=0;i<fNn;i++) *os << setprecision(16) << fLowEdgeN[i] << " ";
 203     *os << endl;
 204     os->flags(fmt); // reset back to old formating.
 205     return;
 206 }
 207 //______________________________________________________________________
 208 void AliITSgeomSSD::Read(istream *is){
 209 ////////////////////////////////////////////////////////////////////////
 210 // Standard input format for this class.
 211 ////////////////////////////////////////////////////////////////////////
 212     Float_t dx,dy,dz;
 213     Int_t i;
 214     char shp[20];
 215
 216     *is >> shp;
 217     *is >> dx >> dy >> dz;
 218     if(fShapeSSD!=0) delete fShapeSSD;
 219     fShapeSSD = new TBRIK("ActiveSSD","Active volume of SSD","SSD SI DET",
 220                             dx,dy,dz);
 221     *is >> fNp >> fNn;
 222     *is >> fAngleP >> fAngleN;
 223     if(fLowEdgeP !=0) delete fLowEdgeP;
 224     if(fLowEdgeN !=0) delete fLowEdgeN;
 225     fLowEdgeP = new Float_t[fNp];
 226     fLowEdgeN = new Float_t[fNn];
 227     for(i=0;i<fNp;i++) *is >> fLowEdgeP[i];
 228     for(i=0;i<fNn;i++) *is >> fLowEdgeN[i];
 229     return;
 230 }
 231 //----------------------------------------------------------------------
 232 ostream &operator<<(ostream &os,AliITSgeomSSD &p){
 233 ////////////////////////////////////////////////////////////////////////
 234 // Standard output streaming function.
 235 ////////////////////////////////////////////////////////////////////////
 236
 237     p.Print(&os);
 238     return os;
 239 }
 240 //----------------------------------------------------------------------
 241 istream &operator>>(istream &is,AliITSgeomSSD &r){
 242 ////////////////////////////////////////////////////////////////////////
 243 // Standard input streaming function.
 244 ////////////////////////////////////////////////////////////////////////
 245
 246     r.Read(&is);
 247     return is;
 248 }
 249 //======================================================================
 250
 251 ClassImp(AliITSgeomSSD175)
 252
 253 AliITSgeomSSD175::AliITSgeomSSD175() : AliITSgeomSSD(){
 254 ////////////////////////////////////////////////////////////////////////
 255 //    default constructor
 256 ////////////////////////////////////////////////////////////////////////
 257     const Float_t kDxyz[] ={3.6500,0.0150,2.000};//cm. (Geant 3.12 units)
 258     // Size of sensitive detector area x,y(thickness),z
 259     const Float_t kangle   = 0.0175; // angle in rad. of anode and cathodes
 260     const Float_t kpitch   = 0.0095;// cm anode separation.
 261     const Int_t   kNstrips = 768; // number of anode or cathode strips.
 262     Float_t *leA,*leC; // array of low edges anode and cathorde.
 263     Int_t i;
 264
 265     leA = new Float_t[kNstrips+1];
 266     leC = new Float_t[kNstrips+1];
 267     leA[0] = -kDxyz[0];
 268     leA[1] = -kpitch*(0.5*kNstrips-1);
 269     leC[0] =  kDxyz[0];
 270     leC[1] =  kpitch*(0.5*kNstrips-1);
 271     for(i=1;i<kNstrips;i++){
 272         leA[i+1] = leA[i] + kpitch;
 273         leC[i+1] = leC[i] - kpitch;
 274     } // end for i
 275     leA[kNstrips] =  kDxyz[0];
 276     leC[kNstrips] = -kDxyz[0];
 277 //    cout << "AliITSgeomSSD175 default creator called: start" << endl;
 278     AliITSgeomSSD::ResetSSD(kDxyz,kangle,-kangle,
 279                                  kNstrips+1,leA,kNstrips+1,leC);
 280     delete leA;
 281     delete leC;
 282 //    cout << "AliITSgeomSSD175 default creator called: end" << endl;
 283 }
 284 //________________________________________________________________________
 285 ostream &operator<<(ostream &os,AliITSgeomSSD175 &p){
 286 ////////////////////////////////////////////////////////////////////////
 287 // Standard output streaming function.
 288 ////////////////////////////////////////////////////////////////////////
 289
 290     p.Print(&os);
 291     return os;
 292 }
 293 //----------------------------------------------------------------------
 294 istream &operator>>(istream &is,AliITSgeomSSD175 &r){
 295 ////////////////////////////////////////////////////////////////////////
 296 // Standard input streaming function.
 297 ////////////////////////////////////////////////////////////////////////
 298
 299     r.Read(&is);
 300     return is;
 301 }
 302 //======================================================================
 303
 304 ClassImp(AliITSgeomSSD275and75)
 305
 306 AliITSgeomSSD275and75::AliITSgeomSSD275and75() : AliITSgeomSSD(){
 307 ////////////////////////////////////////////////////////////////////////
 308 //    default constructor
 309 ////////////////////////////////////////////////////////////////////////
 310 }
 311 //----------------------------------------------------------------------
 312 AliITSgeomSSD275and75::AliITSgeomSSD275and75(Int_t npar,Float_t *par) :
 313                                                             AliITSgeomSSD(){
 314     // Default constructor for AliITSgeomSSD with strip angles of
 315     // 275 miliradians and 75 miliradians. This constructor initlizes
 316     // AliITSgeomSSD with the correct values. This is the miror image
 317     // of the AliITSgeomSSD75and275 class.
 318     const Float_t kDxyz[] ={3.6500,0.0150,2.000};//cm. (Geant 3.12 units)
 319     // Size of sensitive detector area x,y(thickness),z
 320     const Float_t kangleA  = 0.0275; // angle in rad. of anode and cathodes
 321     const Float_t kangleC  = 0.0075; // angle in rad. of anode and cathodes
 322     const Float_t kpitch   = 0.0095;// cm anode separation.
 323     const Int_t   kNstrips = 768; // number of anode or cathode strips.
 324     Float_t *leA,*leC; // array of low edges anode and cathorde.
 325     Int_t i;
 326
 327     leA = new Float_t[kNstrips+1];
 328     leC = new Float_t[kNstrips+1];
 329     leA[0] = -kDxyz[0];
 330     leA[1] = -kpitch*(0.5*kNstrips-1);
 331     leC[0] =  kDxyz[0];
 332     leC[1] =  kpitch*(0.5*kNstrips-1);
 333     for(i=1;i<kNstrips;i++){
 334         leA[i+1] = leA[i] + kpitch;
 335         leC[i+1] = leC[i] - kpitch;
 336     } // end for i
 337     leA[kNstrips] =  kDxyz[0];
 338     leC[kNstrips] = -kDxyz[0];
 339 //    cout << "AliITSgeomSSD275and75 default creator called: start" << endl;
 340     AliITSgeomSSD::ResetSSD(par,kangleA,kangleC,
 341                                  kNstrips+1,leA,kNstrips+1,leC);
 342     delete [] leA;
 343     delete [] leC;
 344 //    cout << "AliITSgeomSSD275and75 default creator called: end" << endl;
 345 }
 346 //________________________________________________________________________
 347 ostream &operator<<(ostream &os,AliITSgeomSSD275and75 &p){
 348 ////////////////////////////////////////////////////////////////////////
 349 // Standard output streaming function.
 350 ////////////////////////////////////////////////////////////////////////
 351
 352     p.Print(&os);
 353     return os;
 354 }
 355 //----------------------------------------------------------------------
 356 istream &operator>>(istream &is,AliITSgeomSSD275and75 &r){
 357 ////////////////////////////////////////////////////////////////////////
 358 // Standard input streaming function.
 359 ////////////////////////////////////////////////////////////////////////
 360
 361     r.Read(&is);
 362     return is;
 363 }
 364 //======================================================================
 365
 366 ClassImp(AliITSgeomSSD75and275)
 367
 368 AliITSgeomSSD75and275::AliITSgeomSSD75and275() : AliITSgeomSSD(){
 369 ////////////////////////////////////////////////////////////////////////
 370 //    default constructor
 371 ////////////////////////////////////////////////////////////////////////
 372 }
 373 AliITSgeomSSD75and275::AliITSgeomSSD75and275(Int_t npar,Float_t *par) :
 374                                                             AliITSgeomSSD(){
 375     // Default constructor for AliITSgeomSSD with strip angles of
 376     // 75 miliradians and 275 miliradians. This constructor initlizes
 377     // AliITSgeomSSD with the correct values. This is the miror image
 378     // of the AliITSgeomSSD275and75 class.
 379     const Float_t kDxyz[] ={3.6500,0.0150,2.000};//cm. (Geant 3.12 units)
 380     // Size of sensitive detector area x,y(thickness),z
 381     const Float_t kangleA  = 0.0075; // angle in rad. of anode and cathodes
 382     const Float_t kangleC  = 0.0275; // angle in rad. of anode and cathodes
 383     const Float_t kpitch   = 0.0095;// cm anode separation.
 384     const Int_t   kNstrips = 768; // number of anode or cathode strips.
 385     Float_t *leA,*leC; // array of low edges anode and cathorde.
 386     Int_t i;
 387
 388     leA = new Float_t[kNstrips+1];
 389     leC = new Float_t[kNstrips+1];
 390     leA[0] = -kDxyz[0];
 391     leA[1] = -kpitch*(0.5*kNstrips-1);
 392     leC[0] =  kDxyz[0];
 393     leC[1] =  kpitch*(0.5*kNstrips-1);
 394     for(i=1;i<kNstrips;i++){
 395         leA[i+1] = leA[i] + kpitch;
 396         leC[i+1] = leC[i] - kpitch;
 397     } // end for i
 398     leA[kNstrips] =  kDxyz[0];
 399     leC[kNstrips] = -kDxyz[0];
 400 //    cout << "AliITSgeomSSD275and75 default creator called: start" << endl;
 401     AliITSgeomSSD::ResetSSD(par,kangleA,kangleC,
 402                                  kNstrips+1,leA,kNstrips+1,leC);
 403     delete leA;
 404     delete leC;
 405 //    cout << "AliITSgeomSSD275and75 default creator called: end" << endl;
 406 }
 407 //________________________________________________________________________
 408 ostream &operator<<(ostream &os,AliITSgeomSSD75and275 &p){
 409 ////////////////////////////////////////////////////////////////////////
 410 // Standard output streaming function.
 411 ////////////////////////////////////////////////////////////////////////
 412
 413     p.Print(&os);
 414     return os;
 415 }
 416 //----------------------------------------------------------------------
 417 istream &operator>>(istream &is,AliITSgeomSSD75and275 &r){
 418 ////////////////////////////////////////////////////////////////////////
 419 // Standard input streaming function.
 420 ////////////////////////////////////////////////////////////////////////
 421
 422     r.Read(&is);
 423     return is;
 424 }
 425 //======================================================================