New version and structure of ITS V11 geometry. Work still in progress.
[u/mrichter/AliRoot.git] / ITS / AliITSBaseGeometry.cxx
1 /**************************************************************************
2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3  *                                                                        *
4  * Author: The ALICE Off-line Project.                                    *
5  * Contributors are mentioned in the code where appropriate.              *
6  *                                                                        *
7  * Permission to use, copy, modify and distribute this software and its   *
8  * documentation strictly for non-commercial purposes is hereby granted   *
9  * without fee, provided that the above copyright notice appears in all   *
10  * copies and that both the copyright notice and this permission notice   *
11  * appear in the supporting documentation. The authors make no claims     *
12  * about the suitability of this software for any purpose. It is          *
13  * provided "as is" without express or implied warranty.                  *
14  **************************************************************************/
15
16 /*
17 $Log$
18
19 $Id$
20 */
21
22 /*
23   A base geometry class defining all of the ITS volumes that make up an ITS
24 geometry.
25 Auhors: B. S. Nilsen
26 Version 0
27 Created February 2003.
28 */
29
30 #include <Riostream.h>
31 #include <stdio.h>
32 #include <stdlib.h>
33 #include <string.h>
34 #include <TMath.h>
35 #include <TGeometry.h>
36 #include <TNode.h>
37 #include <TTUBE.h>
38 #include <TTUBS.h>
39 #include <TPCON.h>
40 #include <TFile.h>    // only required for Tracking function?
41 #include <TCanvas.h>
42 #include <TObjArray.h>
43 #include <TLorentzVector.h>
44 #include <TObjString.h>
45 #include <TClonesArray.h>
46 #include <TBRIK.h>
47 #include <TSystem.h>
48 #include <AliRun.h>
49 #include <AliMagF.h>
50 #include <AliConst.h>
51 #include "AliITSBaseGeometry.h"
52
53 ClassImp(AliITSBaseGeometry)
54 //______________________________________________________________________
55 AliITSBaseGeometry::AliITSBaseGeometry(){
56     // Default construtor for the ITS Base Geometry class.
57     // Inputs:
58     //    none.
59     // Outputs:
60     //    none.
61     // Return:
62     //    none.
63
64     fScale = 1.0; // Default value.
65     fits = 0; // zero pointers.
66     fNCreates++; // incrament this creation counter.
67 }
68 //______________________________________________________________________
69 AliITSBaseGeometry::AliITSBaseGeometry(AliModule *its,Int_t iflag){
70     // Standard construtor for the ITS Base Geometry class.
71     // Inputs:
72     //    Int_t iflag  flag to indecate specific swiches in the geometry
73     // Outputs:
74     //    none.
75     // Return:
76     //    none.
77
78     fScale = 1.0; // Default value.
79     fits = its; // get a copy of the pointer to the ITS.
80     fNCreates++; // incrament this creation counter.
81 }
82 //______________________________________________________________________
83 AliITSBaseGeometry::~AliITSBaseGeometry(){
84     // Standeard destructor for the ITS Base Geometry class.
85     // Inputs:
86     //    Int_t iflag  flag to indecate specific swiches in the geometry
87     // Outputs:
88     //    none.
89     // Return:
90     //    none.
91
92     fits = 0; // This class does not own this class. It contaitns a pointer
93     // to it for conveniance.
94     fidmed = 0; // This class does not own this array of media indexs. It
95     fNCreates--;
96     if(fNCreates==0){ // Now delete the static members
97         Int_t i;
98         if(fVolName!=0){
99             for(i=0;i<fVolNameLast;i++) delete fVolName[i];
100             fVolNameSize = 0;
101             fVolNameLast = 0;
102             delete[] fVolName;
103         }// end if
104         delete[] fidrot;
105         fidrotsize = fidrotlast = 0;
106     }// end if
107 }
108 //______________________________________________________________________
109 Int_t AliITSBaseGeometry::AddVolName(const TString name){
110     // Checks if the volume name already exist, if not it adds it to
111     // the list of volume names and returns an index to that volume name.
112     // it will create and expand the array of volume names as needed.
113     // If the volume name already exists, it will give an error message and
114     // return an index <0.
115     // Inputs:
116     //    const TString name  Volume name to be added to the list.
117     // Outputs:
118     //    none.
119     // Return:
120     //    The index where this volume name is stored.
121     Int_t i;
122
123     if(fVolName==0){ // must create array.
124         fVolNameSize = 1000;
125         fVolName = new TString[fVolNameSize];
126         fVolNameLast = 0;
127     } // end if
128     for(i=0;i<fVolNameLast;i++) if(fVolName[i].CompareTo(name)==0){ // Error
129         Error("AddVolName","Volume name already exists for volume %d",i);
130         return -1;
131     } // end for i
132     if(fVolNameSize==fVolNameLast-1){ // Array is full must expand.
133         Int_t size = fVolNameSize*2;
134         TString *old = fVolName;
135         fVolName = new TString[fVolNameSize];
136         for(i=0;i<fVolNameLast;i++) fVolName[i] = old[i];
137         delete[] old;
138         fVolNameSize = size;
139     } // end if
140     if(strcmp(ITSIndexToITSG3name(fVolNameLast),"ITSV")==0){
141         // Special Reserved Geant 3 volumen name. Skip it
142         // fill it with explination for conveniance.
143         fVolName[fVolNameLast] = "ITS Master Mother Volume";
144         fVolNameLast++;
145     } // end if
146     fVolName[fVolNameLast] = name;
147     fVolNameLast++;
148     return fVolNameLast-1; // return the index
149 }
150 //______________________________________________________________________
151 char* AliITSBaseGeometry::ITSIndexToITSG3name(const Int_t i){
152     // Given the ITS volume index i, it returns the Geant3 ITS volume
153     // name. The valid characters must be in the range
154     // '0' through 'Z'. This will include all upper case letter and the
155     // numbers 0-9. In addition it does not will include the following simbols
156     // ":;<=>?@"
157     // Inputs:
158     //    const Int_t i  the ITS volume index
159     // Output:
160     //    none.
161     // Return:
162     //    char[4] with the ITS volume name starting from "I000" to "IZZZ"
163     const Int_t rangen=(Int_t)('9'-'0'+1); // range of numbers
164     const Int_t rangel=(Int_t)('Z'-'A'+1); // range of letters
165     const Int_t range = rangen+rangel; // the number of characters between 
166                                        // 0-9 and A-Z.
167     char a[4];
168     Int_t j = i;
169
170     a[0] = (char)('I');
171     a[1] = (char)('0'+j/(range*range));
172     if(a[1]>'9') a[1] += 'A'-'0'; // if it is a letter add in gap for simples.
173     j -= range*range*(a[1]-'0');
174     a[2] = (char)('0'+j/range);
175     if(a[2]>'9') a[2] += 'A'-'0'; // if it is a letter add in gap for simples.
176     j -= range*(a[2]-'0');
177     a[3] = (char)('0'+j);
178     if(a[3]>'9') a[3] += 'A'-'0'; // if it is a letter add in gap for simples.
179     return a;
180 }
181 //______________________________________________________________________
182 Int_t AliITSBaseGeometry::ITSG3VnameToIndex(const char name[3])const{
183     // Given the last three characters of the ITS Geant3 volume name,
184     // this returns the index. The valid characters must be in the range
185     // '0' through 'Z'. This will include all upper case letter and the
186     // numbers 0-9. In addition it will include the following simbles
187     // ":;<=>?@"
188     // Inputs:
189     //    const char name[3]  The last three characters of the ITS Geant3
190     //                        volume name
191     // Output:
192     //    none.
193     // Return:
194     //    Int_t the index.
195     const Int_t rangen=(Int_t)('9'-'0'+1); // range of numbers
196     const Int_t rangel=(Int_t)('Z'-'A'+1); // range of letters
197     const Int_t range = rangen+rangel; // the number of characters between 
198                                        // 0-9 and A-Z.
199     Int_t i,j;
200
201     i = 0;
202     for(j=3;j>-1;j--){
203         if(isdigit(name[j])){ // number
204             i += (Int_t)(name[j]-'0')*TMath::Power(range,(Double_t)j);
205         }else{ // Letter
206             i += (Int_t)(name[j]-'A'+rangen)*TMath::Power(range,(Double_t)j);
207         } // end if
208     } // end for j
209     return i;
210 }
211 //______________________________________________________________________
212 TString AliITSBaseGeometry::GetVolName(const Int_t i)const{
213     // Returns the volume name at a given index i. Index must be in
214     // range and the array of volume names must exist. If there is an
215     // error, a message is written and 0 is returned.
216     // Inputs:
217     //   const Int_t i Index
218     // Output:
219     //   none.
220     // Return:
221     //   A TString contianing the ITS volume name.
222
223     if(i<0||i>=fVolNameLast){
224         Error("GetVolName","Index=%d out of range but be witin 0<%d",i,
225               fVolName-1);
226         return 0;
227     } // end if Error
228     return fVolName[i];
229 }
230 //______________________________________________________________________
231 Int_t AliITSBaseGeometry::GetVolumeIndex(const TString &a){
232     // Return the index corresponding the the volume name a. If the
233     // Volumen name is not found, return -1, and a warning message given.
234     // Inputs:
235     //   const TString &a  Name of volume for which index is wanted.
236     // Output:
237     //   none.
238     // Return:
239     //   Int_t Index corresponding the volume a. If not found -1 is returned.
240     Int_t i;
241
242     for(i=0;i<fVolNameLast;i++) if(fVolName[i].CompareTo(a)==0) return i;
243     Info("GetVolumeIndex","Volume name %s not found",a.Data());
244     return -1;
245 }
246 //______________________________________________________________________
247 void AliITSBaseGeometry::Box(const char gnam[3],const TString &dis,
248                              Double_t dx,Double_t dy,Double_t dz,Int_t med){
249     // Interface to TMC->Gsvolu() for ITS bos geometries. Box with faces
250     // perpendicular to the axes. It has 3 paramters. See SetScale() for
251     // units. Default units are geant 3 [cm].
252     // Inputs:
253     //    const char gnam[3]  3 character geant volume name. The letter "I"
254     //                        is appended to the front to indecate that this
255     //                        is an ITS volume.
256     //    TString &dis        String containging part discription.
257     //    Double_t dx         half-length of box in x-axis
258     //    Double_t dy         half-length of box in y-axis
259     //    Double_t dz         half-length of box in z-axis
260     //    Int_t    med        media index number.
261     // Output:
262     //    none.
263     // Return.
264     //    none.
265     char name[4];
266     Float_t param[3];
267
268     if(fidmed==0) SetMedArray();
269     param[0] = fScale*dx;
270     param[1] = fScale*dy;
271     param[2] = fScale*dz;
272     name[3] = 'I';
273     for(Int_t i=0;i<3;i++) name[i+1] = gnam[i];
274     gMC->Gsvolu(name,"BOX ",fidmed[med],param,3);
275 }
276 //______________________________________________________________________
277 void AliITSBaseGeometry::Trapezoid1(const char gnam[3],const TString &dis,
278                                     Double_t dxn,Double_t dxp,Double_t dy,
279                                     Double_t dz,Int_t med){
280     // Interface to TMC->Gsvolu() for ITS TRD1 geometries. Trapezoid with the 
281     // x dimension varing along z. It has 4 parameters. See SetScale() for
282     // units. Default units are geant 3 [cm].
283     // Inputs:
284     //    const char gnam[3]  3 character geant volume name. The letter "I"
285     //                        is appended to the front to indecate that this
286     //                        is an ITS volume.
287     //    TString &dis        String containging part discription.
288     //    Double_t dxn        half-length along x at the z surface positioned 
289     //                        at -DZ
290     //    Double_t dxp        half-length along x at the z surface positioned 
291     //                        at +DZ
292     //    Double_t dy         half-length along the y-axis
293     //    Double_t dz         half-length along the z-axis
294     //    Int_t    med        media index number.
295     // Output:
296     //    none.
297     // Return.
298     //    none.
299     char name[4];
300     Float_t param[4];
301
302     if(fidmed==0) SetMedArray();
303     param[0] = fScale*dxn;
304     param[1] = fScale*dxp;
305     param[2] = fScale*dy;
306     param[3] = fScale*dz;
307     name[3] = 'I';
308     for(Int_t i=0;i<3;i++) name[i+1] = gnam[i];
309     gMC->Gsvolu(name,"TRD1",fidmed[med],param,4);
310 }
311 //______________________________________________________________________
312 void AliITSBaseGeometry::Trapezoid2(const char gnam[3],const TString &dis,
313                                     Double_t dxn,Double_t dxp,Double_t dyn,
314                                     Double_t dyp,Double_t dz,Int_t med){
315     // Interface to TMC->Gsvolu() for ITS TRD2 geometries. Trapezoid with the 
316     // x and y dimension varing along z. It has 5 parameters. See SetScale() 
317     // for units. Default units are geant 3 [cm].
318     // Inputs:
319     //    const char gnam[3]  3 character geant volume name. The letter "I"
320     //                        is appended to the front to indecate that this
321     //                        is an ITS volume.
322     //    TString &dis        String containging part discription.
323     //    Double_t dxn        half-length along x at the z surface positioned 
324     //                        at -DZ
325     //    Double_t dxp        half-length along x at the z surface positioned 
326     //                        at +DZ
327     //    Double_t dyn        half-length along x at the z surface positioned 
328     //                        at -DZ
329     //    Double_t dyp        half-length along x at the z surface positioned 
330     //                        at +DZ
331     //    Double_t dz         half-length along the z-axis
332     //    Int_t    med        media index number.
333     // Output:
334     //    none.
335     // Return.
336     //    none.
337     char name[4];
338     Float_t param[5];
339
340     if(fidmed==0) SetMedArray();
341     param[0] = fScale*dxn;
342     param[1] = fScale*dxp;
343     param[2] = fScale*dyn;
344     param[3] = fScale*dyp;
345     param[4] = fScale*dz;
346     name[3] = 'I';
347     for(Int_t i=0;i<3;i++) name[i+1] = gnam[i];
348     gMC->Gsvolu(name,"TRD2",fidmed[med],param,5);
349 }
350 //______________________________________________________________________
351 void AliITSBaseGeometry::Trapezoid(const char gnam[3],const TString &dis,
352                                    Double_t dz,Double_t thet,Double_t phi,
353                                    Double_t h1,Double_t bl1,Double_t tl1,
354                                    Double_t alp1,Double_t h2,Double_t bl2,
355                                    Double_t tl2,Double_t alp2,Int_t med){
356     // Interface to TMC->Gsvolu() for ITS TRAP geometries. General Trapezoid, 
357     // The faces perpendicular to z are trapezia and their centers are not 
358     // necessarily on a line parallel to the z axis. This shape has 11 
359     // parameters, but only cosidering that the faces should be planar, only 9 
360     // are really independent. A check is performed on the user parameters and 
361     // a message is printed in case of non-planar faces. Ignoring this warning 
362     // may cause unpredictable effects at tracking time. See SetScale() 
363     // for units. Default units are geant 3 [cm].
364     // Inputs:
365     //    const char gnam[3]  3 character geant volume name. The letter "I"
366     //                        is appended to the front to indecate that this
367     //                        is an ITS volume.
368     //    TString &dis        String containging part discription.
369     //    Double_t dz         Half-length along the z-asix
370     //    Double_t thet       Polar angle of the line joing the center of the 
371     //                        face at -dz to the center of the one at dz 
372     //                        [degree].
373     //    Double_t phi        aximuthal angle of the line joing the center of 
374     //                        the face at -dz to the center of the one at +dz 
375     //                        [degree].
376     //    Double_t h1         half-length along y of the face at -dz.
377     //    Double_t bl1        half-length along x of the side at -h1 in y of 
378     //                        the face at -dz in z.
379     //    Double_t tl1        half-length along x of teh side at +h1 in y of 
380     //                        the face at -dz in z.
381     //    Double_t alp1       angle with respect to the y axis from the center 
382     //                        of the side at -h1 in y to the cetner of the 
383     //                        side at +h1 in y of the face at -dz in z 
384     //                        [degree].
385     //    Double_t h2         half-length along y of the face at +dz
386     //    Double_t bl2        half-length along x of the side at -h2 in y of
387     //                        the face at +dz in z.
388     //    Double_t tl2        half-length along x of the side at _h2 in y of 
389     //                        the face at +dz in z.
390     //    Double_t alp2       angle with respect to the y axis from the center 
391     //                        of the side at -h2 in y to the center of the 
392     //                        side at +h2 in y of the face at +dz in z 
393     //                        [degree].
394     //    Int_t    med        media index number.
395     // Output:
396     //    none.
397     // Return.
398     //    none.
399     char name[4];
400     Float_t param[11];
401
402     if(fidmed==0) SetMedArray();
403     param[0] = fScale*dz;
404     param[1] = thet;
405     param[2] = phi;
406     param[3] = fScale*h1;
407     param[4] = fScale*bl1;
408     param[5] = fScale*tl1;
409     param[6] = alp1;
410     param[7] = fScale*h2;
411     param[8] = fScale*bl2;
412     param[9] = fScale*tl2;
413     param[10] = alp2;
414     name[3] = 'I';
415     for(Int_t i=0;i<3;i++) name[i+1] = gnam[i];
416     gMC->Gsvolu(name,"TRAP",fidmed[med],param,11);
417 }
418 //______________________________________________________________________
419 void AliITSBaseGeometry::Tube(const char gnam[3],const TString &dis,
420                               Double_t rmin,Double_t rmax,Double_t dz,
421                               Int_t med){
422     // Interface to TMC->Gsvolu() for ITS TUBE geometries. Simple Tube. It has
423     // 3 parameters. See SetScale() 
424     // for units. Default units are geant 3 [cm].
425     // Inputs:
426     //    const char gnam[3]  3 character geant volume name. The letter "I"
427     //                        is appended to the front to indecate that this
428     //                        is an ITS volume.
429     //    TString &dis        String containging part discription.
430     //    Double_t rmin       Inside Radius.
431     //    Double_t rmax       Outside Radius.
432     //    Double_t dz         half-length along the z-axis
433     //    Int_t    med        media index number.
434     // Output:
435     //    none.
436     // Return.
437     //    none.
438     char name[4];
439     Float_t param[3];
440
441     if(fidmed==0) SetMedArray();
442     param[0] = fScale*rmin;
443     param[1] = fScale*rmax;
444     param[2] = fScale*dz;
445     name[3] = 'I';
446     for(Int_t i=0;i<3;i++) name[i+1] = gnam[i];
447     gMC->Gsvolu(name,"TUBE",fidmed[med],param,3);
448 }
449 //______________________________________________________________________
450 void AliITSBaseGeometry::TubeSegment(const char gnam[3],const TString &dis,
451                                      Double_t rmin,Double_t rmax,Double_t dz,
452                                      Double_t phi1,Double_t phi2,Int_t med){
453     // Interface to TMC->Gsvolu() for ITS TUBE geometries. Phi segment of a 
454     // tube. It has 5  parameters. Phi1 should be smaller than phi2. If this is
455     // not the case, the system adds 360 degrees to phi2. See SetScale() 
456     // for units. Default units are geant 3 [cm].
457     // Inputs:
458     //    const char gnam[3]  3 character geant volume name. The letter "I"
459     //                        is appended to the front to indecate that this
460     //                        is an ITS volume.
461     //    TString &dis        String containging part discription.
462     //    Double_t rmin       Inside Radius.
463     //    Double_t rmax       Outside Radius.
464     //    Double_t dz         half-length along the z-axis
465     //    Double_t phi1       Starting angle of the segment [degree].
466     //    Double_t phi2       Ending angle of the segment [degree].
467     //    Int_t    med        media index number.
468     // Output:
469     //    none.
470     // Return.
471     //    none.
472     char name[4];
473     Float_t param[5];
474
475     if(fidmed==0) SetMedArray();
476     param[0] = fScale*rmin;
477     param[1] = fScale*rmax;
478     param[2] = fScale*dz;
479     param[3] = phi1;
480     param[4] = phi2;
481     name[3] = 'I';
482     for(Int_t i=0;i<3;i++) name[i+1] = gnam[i];
483     gMC->Gsvolu(name,"TUBS",fidmed[med],param,5);
484 }
485 //______________________________________________________________________
486 void AliITSBaseGeometry::Cone(const char gnam[3],const TString &dis,
487                               Double_t dz,Double_t rmin1,Double_t rmax1,
488                               Double_t rmin2,Double_t rmax2,Int_t med){
489     // Interface to TMC->Gsvolu() for ITS Cone geometries. Conical tube. It 
490     // has 5 parameters. See SetScale() 
491     // for units. Default units are geant 3 [cm].
492     // Inputs:
493     //    const char gnam[3]  3 character geant volume name. The letter "I"
494     //                        is appended to the front to indecate that this
495     //                        is an ITS volume.
496     //    TString &dis        String containging part discription.
497     //    Double_t dz         half-length along the z-axis
498     //    Double_t rmin1      Inside Radius at -dz.
499     //    Double_t rmax1      Outside Radius at -dz.
500     //    Double_t rmin2      inside radius at +dz.
501     //    Double_t rmax2      outside radius at +dz.
502     //    Int_t    med        media index number.
503     // Output:
504     //    none.
505     // Return.
506     //    none.
507     char name[4];
508     Float_t param[5];
509
510     if(fidmed==0) SetMedArray();
511     param[0] = fScale*dz;
512     param[1] = fScale*rmin1;
513     param[2] = fScale*rmax1;
514     param[3] = fScale*rmin2;
515     param[4] = fScale*rmax2;
516     name[3] = 'I';
517     for(Int_t i=0;i<3;i++) name[i+1] = gnam[i];
518     gMC->Gsvolu(name,"CONS",fidmed[med],param,5);
519 }
520 //______________________________________________________________________
521 void AliITSBaseGeometry::ConeSegment(const char gnam[3],const TString &dis,
522                                      Double_t dz,Double_t rmin1,Double_t rmax1,
523                                      Double_t rmin2,Double_t rmax2,
524                                      Double_t phi1,Double_t phi2,Int_t med){
525     // Interface to TMC->Gsvolu() for ITS ConS geometries. One segment of a 
526     // conical tube. It has 7 parameters. Phi1 should be smaller than phi2. If 
527     // this is not the case, the system adds 360 degrees to phi2. See 
528     // SetScale() for units. Default units are geant 3 [cm].
529     // Inputs:
530     //    const char gnam[3]  3 character geant volume name. The letter "I"
531     //                        is appended to the front to indecate that this
532     //                        is an ITS volume.
533     //    TString &dis        String containging part discription.
534     //    Double_t dz         half-length along the z-axis
535     //    Double_t rmin1      Inside Radius at -dz.
536     //    Double_t rmax1      Outside Radius at -dz.
537     //    Double_t rmin2      inside radius at +dz.
538     //    Double_t rmax2      outside radius at +dz.
539     //    Double_t phi1       Starting angle of the segment [degree].
540     //    Double_t phi2       Ending angle of the segment [degree].
541     //    Int_t    med        media index number.
542     // Output:
543     //    none.
544     // Return.
545     //    none.
546     char name[4];
547     Float_t param[7];
548
549     if(fidmed==0) SetMedArray();
550     param[0] = fScale*dz;
551     param[1] = fScale*rmin1;
552     param[2] = fScale*rmax1;
553     param[3] = fScale*rmin2;
554     param[4] = fScale*rmax2;
555     param[5] = phi1;
556     param[6] = phi2;
557     name[3] = 'I';
558     for(Int_t i=0;i<3;i++) name[i+1] = gnam[i];
559     gMC->Gsvolu(name,"CONS",fidmed[med],param,7);
560 }
561 //______________________________________________________________________
562 void AliITSBaseGeometry::Sphere(const char gnam[3],const TString &dis,
563                                 Double_t rmin,Double_t rmax,Double_t the1,
564                                 Double_t the2,Double_t phi1,Double_t phi2,
565                                 Int_t med){
566     // Interface to TMC->Gsvolu() for ITS SPHE geometries. Segment of a 
567     // sphereical shell. It has 6 parameters. See SetScale() 
568     // for units. Default units are geant 3 [cm].
569     // Inputs:
570     //    const char gnam[3]  3 character geant volume name. The letter "I"
571     //                        is appended to the front to indecate that this
572     //                        is an ITS volume.
573     //    TString &dis        String containging part discription.
574     //    Double_t rmin       Inside Radius.
575     //    Double_t rmax       Outside Radius.
576     //    Double_t the1       staring polar angle of the shell [degree].
577     //    Double_t the2       ending polar angle of the shell [degree].
578     //    Double_t phui       staring asimuthal angle of the shell [degree].
579     //    Double_t phi2       ending asimuthal angle of the shell [degree].
580     //    Int_t    med        media index number.
581     // Output:
582     //    none.
583     // Return.
584     //    none.
585     char name[4];
586     Float_t param[6];
587
588     if(fidmed==0) SetMedArray();
589     param[0] = fScale*rmin;
590     param[1] = fScale*rmax;
591     param[2] = the1;
592     param[3] = the2;
593     param[4] = phi1;
594     param[5] = phi2;
595     name[3] = 'I';
596     for(Int_t i=0;i<3;i++) name[i+1] = gnam[i];
597     gMC->Gsvolu(name,"SPHE",fidmed[med],param,6);
598 }
599 //______________________________________________________________________
600 void AliITSBaseGeometry::Parallelepiped(const char gnam[3],const TString &dis,
601                                         Double_t dx,Double_t dy,Double_t dz,
602                                         Double_t alpha,Double_t thet,
603                                         Double_t phi,Int_t med){
604     // Interface to TMC->Gsvolu() for ITS PARA geometries. Parallelepiped. It 
605     // has 6 parameters. See SetScale() for units. Default units are geant 3 
606     // [cm].
607     // Inputs:
608     //    const char gnam[3]  3 character geant volume name. The letter "I"
609     //                        is appended to the front to indecate that this
610     //                        is an ITS volume.
611     //    TString &dis        String containging part discription.
612     //    Double_t dx         half-length allong x-axis
613     //    Double_t dy         half-length allong y-axis
614     //    Double_t dz         half-length allong z-axis
615     //    Double_t alpha      angle formed by the y axis and by the plane 
616     //                        joining the center of teh faces parallel to the 
617     //                        z-x plane at -dY and +dy [degree].
618     //    Double_t thet       polar angle of the line joining the centers of 
619     //                        the faces at -dz and +dz in z [degree].
620     //    Double_t phi        azimuthal angle of teh line joing the centers of 
621     //                        the faaces at -dz and +dz in z [degree].
622     //    Int_t    med        media index number.
623     // Output:
624     //    none.
625     // Return.
626     //    none.
627     char name[4];
628     Float_t param[6];
629
630     if(fidmed==0) SetMedArray();
631     param[0] = fScale*dx;
632     param[1] = fScale*dy;
633     param[2] = fScale*dz;
634     param[3] = alpha;
635     param[4] = thet;
636     param[5] = phi;
637     name[3] = 'I';
638     for(Int_t i=0;i<3;i++) name[i+1] = gnam[i];
639     gMC->Gsvolu(name,"PARA",fidmed[med],param,6);
640 }
641 //______________________________________________________________________
642 void AliITSBaseGeometry::Polygon(const char gnam[3],const TString &dis,
643                                  Double_t phi1,Double_t dphi,Int_t npdv,
644                                  Int_t nz,Double_t *z,Double_t *rmin,
645                                  Double_t *rmax,Int_t med){
646     // Interface to TMC->Gsvolu() for ITS PGON geometry. Polygon It has 10 
647     // parameters or more. See SetScale() for units. Default units are geant 3 
648     // [cm].
649     // Inputs:
650     //    const char gnam[3]  3 character geant volume name. The letter "I"
651     //                        is appended to the front to indecate that this
652     //                        is an ITS volume.
653     //    TString &dis        String containging part discription.
654     //    Double_t phi1       the azimuthal angle at which the volume begins 
655     //                        (angles are counted clouterclockwise) [degrees].
656     //    Double_t dphi       opening angle of the volume, which extends from 
657     //                        phi1 to phi1+dphi [degree].
658     //    Int_t npdv          the number of sides of teh cross section between 
659     //                        the given phi limits.
660     //    Int_t nz            number of planes perpendicular to the z axis 
661     //                        where the dimension of the section is given - 
662     //                        this number should be at least 2 and NP triples 
663     //                        of number must follow.
664     //    Double_t *z         array [nz] of z coordiates of the sections..
665     //    Double_t *rmin      array [nz] of radius of teh circle tangent to 
666     //                        the sides of the inner polygon in teh 
667     //                        cross-section.
668     //    Double_t *rmax      array [nz] of radius of the circle tangent to 
669     //                        the sides of the outer polygon in the 
670     //                       cross-section.
671     //    Int_t    med        media index number.
672     // Output:
673     //    none.
674     // Return.
675     //    none.
676     char name[4];
677     Float_t *param;
678     Int_t n,i;
679
680     if(fidmed==0) SetMedArray();
681     n = 4+3*nz;
682     param = new Float_t[n];
683     param[0] = phi1;
684     param[1] = dphi;
685     param[2] = (Float_t)npdv;
686     param[3] = (Float_t)nz;
687     for(i=0;i<nz;i++){
688         param[4+3*i] = z[i];
689         param[5+3*i] = rmin[i];
690         param[6+3*i] = rmax[i];
691     } // end for i
692     name[3] = 'I';
693     for(i=0;i<3;i++) name[i+1] = gnam[i];
694     gMC->Gsvolu(name,"PGON",fidmed[med],param,n);
695
696     delete[] param;
697 }
698 //______________________________________________________________________
699 void AliITSBaseGeometry::PolyCone(const char gnam[3],const TString &dis,
700                                   Double_t phi1,Double_t dphi,Int_t nz,
701                                   Double_t *z,Double_t *rmin,Double_t *rmax,
702                                   Int_t med){
703     // Interface to TMC->Gsvolu() for ITS PCON geometry. Poly-cone It has 9 
704     // parameters or more. See SetScale() for units. Default units are geant 3 
705     // [cm].
706     // Inputs:
707     //    const char gnam[3]  3 character geant volume name. The letter "I"
708     //                        is appended to the front to indecate that this
709     //                        is an ITS volume.
710     //    TString &dis        String containging part discription.
711     //    Double_t phi1       the azimuthal angle at which the volume begins 
712     //                        (angles are counted clouterclockwise) [degrees].
713     //    Double_t dphi       opening angle of the volume, which extends from 
714     //                        phi1 to phi1+dphi [degree].
715     //    Int_t nz            number of planes perpendicular to the z axis 
716     //                        where the dimension of the section is given - 
717     //                        this number should be at least 2 and NP triples 
718     //                        of number must follow.
719     //    Double_t *z         Array [nz] of z coordinate of the section.
720     //    Double_t *rmin      Array [nz] of radius of teh inner circle in the 
721     //                        cross-section.
722     //    Double_t *rmax      Array [nz] of radius of the outer circle in the 
723     //                        cross-section.
724     //    Int_t    med        media index number.
725     // Output:
726     //    none.
727     // Return.
728     //    none.
729     char name[4];
730     Float_t *param;
731     Int_t n,i;
732
733     if(fidmed==0) SetMedArray();
734     n = 3+3*nz;
735     param = new Float_t[n];
736     param[0] = phi1;
737     param[1] = dphi;
738     param[2] = (Float_t) nz;
739     for(i=0;i<nz;i++){
740         param[3+3*i] = z[i];
741         param[4+3*i] = rmin[i];
742         param[5+3*i] = rmax[i];
743     } // end for i
744     name[3] = 'I';
745     for(i=0;i<3;i++) name[i+1] = gnam[i];
746     gMC->Gsvolu(name,"PCON",fidmed[med],param,n);
747
748     delete[] param;
749 }
750 //______________________________________________________________________
751 void AliITSBaseGeometry::TubeElliptical(const char gnam[3],const TString &dis,
752                                Double_t p1,Double_t p2,Double_t dz,Int_t med){
753     // Interface to TMC->Gsvolu() for ITS ELTU geometries. Elliptical 
754     // cross-section Tube. It has 3 parameters. See SetScale() 
755     // for units. Default units are geant 3 [cm]. The equation of the surface 
756     // is x^2 * p1^-2 + y^2 * p2^-2 = 1.
757     // Inputs:
758     //    const char gnam[3]  3 character geant volume name. The letter "I"
759     //                        is appended to the front to indecate that this
760     //                        is an ITS volume.
761     //    TString &dis        String containging part discription.
762     //    Double_t p1         semi-axis of the elipse along x.
763     //    Double_t p2         semi-axis of the elipse along y.
764     //    Double_t dz         half-length along the z-axis
765     //    Int_t    med        media index number.
766     // Output:
767     //    none.
768     // Return.
769     //    none.
770     char name[4];
771     Float_t param[3];
772
773     if(fidmed==0) SetMedArray();
774     param[0] = fScale*p1;
775     param[1] = fScale*p2;
776     param[2] = fScale*dz;
777     name[3] = 'I';
778     for(Int_t i=0;i<3;i++) name[i+1] = gnam[i];
779     gMC->Gsvolu(name,"ELTU",fidmed[med],param,3);
780 }
781 //______________________________________________________________________
782 void AliITSBaseGeometry::HyperbolicTube(const char gnam[3],const TString &dis,
783                                Double_t rmin,Double_t rmax,Double_t dz,
784                                Double_t thet,Int_t med){
785     // Interface to TMC->Gsvolu() for ITS HYPE geometries. Hyperbolic tube. 
786     // Fore example the inner and outer surfaces are hyperboloids, as would be 
787     // foumed by a system of cylinderical wires which were then rotated 
788     // tangentially about their centers. It has 4 parameters. See SetScale() 
789     // for units. Default units are geant 3 [cm]. The hyperbolic surfaces are 
790     // given by r^2 = (ztan(thet)^2 + r(z=0)^2.
791     // Inputs:
792     //    const char gnam[3]  3 character geant volume name. The letter "I"
793     //                        is appended to the front to indecate that this
794     //                        is an ITS volume.
795     //    TString &dis        String containging part discription.
796     //    Double_t rmin       Inner radius at z=0 where tube is narrowest.
797     //    Double_t rmax       Outer radius at z=0 where tube is narrowest.
798     //    Double_t dz         half-length along the z-axis
799     //    Double_t thet       stero angel of rotation of the two faces 
800     //                       [degrees].
801     //    Int_t    med        media index number.
802     // Output:
803     //    none.
804     // Return.
805     //    none.
806     char name[4];
807     Float_t param[4];
808
809     if(fidmed==0) SetMedArray();
810     param[0] = fScale*rmin;
811     param[1] = fScale*rmax;
812     param[2] = fScale*dz;
813     param[3] = thet;
814     name[3] = 'I';
815     for(Int_t i=0;i<3;i++) name[i+1] = gnam[i];
816     gMC->Gsvolu(name,"HYPE",fidmed[med],param,4);
817 }
818 //______________________________________________________________________
819 void AliITSBaseGeometry::TwistedTrapezoid(const char gnam[3],
820                                           const TString &dis,
821                                  Double_t dz,Double_t thet,Double_t phi,
822                                  Double_t twist,Double_t h1,Double_t bl1,
823                                  Double_t tl1,Double_t apl1,Double_t h2,
824                                  Double_t bl2,Double_t tl2,Double_t apl2,
825                                  Int_t med){
826     // Interface to TMC->Gsvolu() for ITS GTRA geometries. General twisted 
827     // trapazoid. The faces perpendicular to z are trapazia and their centers 
828     // are not necessarily on a line parallel to the z axis as the TRAP. 
829     // Additionally, the faces may be twisted so that none of their edges are 
830     // parallel. It is a TRAP shape, exept that it is twisted in the x-y plane 
831     // as a function of z. The parallel sides perpendicular to the x axis are 
832     // rotated with respect to the x axis by an angle TWIST, which is one of 
833     // the parameters. The shape is defined by the eight corners and is assumed
834     // to be constructed of straight lines joingin points on the boundry of the
835     // trapezoidal face at Z=-dz to the coresponding points on the face at 
836     // z=+dz. Divisions are not allowed. It has 12 parameters. See SetScale() 
837     // for units. Default units are geant 3 [cm]. Note: This shape suffers from
838     // the same limitations than the TRAP. The tracking routines assume that 
839     // the faces are planar, but htis constraint is not easily expressed in 
840     // terms of the 12 parameters. Additionally, no check on th efaces is 
841     // performed in this case. Users should avoid to use this shape as much as 
842     // possible, and if they have to do so, they should make sure that the 
843     // faces are really planes. If this is not the case, the result of the 
844     // trasport is unpredictable. To accelerat ethe computations necessary for 
845     // trasport, 18 additioanl parameters are calculated for this shape are
846     // 1 DXODZ dx/dz of the line joing the centers of the faces at z=+_dz.
847     // 2 DYODZ dy/dz of the line joing the centers of the faces at z=+_dz.
848     // 3 XO1    x at z=0 for line joing the + on parallel side, perpendicular 
849     //          corners at z=+_dz.
850     // 4 YO1    y at z=0 for line joing the + on parallel side, + on 
851     //          perpendicular corners at z=+-dz.
852     // 5 DXDZ1  dx/dz for line joing the + on parallel side, + on 
853     //          perpendicular corners at z=+-dz.
854     // 6 DYDZ1  dy/dz for line joing the + on parallel side, + on 
855     //          perpendicular corners at z=+-dz.
856     // 7 X02    x at z=0 for line joing the - on parallel side, + on 
857     //          perpendicular corners at z=+-dz.
858     // 8 YO2    y at z=0 for line joing the - on parallel side, + on 
859     //          perpendicular corners at z=+-dz.
860     // 9 DXDZ2  dx/dz for line joing the - on parallel side, + on 
861     //          perpendicular corners at z=+-dz.
862     // 10 DYDZ2dy/dz for line joing the - on parallel side, + on 
863     //          perpendicular corners at z=+-dz.
864     // 11 XO3   x at z=0 for line joing the - on parallel side, - on 
865     //          perpendicular corners at z=+-dz.
866     // 12 YO3   y at z=0 for line joing the - on parallel side, - on 
867     //          perpendicular corners at z=+-dz.
868     // 13 DXDZ3 dx/dzfor line joing the - on parallel side, - on 
869     //          perpendicular corners at z=+-dz.
870     // 14 DYDZ3 dydz for line joing the - on parallel side, - on 
871     //          perpendicular corners at z=+-dz.
872     // 15 XO4   x at z=0 for line joing the + on parallel side, - on 
873     //          perpendicular corners at z=+-dz.
874     // 16 YO4   y at z=0 for line joing the + on parallel side, - on 
875     //          perpendicular corners at z=+-dz.
876     // 17 DXDZ4 dx/dz for line joing the + on parallel side, - on 
877     //          perpendicular corners at z=+-dz.
878     // 18 DYDZ4 dydz for line joing the + on parallel side, - on 
879     //          perpendicular corners at z=+-dz.
880     // Inputs:
881     //    const char gnam[3]  3 character geant volume name. The letter "I"
882     //                        is appended to the front to indecate that this
883     //                        is an ITS volume.
884     //    TString &dis        String containging part discription.
885     //    Double_t dz         half-length along the z axis.
886     //    Double_t thet       polar angle of the line joing the center of the 
887     //                        face at -dz to the center of the one at +dz 
888     //                        [degrees].
889     //    Double_t phi        Azymuthal angle of teh line joing the centre of 
890     //                        the face at -dz to the center of the one at +dz 
891     //                        [degrees].
892     //    Double_t twist      Twist angle of the faces parallel to the x-y 
893     //                        plane at z=+-dz around an axis parallel to z 
894     //                        passing through their centre [degrees].
895     //    Double_t h1         Half-length along y of the face at -dz.
896     //    Double_t bl1        half-length along x of the side -h1 in y of the 
897     //                        face at -dz in z.
898     //    Double_t tl1        half-length along x of the side at +h1 in y of 
899     //                        the face at -dz in z.
900     //    Double_t apl1       Angle with respect to the y ais from the center 
901     //                        of the side at -h1 in y to the centere of the 
902     //                        side at +h1 in y of the face at -dz in z 
903     //                        [degrees].
904     //    Double_t h2         half-length along the face at +dz.
905     //    Double_t bl2        half-length along x of the side at -h2 in y of 
906     //                        the face at -dz in z.
907     //    Double_t tl2        half-length along x of the side at +h2 in y of 
908     //                        the face at +dz in z.
909     //    Double_t apl2       angle with respect to the y axis from the center 
910     //                        of the side at -h2 in y to the center of the side
911     //                        at +h2 in y of the face at +dz in z [degrees].
912     //    Int_t    med        media index number.
913     // Output:
914     //    none.
915     // Return.
916     //    none.
917     char name[4];
918     Float_t param[12];
919
920     if(fidmed==0) SetMedArray();
921     param[0] = fScale*dz;
922     param[1] = thet;
923     param[2] = phi;
924     param[3] = twist;
925     param[4] = fScale*h1;
926     param[5] = fScale*bl1;
927     param[6] = fScale*tl1;
928     param[7] = apl1;
929     param[8] = fScale*h2;
930     param[9] = fScale*bl2;
931     param[10] = fScale*tl2;
932     param[11] = apl2;
933     name[3] = 'I';
934     for(Int_t i=0;i<3;i++) name[i+1] = gnam[i];
935     gMC->Gsvolu(name,"GTRA",fidmed[med],param,12);
936 }
937 //______________________________________________________________________
938 void AliITSBaseGeometry::CutTube(const char gnam[3],const TString &dis,
939                                  Double_t rmin,Double_t rmax,Double_t dz,
940                                  Double_t phi1,Double_t phi2,Double_t lx,
941                                  Double_t ly,Double_t lz,Double_t hx,
942                                  Double_t hy,Double_t hz,Int_t med){
943     // Interface to TMC->Gsvolu() for ITS CTUB geometries. Cut tube. A tube cut
944     // at the extremities with planes not necessarily perpendicular tot he z 
945     // axis. It has 11 parameters. See SetScale() for units. Default units are 
946     // geant 3 [cm]. phi1 should be smaller than phi2. If this is not the case,
947     // the system adds 360 degrees to phi2.
948     // Inputs:
949     //    const char gnam[3]  3 character geant volume name. The letter "I"
950     //                        is appended to the front to indecate that this
951     //                        is an ITS volume.
952     //    TString &dis        String containging part discription.
953     //    Double_t rmin       Inner radius at z=0 where tube is narrowest.
954     //    Double_t rmax       Outer radius at z=0 where tube is narrowest.
955     //    Double_t dz         half-length along the z-axis
956     //    Double_t dz         half-length along the z-axis
957     //    Double_t phi1       Starting angle of the segment [degree].
958     //    Double_t phi2       Ending angle of the segment [degree].
959     //    Double_t lx         x component of a unit vector perpendicular to 
960     //                        the face at -dz.
961     //    Double_t ly         y component of a unit vector perpendicular to 
962     //                        the face at -dz.
963     //    Double_t lz         z component of a unit vector perpendicular to 
964     //                        the face at -dz.
965     //    Double_t hx         x component of a unit vector perpendicular to 
966     //                        the face at +dz.
967     //    Double_t hy         y component of a unit vector perpendicular to 
968     //                        the face at +dz.
969     //    Double_t hz         z component of a unit vector perpendicular to 
970     //                        the face at +dz.
971     //    Int_t    med        media index number.
972     // Output:
973     //    none.
974     // Return.
975     //    none.
976     char name[4];
977     Float_t param[11];
978
979     if(fidmed==0) SetMedArray();
980     param[0] = fScale*rmin;
981     param[1] = fScale*rmax;
982     param[2] = fScale*dz;
983     param[3] = phi1;
984     param[4] = phi2;
985     param[5] = lx;
986     param[6] = ly;
987     param[7] = lz;
988     param[8] = hx;
989     param[9] = hy;
990     param[10] = hz;
991     name[3] = 'I';
992     for(Int_t i=0;i<3;i++) name[i+1] = gnam[i];
993     gMC->Gsvolu(name,"CTUB",fidmed[med],param,11);
994 }
995 //______________________________________________________________________
996 void AliITSBaseGeometry::Pos(const char vol[3],Int_t cn,const char moth[3],
997                              Double_t x,Double_t y,Double_t z,Int_t irot){
998     // Place a copy of a volume previously defined by a call to GSVOLU inside 
999     // its mother volulme moth.
1000     // Inputs:
1001     //   const char vol[3]  3 character geant volume name. The letter "I"
1002     //                      is appended to the front to indecate that this
1003     //                      is an ITS volume.
1004     //   const char moth[3] 3 character geant volume name of the mother volume 
1005     //                      in which vol will be placed. The letter "I" is 
1006     //                      appended to the front to indecate that this is an 
1007     //                      ITS volume.
1008     //   Double_t x         The x positon of the volume in the mother's 
1009     //                      reference system
1010     //   Double_t y         The y positon of the volume in the mother's 
1011     //                      reference system
1012     //   Double_t z         The z positon of the volume in the mother's 
1013     //                      reference system
1014     //   Int_t irot         the index for the rotation matrix to be used.
1015     //                      irot=-1 => unit rotation.
1016     // Outputs:
1017     //    none.
1018     // Return:
1019     //    none.
1020     char name[4],mother[4];
1021     Float_t param[3];
1022     Int_t r=0,i;
1023
1024     param[0] = x;
1025     param[1] = y;
1026     param[2] = z;
1027     name[3] = 'I';
1028     for(i=0;i<3;i++) name[i+1] = vol[i];
1029     mother[3] = 'I';
1030     for(i=0;i<3;i++) mother[i+1] = moth[i];
1031     if(irot>=0) r=fidrot[irot];
1032     gMC->Gspos(name,1,mother,param[0],param[1],param[2],r,"ONLY");
1033 }
1034 //______________________________________________________________________
1035 void AliITSBaseGeometry::Matrix(Int_t irot,Double_t thet1,Double_t phi1,
1036                        Double_t thet2,Double_t phi2,
1037                        Double_t thet3,Double_t phi3){
1038     // Defines a Geant rotation matrix. checks to see if it is the unit
1039     // matrix. If so, then no additonal matrix is defined. Stores rotation 
1040     // matrix irot in the data structure JROTM. If the matrix is not 
1041     // orthonormal, it will be corrected by setting y' perpendicular to x' 
1042     // and z' = x' X y'. A warning message is printed in this case.
1043     // Inputs:
1044     //   Int_t irot     Intex specifing which rotation matrix.
1045     //   Double_t thet1 Polar angle for axisw x [degrees].
1046     //   Double_t phi1  azimuthal angle for axis x [degrees].
1047     //   Double_t thet12Polar angle for axisw y [degrees].
1048     //   Double_t phi2  azimuthal angle for axis y [degrees].
1049     //   Double_t thet3 Polar angle for axisw z [degrees].
1050     //   Double_t phi3  azimuthal angle for axis z [degrees].
1051     // Outputs:
1052     //    none.
1053     // Return:
1054     //    none.
1055     Float_t t1,p1,t2,p2,t3,p3;
1056
1057     if(thet1==90.0&&phi1==0.0&&thet2==90.0&&phi2==90.0&&thet3==0.0&&phi3==0.0){
1058         fidrot[irot] = 0; // Unit matrix
1059     }else{
1060         t1 = thet1;
1061         p1 = phi1;
1062         t2 = thet2;
1063         p2 = phi2;
1064         t3 = thet3;
1065         p3 = phi3;
1066         fits->AliMatrix(fidrot[irot],t1,p1,t2,p2,t3,p3);
1067     } // end if
1068 }
1069 //______________________________________________________________________
1070 void AliITSBaseGeometry::Matrix(Int_t irot,Int_t axis,Double_t thet){
1071     // Defines a Geant rotation matrix. checks to see if it is the unit
1072     // matrix. If so, then no additonal matrix is defined. Stores rotation 
1073     // matrix irot in the data structure JROTM. If the matrix is not 
1074     // orthonormal, it will be corrected by setting y' perpendicular to x' 
1075     // and z' = x' X y'. A warning message is printed in this case.
1076     // Inputs:
1077     //   Int_t irot         Intex specifing which rotation matrix.
1078     //   Int_t axis         Axis about which rotation is to be done.
1079     //   Double_t thet      Angle to rotate by [degrees].
1080     // Outputs:
1081     //    none.
1082     // Return:
1083     //    none.
1084
1085     if(thet==0.0){
1086         fidrot[irot] = 0; // Unit matrix
1087     }else{
1088         switch (irot) {
1089         case 0: //Rotate about x-axis, x-axis does not change.
1090             fits->AliMatrix(fidrot[irot],90.0,0.0,90.0+thet,90.0,thet,90.0);
1091             break;
1092         case 1: //Rotate about y-axis, y-axis does not change.
1093             fits->AliMatrix(fidrot[irot],-90.0-thet,0.0,90.0,90.0,thet,90.0);
1094             break;
1095         case 2: //Rotate about z-axis, z-axis does not change.
1096             fits->AliMatrix(fidrot[irot],90.0,thet,90.0,-thet-90.0,0.0,0.0);
1097             break;
1098         default:
1099             Error("Matrix","axis must be either 0, 1, or 2. for matrix=%d",
1100                   irot);
1101             break;
1102         } // end switch
1103     } // end if
1104 }
1105 //______________________________________________________________________
1106 void AliITSBaseGeometry::Matrix(Int_t irot,Double_t rot[3][3]){
1107     // Defines a Geant rotation matrix. checks to see if it is the unit
1108     // matrix. If so, then no additonal matrix is defined. Stores rotation 
1109     // matrix irot in the data structure JROTM. If the matrix is not 
1110     // orthonormal, it will be corrected by setting y' perpendicular to x' 
1111     // and z' = x' X y'. A warning message is printed in this case.
1112     // Inputs:
1113     //   Int_t irot         Intex specifing which rotation matrix.
1114     //   Double_t rot[3][3] The 3 by 3 rotation matrix.
1115     // Outputs:
1116     //    none.
1117     // Return:
1118     //    none.
1119
1120     if(rot[0][0]==1.0&&rot[1][1]==1.0&&rot[2][2]==1.0&&
1121        rot[0][1]==0.0&&rot[0][2]==0.0&&rot[1][0]==0.0&&
1122        rot[1][2]==0.0&&rot[2][0]==0.0&&rot[2][1]==0.0){
1123         fidrot[irot] = 0; // Unit matrix
1124     }else{
1125         Double_t si,c=180./TMath::Pi();
1126         Double_t ang[6];
1127
1128         ang[1] = TMath::ATan2(rot[0][1],rot[0][0]);
1129         if(TMath::Cos(ang[1])!=0.0) si = rot[0][0]/TMath::Cos(ang[1]);
1130         else si = rot[0][1]/TMath::Sin(ang[1]);
1131         ang[0] = TMath::ATan2(si,rot[0][2]);
1132
1133         ang[3] = TMath::ATan2(rot[1][1],rot[1][0]);
1134         if(TMath::Cos(ang[3])!=0.0) si = rot[1][0]/TMath::Cos(ang[3]);
1135         else si = rot[1][1]/TMath::Sin(ang[3]);
1136         ang[2] = TMath::ATan2(si,rot[1][2]);
1137
1138         ang[5] = TMath::ATan2(rot[2][1],rot[2][0]);
1139         if(TMath::Cos(ang[5])!=0.0) si = rot[2][0]/TMath::Cos(ang[5]);
1140         else si = rot[2][1]/TMath::Sin(ang[5]);
1141         ang[4] = TMath::ATan2(si,rot[2][2]);
1142
1143         for(Int_t i=0;i<6;i++) {ang[i] *= c; if(ang[i]<0.0) ang[i] += 360.;}
1144         fits->AliMatrix(fidrot[irot],ang[0],ang[1],ang[2],ang[3],
1145                         ang[4],ang[5]);
1146     } // end if
1147 }
1148 //______________________________________________________________________
1149 Float_t AliITSBaseGeometry::GetA(Int_t z){
1150     // Returns the isotopicaly averaged atomic number.
1151     // Inputs:
1152     //    Int_t z  Elemental number
1153     // Outputs:
1154     //    none.
1155     // Return:
1156     //    The atomic mass number.
1157     const Float_t A[]={ 1.00794 ,  4.0026902,  6.941   ,  9.012182 , 10.811   ,
1158                        12.01007 , 14.00674  , 15.9994  , 18.9984032, 20.1797  ,
1159                        22.98970 , 24.3050   , 26.981538, 28.0855   , 30.973761,
1160                        32.066   , 35.4527   , 39.948   , 39.0983   , 40.078   ,
1161                        44.95591 , 47.867    , 50.9415  , 51.9961   , 54.938049,
1162                        55.845   , 58.933200 , 58.6934  , 63.546    , 65.39    ,
1163                        69.723   , 72.61     , 74.92160 , 78.96     , 79.904   ,
1164                        83.80    , 85.4678   , 87.62    , 88.9085   , 91.224   ,
1165                        92.90638 , 95.94     , 97.907215, 101.07    ,102.90550 ,
1166                       106.42    ,107.8682   ,112.411   ,114.818    ,118.710   ,
1167                       121.760   ,127.60     ,126.90447 ,131.29     ,132.90545 ,
1168                       137.327   ,138.9055   ,140.116   ,140.90765  ,144.24    ,
1169                       144.912746,150.36     ,151.964   ,157.25     ,158.92534 ,
1170                       162.50    ,164.93032  ,167.26    ,168.93421  ,173.04    ,
1171                       174.967   ,178.49     ,180.9479 ,183.84      ,186.207   ,
1172                       190.23    ,192.217    ,195.078  ,196.96655   ,200.59    ,
1173                       204.3833  ,207.2      ,208.98038,208.982415  ,209.987131,
1174                       222.017570,223.019731 ,226.025402,227.027747 ,232.0381  ,
1175                       231.03588 ,238.0289};
1176
1177     if(z<1||z>92){
1178         Error("GetA","z must be 0<z<93. z=%d",z);
1179         return 0.0;
1180     } // end if
1181     return A[z-1];
1182 }
1183 //______________________________________________________________________
1184 Float_t AliITSBaseGeometry::GetStandardMaxStepSize(Int_t istd){
1185     // Returns one of a set of standard Maximum Step Size values.
1186     // Inputs:
1187     //   Int_t istd  Index to indecate which standard.
1188     // Outputs:
1189     //    none.
1190     // Return:
1191     //    The appropreate standard Maximum Step Size value [cm].
1192     Float_t t[]={1.0, // default
1193                  0.0075, // Silicon detectors...
1194                  1.0, // Air in central detectors region
1195                  1.0  // Material in non-centeral region
1196     };
1197     return t[istd];
1198 }
1199 //______________________________________________________________________
1200 Float_t AliITSBaseGeometry::GetStandardThetaMax(Int_t istd){
1201     // Returns one of a set of standard Theata Max values.
1202     // Inputs:
1203     //   Int_t istd  Index to indecate which standard.
1204     // Outputs:
1205     //    none.
1206     // Return:
1207     //    The appropreate standard Theta max value [degrees].
1208     Float_t t[]={0.1, // default
1209                  0.1, // Silicon detectors...
1210                  0.1, // Air in central detectors region
1211                  1.0  // Material in non-centeral region
1212     };
1213     return t[istd];
1214 }
1215 //______________________________________________________________________
1216 Float_t AliITSBaseGeometry::GetStandardEfraction(Int_t istd){
1217     // Returns one of a set of standard E fraction values.
1218     // Inputs:
1219     //   Int_t istd  Index to indecate which standard.
1220     // Outputs:
1221     //    none.
1222     // Return:
1223     //    The appropreate standard E fraction value [#].
1224     Float_t t[]={0.1, // default
1225                  0.1, // Silicon detectors...
1226                  0.1, // Air in central detectors region
1227                  0.5  // Material in non-centeral region
1228     };
1229     return t[istd];
1230 }
1231 Float_t AliITSBaseGeometry::GetStandardEpsilon(Int_t istd){
1232     // Returns one of the standard Epsilon valuse
1233     // Inputs:
1234     //    Int_t istd  index of standard cuts to get
1235     // Output:
1236     //    none.
1237     // Return:
1238     //    Float_t the standard Epsilon cut value.
1239     Float_t t[]={1.0E-4, // default
1240                  1.0E-4, // Silicon detectors...
1241                  1.0E-4, // Air in central detector region
1242                  1.0E-3, // Material in non-cneteral regions
1243     };
1244
1245     return t[istd];
1246 }
1247 //______________________________________________________________________
1248 void AliITSBaseGeometry::Element(Int_t imat,const char* name,Int_t z,
1249                                  Double_t dens,Int_t istd){
1250     // Defines a Geant single element material and sets its Geant medium
1251     // proporties. The average atomic A is assumed to be given by their
1252     // natural abundances. Things like the radiation length are calculated
1253     // for you.
1254     // Inputs:
1255     //    Int_t imat       Material number.
1256     //    const char* name Material name. No need to add a $ at the end.
1257     //    Int_t z          The elemental number.
1258     //    Double_t dens    The density of the material [g/cm^3].
1259     //    Int_t istd       Defines which standard set of transport parameters
1260     //                     which should be used.
1261     // Output:
1262     //     none.
1263     // Return:
1264     //     none.
1265     Float_t rad,Z,A=GetA(z),tmax,stemax,deemax,epsilon;
1266     char *name2;
1267     Int_t len;
1268
1269     len = strlen(name)+1;
1270     name2 = new char[len];
1271     strncpy(name2,name,len-1);
1272     name2[len-1] = '\0';
1273     name2[len-2] = '$';
1274     Z = (Float_t)z;
1275     rad = GetRadLength(z)/dens;
1276     fits->AliMaterial(imat,name2,A,Z,dens,rad,0.0,0,0);
1277     tmax    = GetStandardThetaMax(istd);    // degree
1278     stemax  = GetStandardMaxStepSize(istd);  // cm
1279     deemax  = GetStandardEfraction(istd);     // ratio
1280     epsilon = GetStandardEpsilon(istd);       //
1281     fits->AliMedium(imat,name2,imat,0,gAlice->Field()->Integ(),
1282                     gAlice->Field()->Max(),tmax,stemax,deemax,epsilon,0.0);
1283     delete[] name2;
1284 }
1285 //______________________________________________________________________
1286 void AliITSBaseGeometry::MixtureByWeight(Int_t imat,const char* name,Int_t *z,
1287                                 Double_t *w,Double_t dens,Int_t n,Int_t istd){
1288     // Defines a Geant material by a set of elements and weights, and sets 
1289     // its Geant medium proporties. The average atomic A is assumed to be 
1290     // given by their natural abundances. Things like the radiation length 
1291     // are calculated for you.
1292     // Inputs:
1293     //    Int_t imat       Material number.
1294     //    const char* name Material name. No need to add a $ at the end.
1295     //    Int_t *z         Array of The elemental numbers.
1296     //    Double_t *w      Array of relative weights.
1297     //    Double_t dens    The density of the material [g/cm^3].
1298     //    Int_t n          the number of elements making up the mixture.
1299     //    Int_t istd       Defines which standard set of transport parameters
1300     //                     which should be used.   
1301     // Output:
1302     //     none.
1303     // Return:
1304     //     none.
1305     Float_t *Z,*A,*W,tmax,stemax,deemax,epsilon;
1306     char *name2;
1307     Int_t len,i;
1308     Z = new Float_t[n];
1309     A = new Float_t[n];
1310     W = new Float_t[n];
1311
1312     len = strlen(name)+1;
1313     name2 = new char[len];
1314     strncpy(name2,name,len-1);
1315     name2[len-1] = '\0';
1316     name2[len-2] = '$';
1317     for(i=0;i<n;i++){Z[i] = (Float_t)z[i];A[i] = (Float_t)GetA(z[i]);
1318                      W[i] = (Float_t)w[i];}
1319     fits->AliMixture(imat,name2,A,Z,dens,n,W);
1320     tmax    = GetStandardThetaMax(istd);    // degree
1321     stemax  = GetStandardMaxStepSize(istd);  // cm
1322     deemax  = GetStandardEfraction(istd);     // #
1323     epsilon = GetStandardEpsilon(istd);
1324     fits->AliMedium(imat,name2,imat,0,gAlice->Field()->Integ(),
1325               gAlice->Field()->Max(),tmax,stemax,deemax,epsilon,0.0);
1326     delete[] name2;
1327     delete[] Z;
1328     delete[] A;
1329     delete[] W;
1330 }
1331 //______________________________________________________________________
1332 void AliITSBaseGeometry::MixtureByNumber(Int_t imat,const char* name,Int_t *z,
1333                                 Int_t *w,Double_t dens,Int_t n,Int_t istd){
1334     // Defines a Geant material by a set of elements and number, and sets 
1335     // its Geant medium proporties. The average atomic A is assumed to be 
1336     // given by their natural abundances. Things like the radiation length 
1337     // are calculated for you.
1338     // Inputs:
1339     //    Int_t imat       Material number.
1340     //    const char* name Material name. No need to add a $ at the end.
1341     //    Int_t *z         Array of The elemental numbers.
1342     //    Int_t_t *w       Array of relative number.
1343     //    Double_t dens    The density of the material [g/cm^3].
1344     //    Int_t n          the number of elements making up the mixture.
1345     //    Int_t istd       Defines which standard set of transport parameters
1346     //                     which should be used.   
1347     // Output:
1348     //     none.
1349     // Return:
1350     //     none.
1351     Float_t *Z,*A,*W,tmax,stemax,deemax,epsilon;
1352     char *name2;
1353     Int_t len,i;
1354     Z = new Float_t[n];
1355     A = new Float_t[n];
1356     W = new Float_t[n];
1357
1358     len = strlen(name)+1;
1359     name2 = new char[len];
1360     strncpy(name2,name,len-1);
1361     name2[len-1] = '\0';
1362     name2[len-2] = '$';
1363     for(i=0;i<n;i++){Z[i] = (Float_t)z[i];A[i] = (Float_t)GetA(z[i]);
1364                      W[i] = (Float_t)w[i];}
1365     fits->AliMixture(imat,name2,A,Z,dens,-n,W);
1366     tmax    = GetStandardThetaMax(istd);    // degree
1367     stemax  = GetStandardMaxStepSize(istd);  // cm
1368     deemax  = GetStandardEfraction(istd);     // #
1369     epsilon = GetStandardEpsilon(istd);
1370     fits->AliMedium(imat,name2,imat,0,gAlice->Field()->Integ(),
1371                     gAlice->Field()->Max(),tmax,stemax,deemax,epsilon,0.0);
1372     delete[] name2;
1373     delete[] Z;
1374     delete[] A;
1375     delete[] W;
1376 }
1377 //______________________________________________________________________
1378 Double_t AliITSBaseGeometry::RadLength(Int_t iz,Double_t a){
1379     // Computes the radiation length in accordance to the PDG 2000 Section
1380     // 23.4.1 p. 166. Transladed from the c code of Flavio Tosello.
1381     // Inputs:
1382     //    Int_t iz    The elemental number
1383     //    Dougle_t    The elemental average atomic mass number
1384     // Outputs:
1385     // Return:
1386     //    Double_t returns the radiation length of the element iz in
1387     //             [gm/cm^2].
1388     Double_t z = (Double_t)iz;
1389     Double_t alphaz = fAlpha*z;
1390     Double_t alphaz2 = alphaz*alphaz;
1391     Double_t c0 = +0.20206,c1 = -0.0369,c2 = +0.0083,c3 = -0.0020;
1392     Double_t z12,z23,l,lp,c;
1393
1394     c = alphaz2*(1./(1.+alphaz2) + c0 + c1*alphaz2 + c2*alphaz2*alphaz2
1395                   +c3*alphaz2*alphaz2*alphaz2);
1396     z12 = TMath::Exp(TMath::Log(z)/3.0);
1397     z23 = z12*z12;
1398     switch (iz){
1399     case 1: //Hydrogen
1400         l  = 5.31;
1401         lp = 6.144;
1402         break;
1403     case 2: //Helium
1404         l  = 4.79;
1405         lp = 5,621;
1406         break;
1407     case 3: //Lithium
1408         l  = 4.74;
1409         lp = 5.805;
1410         break;
1411     case 4: //Berilium
1412         l  = 4.71;
1413         lp = 5.924;
1414         break;
1415     default: //Others
1416         l  = TMath::Log(184.15/z12);
1417         lp = TMath::Log(1194.0/z23);
1418         break;
1419     } // end switch
1420     Double_t re2,b,r,xz;
1421
1422     re2 = fRe*fRe;
1423     b = 4.0*fAlpha*re2*fNa/a;
1424     r = b*z*(z*(l-c)+lp);
1425     xz = 1.0/r;
1426     return xz; // [gm/cm^2]
1427 }