ITS/AliITSBaseGeometry.h

   1 #ifndef ALIITSBASEVOLPARAMS_H
   2 #define ALIITSBASEVOLPARAMS_H
   3 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   4  * See cxx source for full Copyright notice                               */
   5
   6 /*
   7   $Id$
   8  */
   9
  10 /////////////////////////////////////////////////////////////////////////
  11 //  Geant 3 base class for volume parameters
  12 /////////////////////////////////////////////////////////////////////////
  13 #include <TObject.h>
  14 class TString;
  15
  16 class AliITSBaseVolParams : public TObject {
  17  public:
  18     AliITSBaseVolParams(){fVol=-1;fCpn=-1;} // Default constructor
  19     virtual ~AliITSBaseVolParams(){} // Destructor
  20     virtual void SetVid(Int_t i){fVol = i;}// Sets the volume id from the next
  21                                            // available one
  22     virtual Int_t GetVid(){return fVol;} // Returns volume id
  23     virtual void SetName(const char *c){fName=c;}//Sets name of this volume
  24     virtual TString* GetName(){return &fName;} // Returns volume name
  25     virtual void Print(ostream *os); // Prints output content of this class
  26     virtual void Read(istream *is); // Reads output created by Print above.
  27     virtual Int_t GetCopyNumber(){return fCpn;}//Returns existing max copy no.
  28     // incoment and return copy number.
  29     virtual Int_t GetNextcpn(){fCpn++;return fCpn;}
  30     // Same as above, but add's 1 for FORTRAN/Geant3 compliance.
  31     virtual Int_t GetG3cpn(){return GetNextcpn()+1;}
  32     /*
  33     Int_t ITSIndexToITSG3name(const Int_t i)
  34         {return AliITSBaseGeometry::ITSIndexToITSG3name(i);};
  35     Int_t ITSG3VnameToIndex(const char *name)const
  36         {return AliITSBaseGeometry::ITSG3VnameToIndex(name);};
  37     */
  38  private:
  39     Int_t   fVol;  // Volume index number
  40     Int_t   fCpn;  // max Copy number
  41     TString fName; // Volume name
  42
  43     ClassDef(AliITSBaseVolParams,1) // Basic ITS volume parameters class
  44 };
  45 // Input and output function for standard C++ input/output.
  46 ostream &operator<<(ostream &os,AliITSBaseVolParams &source);
  47 istream &operator>>(istream &os,AliITSBaseVolParams &source);
  48 #endif
  49
  50 #ifndef ALIITSBOXDATA_H
  51 #define ALIITSBOXDATA_H
  52 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  53  * See cxx source for full Copyright notice                               */
  54
  55 /*
  56   $Id$
  57  */
  58
  59 /////////////////////////////////////////////////////////////////////////
  60 //  Geant 3 Box data structure.
  61 /////////////////////////////////////////////////////////////////////////
  62 class TString;
  63
  64 class AliITSBoxData : public AliITSBaseVolParams {
  65  public:
  66     AliITSBoxData() : AliITSBaseVolParams() // Default constructor
  67         {fDx=0.0;fDy=0.0;fDz=0;}
  68     virtual ~AliITSBoxData(){} // Standard destructor
  69     // Getters
  70     Double_t DxAt() {return fDx;} // Returm arrau of rmin values
  71     Double_t DyAt() {return fDy;} // Returm arrau of rmax values
  72     Double_t DzAt() {return fDz;} // Return fDz coordiante
  73     Double_t& Dx(){return fDx;}// Returns address of fRmax
  74     Double_t& Dy(){return fDy;}// Returns address of fRmin
  75     Double_t& Dz(){return fDz;}// Returns address of fDz
  76     void Print(ostream *os); // Prints output content of this class
  77     void Read(istream *is); // Reads output created by Print above.
  78  private:
  79     Double_t fDx; // X half length
  80     Double_t fDy; // Y half length
  81     Double_t fDz; // Z half length.
  82
  83     ClassDef(AliITSBoxData,1) // Box data class
  84 };
  85 // Input and output function for standard C++ input/output.
  86 ostream &operator<<(ostream &os,AliITSBoxData &source);
  87 istream &operator>>(istream &os,AliITSBoxData &source);
  88 #endif
  89
  90 #ifndef ALIITSTRAPEZOID1DATA_H
  91 #define ALIITSTRAPEZOID1DATA_H
  92 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  93  * See cxx source for full Copyright notice                               */
  94
  95 /*
  96   $Id$
  97  */
  98
  99 /////////////////////////////////////////////////////////////////////////
 100 //  Geant 3 Trapezoid 1 data structure.
 101 /////////////////////////////////////////////////////////////////////////
 102 class TString;
 103
 104 class AliITSTrapezoid1Data : public AliITSBaseVolParams {
 105  public:
 106     AliITSTrapezoid1Data() : AliITSBaseVolParams() // Default constructor
 107         {fDx[0]=0.0;fDx[1]=0.0;fDy=0.0;fDz=0;}
 108     virtual ~AliITSTrapezoid1Data(){} // Standard destructor
 109     // Getters
 110     Double_t DxAt(Int_t i) {return fDx[i];} // Returm arrau of rmin values
 111     Double_t DyAt() {return fDy;} // Returm arrau of rmax values
 112     Double_t DzAt() {return fDz;} // Return fDz coordiante
 113     Double_t& Dx(Int_t i){return fDx[i];}// Returns address of fRmax
 114     Double_t& Dy(){return fDy;}// Returns address of fRmin
 115     Double_t& Dz(){return fDz;}// Returns address of fDz
 116     void Print(ostream *os); // Prints output content of this class
 117     void Read(istream *is); // Reads output created by Print above.
 118  private:
 119     Double_t fDx[2]; // X half length
 120     Double_t fDy; // Y half length
 121     Double_t fDz; // Z half length.
 122
 123     ClassDef(AliITSTrapezoid1Data,1) // Trapezoid 1 data class
 124 };
 125 // Input and output function for standard C++ input/output.
 126 ostream &operator<<(ostream &os,AliITSTrapezoid1Data &source);
 127 istream &operator>>(istream &os,AliITSTrapezoid1Data &source);
 128 #endif
 129
 130 #ifndef ALIITSTRAPEZOID2DATA_H
 131 #define ALIITSTRAPEZOID2DATA_H
 132 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 133  * See cxx source for full Copyright notice                               */
 134
 135 /*
 136   $Id$
 137  */
 138
 139 /////////////////////////////////////////////////////////////////////////
 140 //  Geant 3 Trapezoid 2 data structure.
 141 /////////////////////////////////////////////////////////////////////////
 142 class TString;
 143
 144 class AliITSTrapezoid2Data : public AliITSBaseVolParams {
 145  public:
 146     AliITSTrapezoid2Data() : AliITSBaseVolParams() // Default constructor
 147         {fDx[0]=0.0;fDx[1]=0.0;fDy[0]=0.0;fDy[1]=0.0;fDz=0.0;}
 148     virtual ~AliITSTrapezoid2Data(){} // Standard destructor
 149     // Getters
 150     Double_t DxAt(Int_t i) {return fDx[i];} // Returm arrau of rmin values
 151     Double_t DyAt(Int_t i) {return fDy[i];} // Returm arrau of rmax values
 152     Double_t DzAt() {return fDz;} // Return fDz coordiante
 153     Double_t& Dx(Int_t i){return fDx[i];}// Returns address of fRmax
 154     Double_t& Dy(Int_t i){return fDy[i];}// Returns address of fRmin
 155     Double_t& Dz(){return fDz;}// Returns address of fDz
 156     void Print(ostream *os); // Prints output content of this class
 157     void Read(istream *is); // Reads output created by Print above.
 158  private:
 159     Double_t fDx[2]; // X half length
 160     Double_t fDy[2]; // Y half length
 161     Double_t fDz; // Z half length.
 162
 163     ClassDef(AliITSTrapezoid2Data,1) // Trapezoid 2 data class
 164 };
 165 // Input and output function for standard C++ input/output.
 166 ostream &operator<<(ostream &os,AliITSTrapezoid2Data &source);
 167 istream &operator>>(istream &os,AliITSTrapezoid2Data &source);
 168 #endif
 169
 170 #ifndef ALIITSTRAPEZOIDDATA_H
 171 #define ALIITSTRAPEZOIDDATA_H
 172 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 173  * See cxx source for full Copyright notice                               */
 174
 175 /*
 176   $Id$
 177  */
 178
 179 /////////////////////////////////////////////////////////////////////////
 180 //  Geant 3 Trapezoid General data structure.
 181 /////////////////////////////////////////////////////////////////////////
 182 class TString;
 183
 184 class AliITSTrapezoidData : public AliITSBaseVolParams {
 185  public:
 186     AliITSTrapezoidData() : AliITSBaseVolParams() // Default constructor
 187         {fDz=0.0;fTheta=0.0;fPhi=0.0;fH[0]=0.0;fH[1]=0.0;fBl[0]=0.0;
 188         fBl[1]=0.0;fTl[0]=0.0;fTl[1]=0.0;fAlp[0]=0.0;fAlp[1]=0.0;}
 189     virtual ~AliITSTrapezoidData(){} // Standard destructor
 190     // Getters
 191     Double_t DzAt() {return fDz;} // Returm arrau of dZ values
 192     Double_t Theta() {return fTheta;} // Returm arrau of Theta values
 193     Double_t Phi() {return fPhi;} // Return Phi coordiante
 194     Double_t HAt(Int_t i){return fH[i];} // Return fH[]
 195     Double_t Bl(Int_t i){return fBl[i];} // Return fBl[]
 196     Double_t Tl(Int_t i){return fTl[i];} // Return fTl[]
 197     Double_t Alpha(Int_t i){return fAlp[i];} // Return fAlpha[]
 198     Double_t& Dz(){return fDz;}// Returns address of fDz
 199     Double_t& Th(){return fTheta;}// Returns address of fTheta
 200     Double_t& Ph(){return fPhi;}// Returns address of fPhi
 201     Double_t& H(Int_t i){return fH[i];}// Returns address of fH
 202     Double_t& B(Int_t i){return fBl[i];}// Returns address of fBl
 203     Double_t& T(Int_t i){return fTl[i];}// Returns address of fTl
 204     Double_t& A(Int_t i){return fAlp[i];}// Returns address of fAlp
 205     void Print(ostream *os); // Prints output content of this class
 206     void Read(istream *is); // Reads output created by Print above.
 207  private:
 208     Double_t fTheta; // Polar angle of the line joing the center of the
 209                      // face at -dz to the center of the one at dz [degree].
 210     Double_t fPhi;   // aximuthal angle of the line joing the center of the
 211                      //  face at -dz to the center of the one at +dz [degree].
 212     Double_t fDz;    // Half-length along the z-asix
 213     Double_t fH[2];  // half-length along y of the face at -dz & _dz.
 214     Double_t fBl[2]; // half-length along x of the side at -h1 in y of
 215                      // the face at -dz & +dz in z.
 216     Double_t fTl[2]; // half-length along x of teh side at +h1 in y of
 217                      // the face at -dz & +dz in z.
 218     Double_t fAlp[2];// angle with respect to the y axis from the center of
 219                      // the side at -fH[0] & +fH[1] in y to the cetner of the
 220                      // side at +h1 in y of the face at -dz in z [degree].
 221
 222     ClassDef(AliITSTrapezoidData,1) // General Trapezoid data class
 223 };
 224 // Input and output function for standard C++ input/output.
 225 ostream &operator<<(ostream &os,AliITSTrapezoidData &source);
 226 istream &operator>>(istream &os,AliITSTrapezoidData &source);
 227 #endif
 228
 229 #ifndef ALIITSTRAPEZOIDTWISTEDDATA_H
 230 #define ALIITSTRAPEZOIDTWISTEDDATA_H
 231 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 232  * See cxx source for full Copyright notice                               */
 233
 234 /*
 235   $Id$
 236  */
 237
 238 /////////////////////////////////////////////////////////////////////////
 239 //  Geant 3 Trapezoid General data structure.
 240 /////////////////////////////////////////////////////////////////////////
 241 class TString;
 242
 243 class AliITSTrapezoidTwistedData : public AliITSBaseVolParams {
 244  public:
 245     AliITSTrapezoidTwistedData() : AliITSBaseVolParams() //Default constructor
 246         {fTwist=0.0;fDz=0.0;fTheta=0.0;fPhi=0.0;fH[0]=0.0;fH[1]=0.0;
 247         fBl[0]=0.0;fBl[1]=0.0;fTl[0]=0.0;fTl[1]=0.0;fAlp[0]=0.0;fAlp[1]=0.0;}
 248     virtual ~AliITSTrapezoidTwistedData(){} // Standard destructor
 249     // Getters
 250     Double_t DzAt() {return fDz;} // Returm arrau of dZ values
 251     Double_t Theta() {return fTheta;} // Returm arrau of Theta values
 252     Double_t Phi() {return fPhi;} // Return Phi angle
 253     Double_t Twist(){return fTwist;} // Returns Twist angle
 254     Double_t HAt(Int_t i){return fH[i];} // Return fH[]
 255     Double_t Bl(Int_t i){return fBl[i];} // Return fBl[]
 256     Double_t Tl(Int_t i){return fTl[i];} // Return fTl[]
 257     Double_t Alpha(Int_t i){return fAlp[i];} // Return fAlpha[]
 258     Double_t& Dz(){return fDz;}// Returns address of fDz
 259     Double_t& Th(){return fTheta;}// Returns address of fTheta
 260     Double_t& Ph(){return fPhi;}// Returns address of fPhi
 261     Double_t& Tw(){return fTwist;}// Returns address of fTwist
 262     Double_t& H(Int_t i){return fH[i];}// Returns address of fH
 263     Double_t& B(Int_t i){return fBl[i];}// Returns address of fBl
 264     Double_t& T(Int_t i){return fTl[i];}// Returns address of fTl
 265     Double_t& A(Int_t i){return fAlp[i];}// Returns address of fAlp
 266     void Print(ostream *os); // Prints output content of this class
 267     void Read(istream *is); // Reads output created by Print above.
 268  private:
 269     Double_t fTwist; // Twist angle of the faces parallel to the x-y
 270                      // plane at z=+-dz around an axis parallel to z
 271     Double_t fTheta; // Polar angle of the line joing the center of the
 272                      // face at -dz to the center of the one at dz [degree].
 273     Double_t fPhi;   // aximuthal angle of the line joing the center of the
 274                      //  face at -dz to the center of the one at +dz [degree].
 275     Double_t fDz;    // Half-length along the z-asix
 276     Double_t fH[2];  // half-length along y of the face at -dz & _dz.
 277     Double_t fBl[2]; // half-length along x of the side at -h1 in y of
 278                      // the face at -dz & +dz in z.
 279     Double_t fTl[2]; // half-length along x of teh side at +h1 in y of
 280                      // the face at -dz & +dz in z.
 281     Double_t fAlp[2];// angle with respect to the y axis from the center of
 282                      // the side at -fH[0] & +fH[1] in y to the cetner of the
 283                      // side at +h1 in y of the face at -dz in z [degree].
 284
 285     ClassDef(AliITSTrapezoidTwistedData,1) // Twisted Trapezoid data class
 286 };
 287 // Input and output function for standard C++ input/output.
 288 ostream &operator<<(ostream &os,AliITSTrapezoidTwistedData &source);
 289 istream &operator>>(istream &os,AliITSTrapezoidTwistedData &source);
 290 #endif
 291
 292 #ifndef ALIITSTUBEDATA_H
 293 #define ALIITSTUBEDATA_H
 294 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 295  * See cxx source for full Copyright notice                               */
 296
 297 /*
 298   $Id$
 299  */
 300
 301 /////////////////////////////////////////////////////////////////////////
 302 //  Geant 3 Tube data structure.
 303 /////////////////////////////////////////////////////////////////////////
 304 class TString;
 305
 306 class AliITSTubeData : public AliITSBaseVolParams {
 307  public:
 308     AliITSTubeData() : AliITSBaseVolParams() // Default constructor
 309         {fDz=0;fRmin=0;fRmax=0;}
 310     virtual ~AliITSTubeData(){} // Standard destructor
 311     // Getters
 312     Double_t DzAt(){return fDz;} // Return fDz coordiante
 313     Double_t Rmin() {return fRmin;} // Returm arrau of rmin values
 314     Double_t Rmax() {return fRmax;} // Returm arrau of rmax values
 315     Double_t& Z(){return fDz;}// Returns address of fDz
 316     Double_t& Rn(){return fRmin;}// Returns address of fRmin
 317     Double_t& Rx(){return fRmax;}// Returns address of fRmax
 318     void Print(ostream *os); // Prints output content of this class
 319     void Read(istream *is); // Reads output created by Print above.
 320  private:
 321     Double_t fRmin; // Inner Radius
 322     Double_t fRmax; // Outer Radius
 323     Double_t fDz;   // Z half length.
 324
 325     ClassDef(AliITSTubeData,1) // Simple Tube data class
 326 };
 327 // Input and output function for standard C++ input/output.
 328 ostream &operator<<(ostream &os,AliITSTubeData &source);
 329 istream &operator>>(istream &os,AliITSTubeData &source);
 330 #endif
 331
 332 #ifndef ALIITSTUBESEGDATA_H
 333 #define ALIITSTUBESEGDATA_H
 334 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 335  * See cxx source for full Copyright notice                               */
 336
 337 /*
 338   $Id$
 339  */
 340
 341 /////////////////////////////////////////////////////////////////////////
 342 //  Geant 3 Tube Segment data structure.
 343 /////////////////////////////////////////////////////////////////////////
 344 class TString;
 345
 346 class AliITSTubeSegData : public AliITSBaseVolParams {
 347  public:
 348     AliITSTubeSegData() : AliITSBaseVolParams() // Default constructor
 349         {fDz=0;fRmin=0;fRmax=0;}
 350     virtual ~AliITSTubeSegData(){} // Standard destructor
 351     // Getters
 352     Double_t Phi0() {return fPhi0;} // Returns starting Phi value
 353     Double_t Phi1() {return fPhi1;} // Returns endinging Phi value
 354     Double_t DzAt(){return fDz;} // Return fDz coordiante
 355     Double_t Rmin() {return fRmin;} // Returm arrau of rmin values
 356     Double_t Rmax() {return fRmax;} // Returm arrau of rmax values
 357     Double_t& P0(){return fPhi0;}// Returns addres of fPhi0
 358     Double_t& P1(){return fPhi1;}// Returns addres of fPhi1
 359     Double_t& Z(){return fDz;}// Returns address of fDz
 360     Double_t& Rn(){return fRmin;}// Returns address of fRmin
 361     Double_t& Rx(){return fRmax;}// Returns address of fRmax
 362     void Print(ostream *os); // Prints output content of this class
 363     void Read(istream *is); // Reads output created by Print above.
 364  private:
 365     Double_t fPhi0,fPhi1;   // Starting and ending phi angles [degrees]
 366     Double_t fRmin; // Inner Radius
 367     Double_t fRmax; // Outer Radius
 368     Double_t fDz;   // Z half length.
 369
 370     ClassDef(AliITSTubeSegData,1) // Segment of a Tube data class
 371 };
 372 // Input and output function for standard C++ input/output.
 373 ostream &operator<<(ostream &os,AliITSTubeSegData &source);
 374 istream &operator>>(istream &os,AliITSTubeSegData &source);
 375 #endif
 376
 377 #ifndef ALIITSTUBECUTDATA_H
 378 #define ALIITSTUBECUTDATA_H
 379 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 380  * See cxx source for full Copyright notice                               */
 381
 382 /*
 383   $Id$
 384  */
 385
 386 #include <TVector3.h>
 387
 388 /////////////////////////////////////////////////////////////////////////
 389 //  Geant 3 Tube Cut data structure.
 390 /////////////////////////////////////////////////////////////////////////
 391 class TString;
 392
 393 class AliITSTubeCutData : public AliITSBaseVolParams {
 394  public:
 395     AliITSTubeCutData() : AliITSBaseVolParams() // Default constructor
 396         {fDz=0;fRmin=0;fRmax=0;fPhi0=0.0,fPhi1=0.0;}
 397     virtual ~AliITSTubeCutData(){} // Standard destructor
 398     // Getters
 399     Double_t Phi0() {return fPhi0;} // Returns starting Phi value
 400     Double_t Phi1() {return fPhi1;} // Returns endinging Phi value
 401     Double_t DzAt(){return fDz;} // Return fDz coordiante
 402     Double_t Rmin() {return fRmin;} // Returm arrau of rmin values
 403     Double_t Rmax() {return fRmax;} // Returm arrau of rmax values
 404     TVector3 Normal(Int_t i){return (fNorm[i]).Unit();}// Returns unit normal
 405                                                      //at z serface -dz & +dz.
 406     // Returns jth unit normal at z serface -dz & +dz.
 407     Double_t Normal(Int_t i,Int_t j){return ((fNorm[i]).Unit())[j];}
 408     Double_t& P0(){return fPhi0;}// Returns addres of fPhi0
 409     Double_t& P1(){return fPhi1;}// Returns addres of fPhi1
 410     Double_t& Z(){return fDz;}// Returns address of fDz
 411     Double_t& Rn(){return fRmin;}// Returns address of fRmin
 412     Double_t& Rx(){return fRmax;}// Returns address of fRmax
 413     // Returns address of normal at z serface -dz & +dz.
 414     TVector3& Nv(Int_t i){return fNorm[i];}
 415     Double_t& Nx(Int_t i){return (fNorm[i])[0];}// return address of x
 416                                                 //component of the nomal vect.
 417     Double_t& Ny(Int_t i){return (fNorm[i])[1];}// return address of y
 418                                                 //component of the nomal vect.
 419     Double_t& Nz(Int_t i){return (fNorm[i])[2];}// return address of z
 420                                                 //component of the nomal vect.
 421     void Print(ostream *os); // Prints output content of this class
 422     void Read(istream *is); // Reads output created by Print above.
 423  private:
 424     Double_t fPhi0,fPhi1;   // Starting and ending phi angles [degrees]
 425     Double_t fRmin; // Inner Radius
 426     Double_t fRmax; // Outer Radius
 427     Double_t fDz;   // Z half length.
 428     TVector3 fNorm[2]; // unit vector normal to -dz and +dz surfaces.
 429
 430     ClassDef(AliITSTubeCutData,1) // A tube segment with cut ends data class
 431 };
 432 // Input and output function for standard C++ input/output.
 433 ostream &operator<<(ostream &os,AliITSTubeCutData &source);
 434 istream &operator>>(istream &os,AliITSTubeCutData &source);
 435 #endif
 436
 437 #ifndef ALIITSTUBEELLIPTICALDATA_H
 438 #define ALIITSTUBEELLIPTICALDATA_H
 439 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 440  * See cxx source for full Copyright notice                               */
 441
 442 /*
 443   $Id$
 444  */
 445
 446 /////////////////////////////////////////////////////////////////////////
 447 //  Geant 3 Tube Elliptical data structure.
 448 /////////////////////////////////////////////////////////////////////////
 449 class TString;
 450
 451 class AliITSTubeEllipticalData : public AliITSBaseVolParams {
 452  public:
 453     AliITSTubeEllipticalData() : AliITSBaseVolParams() // Default constructor
 454         {fDz=0;fP0=0;fP1=0;}
 455     virtual ~AliITSTubeEllipticalData(){} // Standard destructor
 456     // Getters
 457     Double_t DzAt(){return fDz;} // Return fDz coordiante
 458     Double_t P0At() {return fP0;} // Returm fP0 values
 459     Double_t P1At() {return fP1;} // Returm fP1 values
 460     Double_t& Z(){return fDz;}// Returns address of fDz
 461     Double_t& P0(){return fP0;}// Returns address of fP0
 462     Double_t& P1(){return fP1;}// Returns address of fP1
 463     void Print(ostream *os); // Prints output content of this class
 464     void Read(istream *is); // Reads output created by Print above.
 465  private:
 466     Double_t fP0; // semi-axis of the elipse along x
 467     Double_t fP1; // semi-asis of the elipse along y
 468     Double_t fDz;   // Z half length.
 469
 470     ClassDef(AliITSTubeEllipticalData,1) // Tube with an elliptical cross
 471                                          // section data class
 472 };
 473 // Input and output function for standard C++ input/output.
 474 ostream &operator<<(ostream &os,AliITSTubeEllipticalData &source);
 475 istream &operator>>(istream &os,AliITSTubeEllipticalData &source);
 476 #endif
 477
 478 #ifndef ALIITSTUBEHYPERBOLICDATA_H
 479 #define ALIITSTUBEHYPERBOLICDATA_H
 480 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 481  * See cxx source for full Copyright notice                               */
 482
 483 /*
 484   $Id$
 485  */
 486
 487 /////////////////////////////////////////////////////////////////////////
 488 //  Geant 3 Tube Hyperbolic data structure.
 489 /////////////////////////////////////////////////////////////////////////
 490 class TString;
 491
 492 class AliITSTubeHyperbolicData : public AliITSBaseVolParams {
 493  public:
 494     AliITSTubeHyperbolicData() : AliITSBaseVolParams() // Default constructor
 495         {fTheta=0.0;fDz=0;fRmin=0;fRmax=0;}
 496     virtual ~AliITSTubeHyperbolicData(){} // Standard destructor
 497     // Getters
 498     Double_t ThetaAt() {return fTheta;} // Returns starting Theta value
 499     Double_t DzAt(){return fDz;} // Return fDz coordiante
 500     Double_t Rmin() {return fRmin;} // Returm arrau of rmin values
 501     Double_t Rmax() {return fRmax;} // Returm arrau of rmax values
 502     Double_t& Theta(){return fTheta;}// Returns addres of fTheta
 503     Double_t& Z(){return fDz;}// Returns address of fDz
 504     Double_t& Rn(){return fRmin;}// Returns address of fRmin
 505     Double_t& Rx(){return fRmax;}// Returns address of fRmax
 506     void Print(ostream *os); // Prints output content of this class
 507     void Read(istream *is); // Reads output created by Print above.
 508  private:
 509     Double_t fTheta;   // stero angle of rotation of the tetwo faces [degrees]
 510     Double_t fRmin; // Inner Radius
 511     Double_t fRmax; // Outer Radius
 512     Double_t fDz;   // Z half length.
 513
 514     ClassDef(AliITSTubeHyperbolicData,1) // Hyperbolic Tube data class
 515 };
 516 // Input and output function for standard C++ input/output.
 517 ostream &operator<<(ostream &os,AliITSTubeHyperbolicData &source);
 518 istream &operator>>(istream &os,AliITSTubeHyperbolicData &source);
 519 #endif
 520
 521 #ifndef ALIITSCONEDATA_H
 522 #define ALIITSCONEDATA_H
 523 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 524  * See cxx source for full Copyright notice                               */
 525
 526 /*
 527   $Id$
 528  */
 529
 530 /////////////////////////////////////////////////////////////////////////
 531 //  Geant 3 Cone data structure.
 532 /////////////////////////////////////////////////////////////////////////
 533 class TString;
 534
 535 class AliITSConeData : public AliITSBaseVolParams {
 536  public:
 537     AliITSConeData() : AliITSBaseVolParams() // Default constructor
 538         {fDz=0;fRmin0=0;fRmax0=0;fRmin1=0;fRmax1=0;}
 539     virtual ~AliITSConeData(){} // Standard destructor
 540     // Getters
 541     Double_t DzAt(){return fDz;} // Return fDz coordiante
 542     Double_t Rmin0() {return fRmin0;} // Returm arrau of rmin0 values
 543     Double_t Rmax0() {return fRmax0;} // Returm arrau of rmax0 values
 544     Double_t Rmin1() {return fRmin1;} // Returm arrau of rmin1 values
 545     Double_t Rmax1() {return fRmax1;} // Returm arrau of rmax1 values
 546     Double_t& Z(){return fDz;}// Returns address of fDz
 547     Double_t& Rn0(){return fRmin0;}// Returns address of fRmin0
 548     Double_t& Rx0(){return fRmax0;}// Returns address of fRmax0
 549     Double_t& Rn1(){return fRmin1;}// Returns address of fRmin1
 550     Double_t& Rx1(){return fRmax1;}// Returns address of fRmax1
 551     void Print(ostream *os); // Prints output content of this class
 552     void Read(istream *is); // Reads output created by Print above.
 553  private:
 554     Double_t fRmin0,fRmin1; // Inner Radius
 555     Double_t fRmax0,fRmax1; // Outer Radius
 556     Double_t fDz;   // Z half length.
 557
 558     ClassDef(AliITSConeData,1) // Simple Cone data class
 559 };
 560 // Input and output function for standard C++ input/output.
 561 ostream &operator<<(ostream &os,AliITSConeData &source);
 562 istream &operator>>(istream &os,AliITSConeData &source);
 563 #endif
 564
 565 #ifndef ALIITSCONESEGDATA_H
 566 #define ALIITSCONESEGDATA_H
 567 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 568  * See cxx source for full Copyright notice                               */
 569
 570 /*
 571   $Id$
 572  */
 573
 574 /////////////////////////////////////////////////////////////////////////
 575 //  Geant 3 Cone Segment data structure.
 576 /////////////////////////////////////////////////////////////////////////
 577 class TString;
 578
 579 class AliITSConeSegData : public AliITSBaseVolParams {
 580  public:
 581     AliITSConeSegData() : AliITSBaseVolParams() // Default constructor
 582         {fPhi0=0.0;fPhi1=360.0;fDz=0;fRmin0=0;fRmax0=0;fRmin1=0;fRmax1=0;}
 583     virtual ~AliITSConeSegData(){} // Standard destructor
 584     // Getters
 585     Double_t Phi0() {return fPhi0;} // Returns starting Phi value
 586     Double_t Phi1() {return fPhi1;} // Returns endinging Phi value
 587     Double_t DzAt() {return fDz;} // Return fDz coordiante
 588     Double_t Rmin0() {return fRmin0;} // Returm arrau of rmin0 values
 589     Double_t Rmax0() {return fRmax0;} // Returm arrau of rmax0 values
 590     Double_t Rmin1() {return fRmin1;} // Returm arrau of rmin1 values
 591     Double_t Rmax1() {return fRmax1;} // Returm arrau of rmax1 values
 592     Double_t& P0(){return fPhi0;}// Returns addres of fPhi0
 593     Double_t& P1(){return fPhi1;}// Returns addres of fPhi1
 594     Double_t& Z(){return fDz;}// Returns address of fDz
 595     Double_t& Rn0(){return fRmin0;}// Returns address of fRmin0
 596     Double_t& Rx0(){return fRmax0;}// Returns address of fRmax0
 597     Double_t& Rn1(){return fRmin1;}// Returns address of fRmin1
 598     Double_t& Rx1(){return fRmax1;}// Returns address of fRmax1
 599     void Print(ostream *os); // Prints output content of this class
 600     void Read(istream *is); // Reads output created by Print above.
 601  private:
 602     Double_t fPhi0,fPhi1;   // Starting and ending phi angles [degrees]
 603     Double_t fRmin0,fRmin1; // Inner Radius
 604     Double_t fRmax0,fRmax1; // Outer Radius
 605     Double_t fDz;   // Z half length.
 606
 607     ClassDef(AliITSConeSegData,1) // Cone segment data class
 608 };
 609 // Input and output function for standard C++ input/output.
 610 ostream &operator<<(ostream &os,AliITSConeSegData &source);
 611 istream &operator>>(istream &os,AliITSConeSegData &source);
 612 #endif
 613
 614 #ifndef ALIITSPCONEDATA_H
 615 #define ALIITSPCONEDATA_H
 616 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 617  * See cxx source for full Copyright notice                               */
 618
 619 /*
 620   $Id$
 621  */
 622
 623 /////////////////////////////////////////////////////////////////////////
 624 //  Geant 3 Poly-Cone data structure.
 625 /////////////////////////////////////////////////////////////////////////
 626 #include <math.h> // for the definision of NAN.
 627 class TString;
 628
 629 class AliITSPConeData : public AliITSBaseVolParams {
 630  public:
 631     AliITSPConeData() : AliITSBaseVolParams() // Default constructor
 632         {fNz=0;fPhi0=0.0;fDphi=0.0;fZ=0;fRmin=0;fRmax=0;}
 633     AliITSPConeData(Int_t n) : AliITSBaseVolParams() // Standard constructor
 634         {fNz=n;fPhi0=0.0;fDphi=360.0;fZ=new Double_t[n];
 635         fRmin=new Double_t[n];fRmax=new Double_t[n];}
 636     AliITSPConeData(AliITSPConeData &source) // Copy constructor
 637         { *this = source;}
 638     virtual ~AliITSPConeData() // Standard destructor
 639         {delete[] fZ;delete[] fRmin;delete[] fRmax;fNz=0;}
 640     AliITSPConeData& operator=(AliITSPConeData &source) // Equals operator
 641         {this->SetVid(source.GetVid());
 642         this->SetName((source.GetName())->Data());
 643         this->fNz = source.fNz;this->fPhi0=source.fPhi0;
 644         this->fDphi=source.fDphi;
 645         if(this->fZ!=0) delete[] this->fZ;
 646         if(this->fRmin!=0) delete[] this->fRmin;
 647         if(this->fRmax!=0) delete[] this->fRmax;
 648         this->fZ=0;this->fRmin=0;this->fRmax=0;if(this->fNz<=0) return *this;
 649         this->fZ=new Double_t[this->fNz];this->fRmin=new Double_t[this->fNz];
 650         this->fRmax=new Double_t[this->fNz];for(Int_t i=0;i<this->fNz;i++){
 651             this->fZ[i]=source.fZ[i];this->fRmin[i]=source.fRmin[i];
 652             fRmax[i]=source.fRmax[i];}return *this;}
 653     void Size(Int_t n)// Sets the number of Z,Rmin,Rmax parameters
 654         {if(fZ!=0) delete fZ;if(fRmin!=0) delete fRmin;
 655         if(fRmax!=0) delete fRmax; fNz=n;fPhi0=0.0;fDphi=360.0;
 656         fZ=new Double_t[n];fRmin=new Double_t[n];fRmax=new Double_t[n];}
 657     void Size(Int_t n,const char *c){//Sets the number of Z,Rmin, and Rmax
 658         // parameters as well as the volume name.
 659         Size(n);SetName(c);}
 660     // Getters
 661     Int_t Nz() {return fNz;} // Returns fNz
 662     Double_t Phi0(){return fPhi0;}// Return starting phi value
 663     Double_t DPhi(){return fDphi;}// Return delta phi value
 664     Double_t ZAt(Int_t i) // Return Z coordiante
 665         {/*if(i<0||i>=fNz) return NAN;else*/ return fZ[i];}
 666     Double_t *Z(){return fZ;} // Returns array of z values
 667     Double_t *Rmin() {return fRmin;} // Returm arrau of rmin values
 668     Double_t *Rmax() {return fRmax;} // Returm arrau of rmax values
 669     Double_t Rmin(Int_t i) // Return Inner radius value
 670         {/*if(i<0||i>=fNz) return NAN;else*/ return fRmin[i];}
 671     Double_t Rmax(Int_t i) // Return Outer radius value
 672         {/*if(i<0||i>=fNz) return NAN;else*/ return fRmax[i];}
 673     // Setters
 674     Double_t& P0() // Returns the address of fPhi0
 675         {return fPhi0;}
 676     Double_t& dP() // Returns the address of fDphi
 677         {return fDphi;}
 678     Double_t& Z(Int_t i)// Returns address of fZ
 679         {/*if(i<0||i>=fNz) return 0;*/return fZ[i];}
 680     Double_t& Rn(Int_t i)// Returns address of fRmin
 681         {/*if(i<0||i>=fNz) return 0;*/return fRmin[i];}
 682     Double_t& Rx(Int_t i)// Returns address of fRmax
 683         {/*if(i<0||i>=fNz) return 0;*/return fRmax[i];}
 684     void Print(ostream *os); // Prints output content of this class
 685     void Read(istream *is); // Reads output created by Print above.
 686  private:
 687     Int_t fNz; // Number of z sections
 688     Double_t fPhi0,fDphi; // Starting phi angle and delta phi [degrees]
 689     Double_t *fZ;    //[n] Z coordiantes
 690     Double_t *fRmin; //[n] Inner radius
 691     Double_t *fRmax; //[n] Outer radius
 692
 693     ClassDef(AliITSPConeData,1) // Poly Cone data class
 694 };
 695 // Input and output function for standard C++ input/output.
 696 ostream &operator<<(ostream &os,AliITSPConeData &source);
 697 istream &operator>>(istream &os,AliITSPConeData &source);
 698
 699 #endif
 700
 701 #ifndef ALIITSSPHEREDATA_H
 702 #define ALIITSSPHEREDATA_H
 703 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 704  * See cxx source for full Copyright notice                               */
 705
 706 /*
 707   $Id$
 708  */
 709
 710 /////////////////////////////////////////////////////////////////////////
 711 //  Geant 3 Tube Segment data structure.
 712 /////////////////////////////////////////////////////////////////////////
 713 class TString;
 714
 715 class AliITSSphereData : public AliITSBaseVolParams {
 716  public:
 717     AliITSSphereData() : AliITSBaseVolParams() // Default constructor
 718         {fTheta[0]=0.0,fTheta[1]=0.0;fPhi[0]=0.0,fPhi[1]=0.0;fRmin=0;fRmax=0;}
 719     virtual ~AliITSSphereData(){} // Standard destructor
 720     // Getters
 721     Double_t Theta0() {return fTheta[0];} // Returns starting Phi value
 722     Double_t Theta1() {return fTheta[1];} // Returns endinging Phi value
 723     Double_t Phi0() {return fPhi[0];} // Returns starting Phi value
 724     Double_t Phi1() {return fPhi[1];} // Returns endinging Phi value
 725     Double_t Rmin() {return fRmin;} // Returm arrau of rmin values
 726     Double_t Rmax() {return fRmax;} // Returm arrau of rmax values
 727     Double_t& T0(){return fTheta[0];}// Returns addres of fTheta[0]
 728     Double_t& T1(){return fTheta[1];}// Returns addres of fTheta[1]
 729     Double_t& P0(){return fPhi[0];}// Returns addres of fPhi[0]
 730     Double_t& P1(){return fPhi[1];}// Returns addres of fPhi[1]
 731     Double_t& Rn(){return fRmin;}// Returns address of fRmin
 732     Double_t& Rx(){return fRmax;}// Returns address of fRmax
 733     void Print(ostream *os); // Prints output content of this class
 734     void Read(istream *is); // Reads output created by Print above.
 735  private:
 736     Double_t fTheta[2]; // Starting and ending theta angles [degree]
 737     Double_t fPhi[2];   // Starting and ending phi angles [degrees]
 738     Double_t fRmin; // Inner Radius
 739     Double_t fRmax; // Outer Radius
 740
 741     ClassDef(AliITSSphereData,1) // sphere data class
 742 };
 743 // Input and output function for standard C++ input/output.
 744 ostream &operator<<(ostream &os,AliITSSphereData &source);
 745 istream &operator>>(istream &os,AliITSSphereData &source);
 746 #endif
 747
 748 #ifndef ALIITSPARALLELEPIPEDDATA_H
 749 #define ALIITSPARALLELEPIPEDDATA_H
 750 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 751  * See cxx source for full Copyright notice                               */
 752
 753 /*
 754   $Id$
 755  */
 756
 757 /////////////////////////////////////////////////////////////////////////
 758 //  Geant 3 Box data structure.
 759 /////////////////////////////////////////////////////////////////////////
 760 class TString;
 761
 762 class AliITSParallelpipedData : public AliITSBaseVolParams {
 763  public:
 764     AliITSParallelpipedData() : AliITSBaseVolParams() // Default constructor
 765         {fDx=0.0;fDy=0.0;fDz=0;}
 766     virtual ~AliITSParallelpipedData(){} // Standard destructor
 767     // Getters
 768     Double_t DxAt() {return fDx;} // Returm arrau of rmin values
 769     Double_t DyAt() {return fDy;} // Returm arrau of rmax values
 770     Double_t DzAt() {return fDz;} // Return fDz coordiante
 771     Double_t Theta() {return fTheta;} // Returm arrau of Theta values
 772     Double_t Phi() {return fPhi;} // Return Phi coordiante
 773     Double_t Alpha(){return fAlpha;} // Return fAlph
 774     Double_t& Dx(){return fDx;}// Returns address of fRmax
 775     Double_t& Dy(){return fDy;}// Returns address of fRmin
 776     Double_t& Dz(){return fDz;}// Returns address of fDz
 777     Double_t& Th(){return fTheta;}// Returns address of fTheta
 778     Double_t& Ph(){return fPhi;}// Returns address of fPhi
 779     Double_t& A(){return fAlpha;}// Returns address of fAlpha
 780     void Print(ostream *os); // Prints output content of this class
 781     void Read(istream *is); // Reads output created by Print above.
 782  private:
 783     Double_t fDx;    // X half length
 784     Double_t fDy;    // Y half length
 785     Double_t fDz;    // Z half length.
 786     Double_t fAlpha; // angle formed by the y axis and by the plane
 787                      // joining the center of teh faces parallel to the
 788                      // z-x plane at -dY and +dy [degree].
 789     Double_t fTheta; //polar angle of the line joining the centers of
 790                      // the faces at -dz and +dz in z [degree].
 791     Double_t fPhi;   // azimuthal angle of teh line joing the centers
 792                      // of the faaces at -dz and +dz in z [degree].
 793
 794     ClassDef(AliITSParallelpipedData,1) // Parallel piped data class
 795 };
 796 // Input and output function for standard C++ input/output.
 797 ostream &operator<<(ostream &os,AliITSParallelpipedData &source);
 798 istream &operator>>(istream &os,AliITSParallelpipedData &source);
 799 #endif
 800
 801 #ifndef ALIITSPGONDATA_H
 802 #define ALIITSPGONDATA_H
 803 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 804  * See cxx source for full Copyright notice                               */
 805
 806 /*
 807   $Id$
 808  */
 809
 810 /////////////////////////////////////////////////////////////////////////
 811 //  Geant 3 Poly-Gon data structure.
 812 /////////////////////////////////////////////////////////////////////////
 813 #include <math.h> // for the definision of NAN.
 814 class TString;
 815
 816 class AliITSPGonData : public AliITSBaseVolParams {
 817  public:
 818     AliITSPGonData() : AliITSBaseVolParams() // Default constructor
 819         {fNz=0;fNphi=0;fPhi0=0.0;fDphi=0.0;fZ=0;fRmin=0;fRmax=0;}
 820     AliITSPGonData(Int_t n) : AliITSBaseVolParams() // Standard constructor
 821         {fNz=n;fNphi=0;fPhi0=0.0;fDphi=360.0;fZ=new Double_t[n];
 822         fRmin=new Double_t[n];fRmax=new Double_t[n];}
 823     AliITSPGonData(AliITSPGonData &source) // Copy constructor
 824         { *this = source;}
 825     virtual ~AliITSPGonData() // Standard destructor
 826         {delete[] fZ;delete[] fRmin;delete[] fRmax;fNz=0;}
 827     AliITSPGonData& operator=(AliITSPGonData &source) // Equals operator
 828         {this->SetVid(source.GetVid());
 829         this->SetName((source.GetName())->Data());
 830         this->fNz = source.fNz;this->fNphi=source.fNphi;
 831         this->fPhi0=source.fPhi0;this->fDphi=source.fDphi;
 832         if(this->fZ!=0) delete[] this->fZ;
 833         if(this->fRmin!=0) delete[] this->fRmin;
 834         if(this->fRmax!=0) delete[] this->fRmax;
 835         this->fZ=0;this->fRmin=0;this->fRmax=0;if(this->fNz<=0) return *this;
 836         this->fZ=new Double_t[this->fNz];this->fRmin=new Double_t[this->fNz];
 837         this->fRmax=new Double_t[this->fNz];for(Int_t i=0;i<this->fNz;i++){
 838             this->fZ[i]=source.fZ[i];this->fRmin[i]=source.fRmin[i];
 839             fRmax[i]=source.fRmax[i];}return *this;}
 840     void Size(Int_t n)// Sets the number of Z,Rmin,Rmax parameters
 841         {if(fZ!=0) delete fZ;if(fRmin!=0) delete fRmin;
 842         if(fRmax!=0) delete fRmax; fNz=n;fPhi0=0.0;fDphi=360.0;
 843         fZ=new Double_t[n];fRmin=new Double_t[n];fRmax=new Double_t[n];}
 844     void Size(Int_t n,const char *c){//Sets the number of Z,Rmin, and Rmax
 845         // parameters as well as the volume name.
 846         Size(n);SetName(c);}
 847     // Getters
 848     Int_t NPhi() {return fNz;} // Returns fNphi
 849     Int_t Nz() {return fNz;} // Returns fNz
 850     Double_t Phi0(){return fPhi0;}// Return starting phi value
 851     Double_t DPhi(){return fDphi;}// Return delta phi value
 852     Double_t *Z(){return fZ;} // Returns array of z values
 853     Double_t *Rmin() {return fRmin;} // Returm arrau of rmin values
 854     Double_t *Rmax() {return fRmax;} // Returm arrau of rmax values
 855     Double_t ZAt(Int_t i) // Return Z coordiante
 856         {/*if(i<0||i>=fNz) return NAN;else*/ return fZ[i];}
 857     Double_t Rmin(Int_t i) // Return Inner radius value
 858         {/*if(i<0||i>=fNz) return NAN;else*/ return fRmin[i];}
 859     Double_t Rmax(Int_t i) // Return Outer radius value
 860         {/*if(i<0||i>=fNz) return NAN;else*/ return fRmax[i];}
 861     // Setters
 862     void Nphi(Int_t i) {fNphi = i;} // Sets fNphi
 863     Double_t& P0() // Returns the address of fPhi0
 864         {return fPhi0;}
 865     Double_t& dP() // Returns the address of fDphi
 866         {return fDphi;}
 867     Double_t& Z(Int_t i)// Returns address of fZ
 868         {/*if(i<0||i>=fNz) return 0;*/return fZ[i];}
 869     Double_t& Rn(Int_t i)// Returns address of fRmin
 870         {/*if(i<0||i>=fNz) return 0;*/return fRmin[i];}
 871     Double_t& Rx(Int_t i)// Returns address of fRmax
 872         {/*if(i<0||i>=fNz) return 0;*/return fRmax[i];}
 873     void Print(ostream *os); // Prints output content of this class
 874     void Read(istream *is); // Reads output created by Print above.
 875  private:
 876     Int_t fNphi;  // Number of sections in phi.
 877     Int_t fNz;    // Number of Z sections
 878     Double_t fPhi0,fDphi; // Starting phi angle and delta phi [degrees]
 879     Double_t *fZ;    //[n] Z coordiantes
 880     Double_t *fRmin; //[n] Inner radius
 881     Double_t *fRmax; //[n] Outer radius
 882
 883     ClassDef(AliITSPGonData,1) // Poly Gon Data Class
 884 };
 885 // Input and output function for standard C++ input/output.
 886 ostream &operator<<(ostream &os,AliITSPGonData &source);
 887 istream &operator>>(istream &os,AliITSPGonData &source);
 888
 889 #endif
 890 #ifndef ALIITSBASEGEOMETRY_H
 891 #define ALIITSBASEGEOMETRY_H
 892 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 893  * See cxx source for full Copyright notice                               */
 894
 895 /*
 896   $Id$
 897  */
 898
 899 /////////////////////////////////////////////////////////////////////////
 900 //  A basic geometry class for the ITS simulation geometry stucture
 901 /////////////////////////////////////////////////////////////////////////
 902 #include <TObject.h>
 903 #include "AliModule.h"
 904 class TString;
 905 class TVector3;
 906
 907 class AliITSBaseGeometry : public TObject {
 908  public:
 909     AliITSBaseGeometry(); // Default constructor
 910     AliITSBaseGeometry(AliModule *its,Int_t iflag); // Standard Constructor
 911     virtual ~AliITSBaseGeometry(); // Destructor
 912     virtual void BuildDisplayGeometry(){}; // Calls ROOT geometry interface
 913                                       // to AliRoot display
 914      // Calls Geant3 interface geometry routines
 915     virtual void CreateG3Geometry(){};
 916     virtual void CreateG3Materials(){};//Calls Geant3 interface for materials
 917     virtual Int_t IsVersion() const{return 11;}// return version of geometry.
 918     // Get Index for Geant3 v name
 919     static Int_t ITSG3VnameToIndex(const char name[3]);
 920     static Int_t ITSIndexToITSG3name(const Int_t i); // Get Geant3 volume name
 921     Int_t AddVolName(const TString name); // Add volumen name to list
 922     TString GetVolName(const Int_t i)const; // Return volume name at index
 923     Int_t GetVolumeIndex(const TString &a);
 924     void SetScalecm(){fScale = 1.0;}// Sets scale factor for centemeters
 925     void SetScalemm(){fScale = 0.10;}// Sets scale factor for milimeters
 926     void SetScalemicrons(){fScale = 1.0E-04;}// Sets scale factor for microns
 927     void SetScale(Double_t s=1.0){fScale = s;}// Sets scale factor
 928     Double_t GetScale()const{return fScale;}// Returns the scale factor
 929     Bool_t IsScalecm()const{// Returens kTRUE if scale factor is set of [cm]
 930         if(fScale==1.0) return kTRUE; return kFALSE;}
 931     // Create a Box
 932     virtual void Box(const char *gnam,const TString &dis,
 933              Double_t dx,Double_t dy,Double_t dz,Int_t med);
 934     virtual void Box(AliITSBoxData &d,Int_t med);
 935     // Greate A Trapizoid with the x dimension varing along z.
 936     virtual void Trapezoid1(const char *gnam,const TString &dis,Double_t dxn,
 937                     Double_t dxp,Double_t dy,Double_t dz,Int_t med);
 938     virtual void Trapezoid1(AliITSTrapezoid1Data &d,Int_t med);
 939     // Greate A Trapizoid with the x and y dimension varing along z.
 940     virtual void Trapezoid2(const char *gnam,const TString &dis,Double_t dxn,
 941                     Double_t dxp,Double_t dyn,Double_t dyp,Double_t dz,
 942                     Int_t med);
 943     virtual void Trapezoid2(AliITSTrapezoid2Data &d,Int_t med);
 944     // General trapazoid.
 945     virtual void Trapezoid(const char *gnam,const TString &dis,Double_t dz,
 946                    Double_t thet,Double_t phi,Double_t h1,Double_t bl1,
 947                    Double_t tl1,Double_t alp1,Double_t h2,Double_t bl2,
 948                    Double_t tl2,Double_t alp2,Int_t med);
 949     virtual void Trapezoid(AliITSTrapezoidData &d,Int_t med);
 950     // Twisted genral trapezoid.
 951     virtual void TwistedTrapezoid(const char *gnam,const TString &dis,
 952                                   Double_t dz,
 953                                   Double_t thet,Double_t phi,Double_t twist,
 954                                   Double_t h1,Double_t bl1,Double_t tl1,
 955                                   Double_t apl1,Double_t h2,Double_t bl2,
 956                                   Double_t tl2,Double_t apl2,Int_t med);
 957     virtual void TwistedTrapezoid(AliITSTrapezoidTwistedData &d,Int_t med);
 958     // Simple Tube.
 959     virtual void Tube(const char *gnam,const TString &dis,Double_t rmin,
 960               Double_t rmax,Double_t dz,Int_t med);
 961     virtual void Tube(AliITSTubeData &d,Int_t med);
 962     // Tube segment.
 963     virtual void TubeSegment(const char *gnam,const TString &dis,
 964                              Double_t rmin,Double_t rmax,Double_t dz,
 965                              Double_t phi1,Double_t phi2,Int_t med);
 966     virtual void TubeSegment(AliITSTubeSegData &v,Int_t med);
 967     // Cut tube.
 968     virtual void CutTube(const char *gnam,const TString &dis,Double_t rmin,
 969                  Double_t rmax,Double_t dz,Double_t phi1,Double_t phi2,
 970                  Double_t lx,Double_t ly,Double_t lz,Double_t hx,Double_t hy,
 971                  Double_t hz,Int_t med);
 972     virtual void CutTube(AliITSTubeCutData &d,Int_t med);
 973     // Ellliptical cross-sectino tube
 974     virtual void TubeElliptical(const char *gnam,const TString &dis,
 975                                 Double_t p1,Double_t p2,Double_t dz,
 976                                 Int_t med);
 977     virtual void TubeElliptical(AliITSTubeEllipticalData &v,Int_t med);
 978     // Hyperbolic tube
 979     virtual void HyperbolicTube(const char *gnam,const TString &dis,
 980                                 Double_t rmin,Double_t rmax,Double_t dz,
 981                                 Double_t thet,Int_t med);
 982     virtual void HyperbolicTube(AliITSTubeHyperbolicData &d,Int_t med);
 983     // Simple Cone.
 984     virtual void Cone(const char *gnam,const TString &dis,Double_t dz,
 985               Double_t rmin1,Double_t rmax1,Double_t rmin2,Double_t rmax2,
 986               Int_t med);
 987     virtual void Cone(AliITSConeData &d,Int_t med);
 988     // Segment of a Cone.
 989     virtual void ConeSegment(const char *gnam,const TString &dis,Double_t dz,
 990                      Double_t rmin1,Double_t rmax1,Double_t rmin2,
 991                      Double_t rmax2,Double_t phi1,Double_t phi2,Int_t med);
 992     virtual void ConeSegment(AliITSConeSegData &d,Int_t med);
 993     //Poly-Cone
 994     virtual void PolyCone(const char *gnam,const TString &dis,Double_t phi1,
 995                   Double_t dphi,Int_t nz,Double_t *z,Double_t *rmin,
 996                   Double_t *rmax,Int_t med);
 997     virtual void PolyCone(AliITSPConeData &d,Int_t med);
 998     // Spherical shell segment.
 999     virtual void Sphere(const char *gnam,const TString &dis,Double_t rmin,
1000                 Double_t rmax,Double_t the1,Double_t the2,Double_t phi1,
1001                 Double_t phi2,Int_t med);
1002     virtual void Sphere(AliITSSphereData &d,Int_t med);
1003     // Parallelepiped.
1004     virtual void Parallelepiped(const char *gnam,const TString &dis,
1005                                 Double_t dx,Double_t dy,Double_t dz,
1006                                 Double_t alph,Double_t thet,
1007                                 Double_t phi,Int_t med);
1008     virtual void Parallelepiped(AliITSParallelpipedData &d,Int_t med);
1009     // Polygon.
1010     virtual void PolyGon(const char *gnam,const TString &dis,Double_t phi1,
1011                  Double_t dphi,Int_t npdv,Int_t nz,Double_t *z,Double_t *rmin,
1012                  Double_t *rmax,Int_t med);
1013     virtual void PolyGon(AliITSPGonData &d,Int_t med);
1014     // Position one volume inside another
1015     virtual void Pos(const char *vol,Int_t cn,const char *moth,Double_t x,
1016              Double_t y,Double_t z,Int_t irot);
1017     // Position one volume inside another
1018     virtual void Pos(AliITSBaseVolParams &v,Int_t cn,
1019              AliITSBaseVolParams &m,TVector3 &t,Int_t irot);
1020     // Position one volume inside another
1021     virtual void Pos(AliITSBaseVolParams &v,AliITSBaseVolParams &m,
1022                      TVector3 &t,Int_t irot){Pos(v,m.GetG3cpn(),m,t,irot);};
1023     Int_t GetMed(Int_t med){return (fits->GetIdtmed())->At(med);}
1024     // Define rotation matrix
1025     void Matrix(Int_t irot,Double_t thet1,Double_t phi1,Double_t thet2,
1026                 Double_t phi2,Double_t thet3,Double_t phi3);
1027     // Defube ritatuib matrix
1028     void Matrix(Int_t irot,Double_t rot[3][3]);
1029     // Rotation matrix about axis i (i=0=>x, i=1=>y, i=2=>z).
1030     void Matrix(Int_t irot,Int_t axis,Double_t thet);
1031     // Rotation matrix about x axis
1032     void XMatrix(Int_t irot,Double_t thet){Matrix(irot,0,thet);}
1033     // Rotation matrix about y axis
1034     void YMatrix(Int_t irot,Double_t thet){Matrix(irot,1,thet);}
1035     // Rotation matrix about z axis
1036     void ZMatrix(Int_t irot,Double_t thet){Matrix(irot,2,thet);}
1037     // Define Element material and medium
1038     void Element(Int_t imat,const char *name,Int_t z,Double_t den,Int_t istd);
1039     // Define Material by constituant weights
1040     void MixtureByWeight(Int_t imat,const char *name,Int_t *z,Double_t *w,
1041                          Double_t dens,Int_t nelments,Int_t istd);
1042     // Define Material by constituant relative number
1043     void MixtureByNumber(Int_t imat,const char *name,Int_t *z,Int_t *i,
1044                          Double_t dens,Int_t nelments,Int_t istd);
1045     // Returns standard radiation lenghts of elements.
1046     Float_t GetRadLength(Int_t z){return RadLength(z,(Double_t)GetA(z));}
1047     // Returns natrual abundance atomic mass numbers for a given element
1048     Float_t GetA(Int_t z);
1049     // Returns ITS standard Theata Max transport cut values
1050     Float_t GetStandardThetaMax(Int_t istd);
1051     // Returns ITS standard Max step size transport cut values
1052     Float_t GetStandardMaxStepSize(Int_t istd);
1053     // Returns ITS standard frational energy transport cut values
1054     Float_t GetStandardEfraction(Int_t istd);
1055     // Returns ITS standard epsilon transport cut values
1056     Float_t GetStandardEpsilon(Int_t istd);
1057     // Degree Versions of TMath functions (as needed)
1058     Double_t Sind(Double_t t){return TMath::Sin(TMath::Pi()*t/180.);}
1059     Double_t Cosd(Double_t t){return TMath::Cos(TMath::Pi()*t/180.);}
1060     Double_t Tand(Double_t t){return TMath::Tan(TMath::Pi()*t/180.);}
1061     Double_t ASind(Double_t t){return 180.0*TMath::ASin(t)/TMath::Pi();}
1062     Double_t ACosd(Double_t t){return 180.0*TMath::ACos(t)/TMath::Pi();}
1063     Double_t ATand(Double_t t){return 180.0*TMath::ATan(t)/TMath::Pi();}
1064     Double_t ATand2(Double_t y,Double_t x){return 180.0*TMath::ATan2(y,x)/
1065                                                TMath::Pi();}
1066     // gives angles in degree between 0.<=t<360.
1067     Double_t Mod360(Double_t t){if(t>=360.) return Mod360(t-360.);
1068         if(t<0.0) return Mod360(t+360.);return t;}
1069     Double_t RadLength(Int_t iz,Double_t a); // Computes radiation length
1070                                              // for an element
1071  private:
1072     void G3name(const char *gname,char *name)//Add's I to name and ending null
1073         {for(Int_t i=0;i<3;i++) name[i+1] = gname[i];
1074         name[0]='I';name[4]='\0';}
1075     //
1076  protected:
1077     static Int_t fNCreates; //! Counts the number of time this class has
1078     // been created.
1079     static const Double_t fAlpha; //! find structure constant
1080     static const Double_t fRe; //![cm]classical elect. radius
1081     static const Double_t fNa; //! [#/mole] Avogadro's number
1082     static Int_t *fidrot;
1083     static Int_t fidrotsize;
1084     static Int_t fidrotlast;
1085     static TString *fVolName; // Array of ITS Volumen names.
1086     static Int_t fVolNameSize; // Size of Array fVolName
1087     static Int_t fVolNameLast; // Last filled element of fVolName
1088     Double_t fScale; // Scale factor (=1=>[cm]).
1089     AliModule *fits; // local pointer to ITS module needed for AliMixture...
1090
1091     ClassDef(AliITSBaseGeometry,1) // Basic ITS Geometry class
1092 };
1093
1094 #endif
1095