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