e01e52a7aa0d641836bb9cd39e9ff84008f89648
[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 Revision 1.3  2003/03/27 08:49:39  hristov
19 Initialization of static data members in the implementation file
20
21 Revision 1.2  2003/03/25 23:27:19  nilsen
22 ITS new Geometry files. Not yet ready for uses, committed to allow additional
23 development.
24
25 Revision 1.1  2003/02/10 17:03:52  nilsen
26 New version and structure of ITS V11 geometry. Work still in progress.
27
28
29 $Id$
30 */
31
32 /*
33   A base geometry class defining all of the ITS volumes that make up an ITS
34 geometry.
35 Auhors: B. S. Nilsen
36 Version 0
37 Created February 2003.
38 */
39
40 #include <Riostream.h>
41 #include <stdio.h>
42 #include <stdlib.h>
43 #include <string.h>
44 #include <TMath.h>
45 #include <TGeometry.h>
46 #include <TNode.h>
47 #include <TTUBE.h>
48 #include <TTUBS.h>
49 #include <TPCON.h>
50 #include <TFile.h>    // only required for Tracking function?
51 #include <TCanvas.h>
52 #include <TObjArray.h>
53 #include <TLorentzVector.h>
54 #include <TObjString.h>
55 #include <TClonesArray.h>
56 #include <TBRIK.h>
57 #include <TSystem.h>
58 #include <AliRun.h>
59 #include <AliMagF.h>
60 #include <AliConst.h>
61 #include "AliITSBaseGeometry.h"
62
63 ClassImp(AliITSBaseGeometry)
64
65 const Double_t AliITSBaseGeometry::fAlpha = 7.297352533e-3;
66 const Double_t AliITSBaseGeometry::fRe = 2.81794028e-13;
67 const Double_t AliITSBaseGeometry::fNa = 6.02214199e+23;
68 Int_t    AliITSBaseGeometry::fNCreates    = 0;
69 Int_t*   AliITSBaseGeometry::fidrot       = 0;
70 Int_t    AliITSBaseGeometry::fidrotsize   = 0;
71 Int_t    AliITSBaseGeometry::fidrotlast   = 0;
72 Int_t    AliITSBaseGeometry::fVolNameSize = 0;
73 Int_t    AliITSBaseGeometry::fVolNameLast = 0;
74 TString* AliITSBaseGeometry::fVolName     = 0;
75
76 //______________________________________________________________________
77 AliITSBaseGeometry::AliITSBaseGeometry(){
78     // Default construtor for the ITS Base Geometry class.
79     // Inputs:
80     //    none.
81     // Outputs:
82     //    none.
83     // Return:
84     //    none.
85
86     fScale = 1.0; // Default value.
87     fits = 0; // zero pointers.
88     if(fNCreates==0){ // only for very first init
89     } // end if
90     fNCreates++; // incrament this creation counter.
91 }
92 //______________________________________________________________________
93 AliITSBaseGeometry::AliITSBaseGeometry(AliModule *its,Int_t iflag){
94     // Standard construtor for the ITS Base Geometry class.
95     // Inputs:
96     //    Int_t iflag  flag to indecate specific swiches in the geometry
97     // Outputs:
98     //    none.
99     // Return:
100     //    none.
101
102     fScale = 1.0; // Default value.
103     fits = its; // get a copy of the pointer to the ITS.
104     if(fNCreates==0){ // only for very first init
105         fidrotsize = ITSG3VnameToIndex("TSV")+1;
106         fidrot = new Int_t[fidrotsize];
107         fidrotlast = 0;
108     } // end if
109     fNCreates++; // incrament this creation counter.
110 }
111 //______________________________________________________________________
112 AliITSBaseGeometry::~AliITSBaseGeometry(){
113     // Standeard destructor for the ITS Base Geometry class.
114     // Inputs:
115     //    Int_t iflag  flag to indecate specific swiches in the geometry
116     // Outputs:
117     //    none.
118     // Return:
119     //    none.
120
121     fits = 0; // This class does not own this class. It contaitns a pointer
122     // to it for conveniance.
123     fNCreates--;
124     if(fNCreates==0){ // Now delete the static members
125         Int_t i;
126         if(fVolName!=0){
127             for(i=0;i<fVolNameLast;i++) delete fVolName[i];
128             fVolNameSize = 0;
129             fVolNameLast = 0;
130             delete[] fVolName;
131         }// end if
132         delete[] fidrot;
133         fidrotsize = fidrotlast = 0;
134     }// end if
135 }
136 //______________________________________________________________________
137 Int_t AliITSBaseGeometry::AddVolName(const TString name){
138     // Checks if the volume name already exist, if not it adds it to
139     // the list of volume names and returns an index to that volume name.
140     // it will create and expand the array of volume names as needed.
141     // If the volume name already exists, it will give an error message and
142     // return an index <0.
143     // Inputs:
144     //    const TString name  Volume name to be added to the list.
145     // Outputs:
146     //    none.
147     // Return:
148     //    The index where this volume name is stored.
149     Int_t i;
150
151     if(fVolName==0){ // must create array.
152         fVolNameSize = 38624;
153         fVolName = new TString[fVolNameSize];
154         fVolNameLast = 0;
155     } // end if
156     for(i=0;i<fVolNameLast;i++) if(fVolName[i].CompareTo(name)==0){ // Error
157         Error("AddVolName","Volume name already exists for volume %d name %s",
158               i,name.Data());
159         return -1;
160     } // end for i
161     if(fVolNameSize==fVolNameLast-1){ // Array is full must expand.
162         Int_t size = fVolNameSize*2;
163         TString *old = fVolName;
164         fVolName = new TString[fVolNameSize];
165         for(i=0;i<fVolNameLast;i++) fVolName[i] = old[i];
166         delete[] old;
167         fVolNameSize = size;
168     } // end if
169     i=ITSIndexToITSG3name(fVolNameLast);
170     if(strcmp((char*)(&i),"ITSV")==0){
171         // Special Reserved Geant 3 volumen name. Skip it
172         // fill it with explination for conveniance.
173         fVolName[fVolNameLast] = "ITS Master Mother Volume";
174         fVolNameLast++;
175     } // end if
176     fVolName[fVolNameLast] = name;
177     fVolNameLast++;
178     return fVolNameLast-1; // return the index
179 }
180 //______________________________________________________________________
181 Int_t AliITSBaseGeometry::ITSIndexToITSG3name(const Int_t i){
182     // Given the ITS volume index i, it returns the Geant3 ITS volume
183     // name. The valid characters must be in the range
184     // '0' through 'Z'. This will include all upper case letter and the
185     // numbers 0-9. In addition it does not will include the following simbols
186     // ":;<=>?@"
187     // Inputs:
188     //    const Int_t i  the ITS volume index
189     // Output:
190     //    none.
191     // Return:
192     //    char[4] with the ITS volume name starting from "I000" to "IZZZ"
193     const Int_t rangen=(Int_t)('9'-'0'+1); // range of numbers
194     const Int_t rangel=(Int_t)('Z'-'A'+1); // range of letters
195     const Int_t range = rangen+rangel; // the number of characters between 
196                                        // 0-9 and A-Z.
197     Int_t k;
198     Byte_t *a = (Byte_t*) &k;
199     Int_t j = i;
200
201     k = 0;
202     a[0] = (Byte_t)('I');
203     a[1] = (Byte_t)('0'+j/(range*range));
204     if(a[1]>'9') a[1] += 'A'-'9'-1;//if it is a letter add in gap for simples.
205     j -= range*range*((Int_t)(j/(range*range)));
206     a[2] = (Byte_t)('0'+j/range);
207     if(a[2]>'9') a[2] += 'A'-'9'-1;//if it is a letter add in gap for simples.
208     j -= range*((Int_t)(j/range));
209     a[3] = (Byte_t)('0'+j);
210     if(a[3]>'9') a[3] += 'A'-'9'-1;//if it is a letter add in gap for simples.
211     return k;
212 }
213 //______________________________________________________________________
214 Int_t AliITSBaseGeometry::ITSG3VnameToIndex(const char *name)const{
215     // Given the last three characters of the ITS Geant3 volume name,
216     // this returns the index. The valid characters must be in the range
217     // '0' through 'Z'. This will include all upper case letter and the
218     // numbers 0-9. In addition it will include the following simbles
219     // ":;<=>?@"
220     // Inputs:
221     //    const char name[3]  The last three characters of the ITS Geant3
222     //                        volume name
223     // Output:
224     //    none.
225     // Return:
226     //    Int_t the index.
227     const Int_t rangen = (Int_t)('9'-'0'+1); // range of numbers
228     const Int_t rangel = (Int_t)('Z'-'A'+1); // range of letters
229     const Int_t range  = rangen+rangel; // the number of characters between
230                                         // 0-9 + A-Z.
231     Int_t i=0,j,k;
232
233     k = strlen(name)-1;
234     for(j=k;j>k-3;j--) if(isdigit(name[j])) // number
235         i += (Int_t)((name[j]-'0')*TMath::Power((Double_t)range,
236                                                 (Double_t)(k-j)));
237     else
238         i += (Int_t)((name[j]-'A'+rangen)*TMath::Power((Double_t)range,
239                                                        (Double_t)(k-j)));
240     return i;
241 }
242 //______________________________________________________________________
243 TString AliITSBaseGeometry::GetVolName(const Int_t i)const{
244     // Returns the volume name at a given index i. Index must be in
245     // range and the array of volume names must exist. If there is an
246     // error, a message is written and 0 is returned.
247     // Inputs:
248     //   const Int_t i Index
249     // Output:
250     //   none.
251     // Return:
252     //   A TString contianing the ITS volume name.
253
254     if(i<0||i>=fVolNameLast){
255         Error("GetVolName","Index=%d out of range but be witin 0<%d",i,
256               fVolName-1);
257         return 0;
258     } // end if Error
259     return fVolName[i];
260 }
261 //______________________________________________________________________
262 Int_t AliITSBaseGeometry::GetVolumeIndex(const TString &a){
263     // Return the index corresponding the the volume name a. If the
264     // Volumen name is not found, return -1, and a warning message given.
265     // Inputs:
266     //   const TString &a  Name of volume for which index is wanted.
267     // Output:
268     //   none.
269     // Return:
270     //   Int_t Index corresponding the volume a. If not found -1 is returned.
271     Int_t i;
272
273     for(i=0;i<fVolNameLast;i++) if(fVolName[i].CompareTo(a)==0) return i;
274     Info("GetVolumeIndex","Volume name %s not found",a.Data());
275     return -1;
276 }
277 //______________________________________________________________________
278 void AliITSBaseGeometry::Box(const char *gnam,const TString &dis,
279                              Double_t dx,Double_t dy,Double_t dz,Int_t med){
280     // Interface to TMC->Gsvolu() for ITS bos geometries. Box with faces
281     // perpendicular to the axes. It has 3 paramters. See SetScale() for
282     // units. Default units are geant 3 [cm].
283     // Inputs:
284     //    const char *gnam  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 dx         half-length of box in x-axis
289     //    Double_t dy         half-length of box in y-axis
290     //    Double_t dz         half-length of box in z-axis
291     //    Int_t    med        media index number.
292     // Output:
293     //    none.
294     // Return.
295     //    none.
296     char name[5];
297     Float_t param[3];
298
299     param[0] = fScale*dx;
300     param[1] = fScale*dy;
301     param[2] = fScale*dz;
302     G3name(gnam,name);
303     gMC->Gsvolu(name,"BOX ",GetMed(med),param,3);
304 }
305 //______________________________________________________________________
306 void AliITSBaseGeometry::Trapezoid1(const char *gnam,const TString &dis,
307                                     Double_t dxn,Double_t dxp,Double_t dy,
308                                     Double_t dz,Int_t med){
309     // Interface to TMC->Gsvolu() for ITS TRD1 geometries. Trapezoid with the 
310     // x dimension varing along z. It has 4 parameters. See SetScale() for
311     // units. Default units are geant 3 [cm].
312     // Inputs:
313     //    const char *gnam  3 character geant volume name. The letter "I"
314     //                        is appended to the front to indecate that this
315     //                        is an ITS volume.
316     //    TString &dis        String containging part discription.
317     //    Double_t dxn        half-length along x at the z surface positioned 
318     //                        at -DZ
319     //    Double_t dxp        half-length along x at the z surface positioned 
320     //                        at +DZ
321     //    Double_t dy         half-length along the y-axis
322     //    Double_t dz         half-length along the z-axis
323     //    Int_t    med        media index number.
324     // Output:
325     //    none.
326     // Return.
327     //    none.
328     char name[5];
329     Float_t param[4];
330
331     param[0] = fScale*dxn;
332     param[1] = fScale*dxp;
333     param[2] = fScale*dy;
334     param[3] = fScale*dz;
335     G3name(gnam,name);
336     gMC->Gsvolu(name,"TRD1",GetMed(med),param,4);
337 }
338 //______________________________________________________________________
339 void AliITSBaseGeometry::Trapezoid2(const char *gnam,const TString &dis,
340                                     Double_t dxn,Double_t dxp,Double_t dyn,
341                                     Double_t dyp,Double_t dz,Int_t med){
342     // Interface to TMC->Gsvolu() for ITS TRD2 geometries. Trapezoid with the 
343     // x and y dimension varing along z. It has 5 parameters. See SetScale() 
344     // for units. Default units are geant 3 [cm].
345     // Inputs:
346     //    const char *gnam  3 character geant volume name. The letter "I"
347     //                        is appended to the front to indecate that this
348     //                        is an ITS volume.
349     //    TString &dis        String containging part discription.
350     //    Double_t dxn        half-length along x at the z surface positioned 
351     //                        at -DZ
352     //    Double_t dxp        half-length along x at the z surface positioned 
353     //                        at +DZ
354     //    Double_t dyn        half-length along x at the z surface positioned 
355     //                        at -DZ
356     //    Double_t dyp        half-length along x at the z surface positioned 
357     //                        at +DZ
358     //    Double_t dz         half-length along the z-axis
359     //    Int_t    med        media index number.
360     // Output:
361     //    none.
362     // Return.
363     //    none.
364     char name[5];
365     Float_t param[5];
366
367     param[0] = fScale*dxn;
368     param[1] = fScale*dxp;
369     param[2] = fScale*dyn;
370     param[3] = fScale*dyp;
371     param[4] = fScale*dz;
372     G3name(gnam,name);
373     gMC->Gsvolu(name,"TRD2",GetMed(med),param,5);
374 }
375 //______________________________________________________________________
376 void AliITSBaseGeometry::Trapezoid(const char *gnam,const TString &dis,
377                                    Double_t dz,Double_t thet,Double_t phi,
378                                    Double_t h1,Double_t bl1,Double_t tl1,
379                                    Double_t alp1,Double_t h2,Double_t bl2,
380                                    Double_t tl2,Double_t alp2,Int_t med){
381     // Interface to TMC->Gsvolu() for ITS TRAP geometries. General Trapezoid, 
382     // The faces perpendicular to z are trapezia and their centers are not 
383     // necessarily on a line parallel to the z axis. This shape has 11 
384     // parameters, but only cosidering that the faces should be planar, only
385     // 9 are really independent. A check is performed on the user parameters 
386     // and a message is printed in case of non-planar faces. Ignoring this
387     // warning may cause unpredictable effects at tracking time. See 
388     // SetScale() for units. Default units are geant 3 [cm].
389     // Inputs:
390     //    const char *gnam  3 character geant volume name. The letter "I"
391     //                        is appended to the front to indecate that this
392     //                        is an ITS volume.
393     //    TString &dis        String containging part discription.
394     //    Double_t dz         Half-length along the z-asix
395     //    Double_t thet       Polar angle of the line joing the center of the 
396     //                        face at -dz to the center of the one at dz 
397     //                        [degree].
398     //    Double_t phi        aximuthal angle of the line joing the center of 
399     //                        the face at -dz to the center of the one at +dz 
400     //                        [degree].
401     //    Double_t h1         half-length along y of the face at -dz.
402     //    Double_t bl1        half-length along x of the side at -h1 in y of 
403     //                        the face at -dz in z.
404     //    Double_t tl1        half-length along x of teh side at +h1 in y of 
405     //                        the face at -dz in z.
406     //    Double_t alp1       angle with respect to the y axis from the 
407     //                        center of the side at -h1 in y to the cetner 
408     //                        of the side at +h1 in y of the face at -dz in z 
409     //                        [degree].
410     //    Double_t h2         half-length along y of the face at +dz
411     //    Double_t bl2        half-length along x of the side at -h2 in y of
412     //                        the face at +dz in z.
413     //    Double_t tl2        half-length along x of the side at _h2 in y of 
414     //                        the face at +dz in z.
415     //    Double_t alp2       angle with respect to the y axis from the 
416     //                        center of the side at -h2 in y to the center 
417     //                        of the side at +h2 in y of the face at +dz in z 
418     //                        [degree].
419     //    Int_t    med        media index number.
420     // Output:
421     //    none.
422     // Return.
423     //    none.
424     char name[5];
425     Float_t param[11];
426
427     param[0] = fScale*dz;
428     param[1] = thet;
429     param[2] = phi;
430     param[3] = fScale*h1;
431     param[4] = fScale*bl1;
432     param[5] = fScale*tl1;
433     param[6] = alp1;
434     param[7] = fScale*h2;
435     param[8] = fScale*bl2;
436     param[9] = fScale*tl2;
437     param[10] = alp2;
438     G3name(gnam,name);
439     gMC->Gsvolu(name,"TRAP",GetMed(med),param,11);
440 }
441 //______________________________________________________________________
442 void AliITSBaseGeometry::Tube(const char *gnam,const TString &dis,
443                               Double_t rmin,Double_t rmax,Double_t dz,
444                               Int_t med){
445     // Interface to TMC->Gsvolu() for ITS TUBE geometries. Simple Tube. It has
446     // 3 parameters. See SetScale() 
447     // for units. Default units are geant 3 [cm].
448     // Inputs:
449     //    const char *gnam  3 character geant volume name. The letter "I"
450     //                        is appended to the front to indecate that this
451     //                        is an ITS volume.
452     //    TString &dis        String containging part discription.
453     //    Double_t rmin       Inside Radius.
454     //    Double_t rmax       Outside Radius.
455     //    Double_t dz         half-length along the z-axis
456     //    Int_t    med        media index number.
457     // Output:
458     //    none.
459     // Return.
460     //    none.
461     char name[5];
462     Float_t param[3];
463
464     param[0] = fScale*rmin;
465     param[1] = fScale*rmax;
466     param[2] = fScale*dz;
467     G3name(gnam,name);
468     gMC->Gsvolu(name,"TUBE",GetMed(med),param,3);
469 }
470 //______________________________________________________________________
471 void AliITSBaseGeometry::Tube(AliITSTubeData &d,Int_t med){
472     // Interface to TMC->Gsvolu() for ITS TUBE geometries. Simple Tube. It has
473     // 3 parameters. See SetScale() 
474     // for units. Default units are geant 3 [cm].
475     // Inputs:
476     //    AliITSTubeData     Structure with the tube parameters
477     //    Int_t    med        media index number.
478     // Output:
479     //    none.
480     // Return.
481     //    none.
482     char name[5];
483     Float_t param[3];
484     Int_t i,k;
485     char *j = (char *) &k;
486
487     param[0] = fScale*d.Rmin();
488     param[1] = fScale*d.Rmax();
489     param[2] = fScale*d.DzAt();
490     d.SetVid(AddVolName((d.GetName())->Data()));
491     k = ITSIndexToITSG3name(d.GetVid());
492     for(i=0;i<4;i++) name[i] = j[i];
493     name[4] = '\0';
494     gMC->Gsvolu(name,"TUBE",GetMed(med),param,3);
495 }
496 //______________________________________________________________________
497 void AliITSBaseGeometry::TubeSegment(const char *gnam,const TString &dis,
498                                      Double_t rmin,Double_t rmax,Double_t dz,
499                                      Double_t phi1,Double_t phi2,Int_t med){
500     // Interface to TMC->Gsvolu() for ITS TUBE geometries. Phi segment of a 
501     // tube. It has 5  parameters. Phi1 should be smaller than phi2. If this
502     // is not the case, the system adds 360 degrees to phi2. See SetScale() 
503     // for units. Default units are geant 3 [cm].
504     // Inputs:
505     //    const char *gnam  3 character geant volume name. The letter "I"
506     //                        is appended to the front to indecate that this
507     //                        is an ITS volume.
508     //    TString &dis        String containging part discription.
509     //    Double_t rmin       Inside Radius.
510     //    Double_t rmax       Outside Radius.
511     //    Double_t dz         half-length along the z-axis
512     //    Double_t phi1       Starting angle of the segment [degree].
513     //    Double_t phi2       Ending angle of the segment [degree].
514     //    Int_t    med        media index number.
515     // Output:
516     //    none.
517     // Return.
518     //    none.
519     char name[5];
520     Float_t param[5];
521
522     param[0] = fScale*rmin;
523     param[1] = fScale*rmax;
524     param[2] = fScale*dz;
525     param[3] = phi1;
526     param[4] = phi2;
527     G3name(gnam,name);
528     gMC->Gsvolu(name,"TUBS",GetMed(med),param,5);
529 }
530 //______________________________________________________________________
531 void AliITSBaseGeometry::Cone(const char *gnam,const TString &dis,
532                               Double_t dz,Double_t rmin1,Double_t rmax1,
533                               Double_t rmin2,Double_t rmax2,Int_t med){
534     // Interface to TMC->Gsvolu() for ITS Cone geometries. Conical tube. It 
535     // has 5 parameters. See SetScale() 
536     // for units. Default units are geant 3 [cm].
537     // Inputs:
538     //    const char *gnam  3 character geant volume name. The letter "I"
539     //                        is appended to the front to indecate that this
540     //                        is an ITS volume.
541     //    TString &dis        String containging part discription.
542     //    Double_t dz         half-length along the z-axis
543     //    Double_t rmin1      Inside Radius at -dz.
544     //    Double_t rmax1      Outside Radius at -dz.
545     //    Double_t rmin2      inside radius at +dz.
546     //    Double_t rmax2      outside radius at +dz.
547     //    Int_t    med        media index number.
548     // Output:
549     //    none.
550     // Return.
551     //    none.
552     char name[5];
553     Float_t param[5];
554
555     param[0] = fScale*dz;
556     param[1] = fScale*rmin1;
557     param[2] = fScale*rmax1;
558     param[3] = fScale*rmin2;
559     param[4] = fScale*rmax2;
560     G3name(gnam,name);
561     gMC->Gsvolu(name,"CONS",GetMed(med),param,5);
562 }
563 //______________________________________________________________________
564 void AliITSBaseGeometry::ConeSegment(const char *gnam,const TString &dis,
565                                      Double_t dz,Double_t rmin1,
566                                      Double_t rmax1,Double_t rmin2,
567                                      Double_t rmax2,Double_t phi1,
568                                      Double_t phi2,Int_t med){
569     // Interface to TMC->Gsvolu() for ITS ConS geometries. One segment of a 
570     // conical tube. It has 7 parameters. Phi1 should be smaller than phi2. 
571     // If this is not the case, the system adds 360 degrees to phi2. See 
572     // SetScale() for units. Default units are geant 3 [cm].
573     // Inputs:
574     //    const char *gnam  3 character geant volume name. The letter "I"
575     //                        is appended to the front to indecate that 
576     //                        this is an ITS volume.
577     //    TString &dis        String containging part discription.
578     //    Double_t dz         half-length along the z-axis
579     //    Double_t rmin1      Inside Radius at -dz.
580     //    Double_t rmax1      Outside Radius at -dz.
581     //    Double_t rmin2      inside radius at +dz.
582     //    Double_t rmax2      outside radius at +dz.
583     //    Double_t phi1       Starting angle of the segment [degree].
584     //    Double_t phi2       Ending angle of the segment [degree].
585     //    Int_t    med        media index number.
586     // Output:
587     //    none.
588     // Return.
589     //    none.
590     char name[5];
591     Float_t param[7];
592
593     param[0] = fScale*dz;
594     param[1] = fScale*rmin1;
595     param[2] = fScale*rmax1;
596     param[3] = fScale*rmin2;
597     param[4] = fScale*rmax2;
598     param[5] = phi1;
599     param[6] = phi2;
600     G3name(gnam,name);
601     gMC->Gsvolu(name,"CONS",GetMed(med),param,7);
602 }
603 //______________________________________________________________________
604 void AliITSBaseGeometry::Sphere(const char *gnam,const TString &dis,
605                                 Double_t rmin,Double_t rmax,Double_t the1,
606                                 Double_t the2,Double_t phi1,Double_t phi2,
607                                 Int_t med){
608     // Interface to TMC->Gsvolu() for ITS SPHE geometries. Segment of a 
609     // sphereical shell. It has 6 parameters. See SetScale() 
610     // for units. Default units are geant 3 [cm].
611     // Inputs:
612     //    const char *gnam  3 character geant volume name. The letter "I"
613     //                        is appended to the front to indecate that this
614     //                        is an ITS volume.
615     //    TString &dis        String containging part discription.
616     //    Double_t rmin       Inside Radius.
617     //    Double_t rmax       Outside Radius.
618     //    Double_t the1       staring polar angle of the shell [degree].
619     //    Double_t the2       ending polar angle of the shell [degree].
620     //    Double_t phui       staring asimuthal angle of the shell [degree].
621     //    Double_t phi2       ending asimuthal angle of the shell [degree].
622     //    Int_t    med        media index number.
623     // Output:
624     //    none.
625     // Return.
626     //    none.
627     char name[5];
628     Float_t param[6];
629
630     param[0] = fScale*rmin;
631     param[1] = fScale*rmax;
632     param[2] = the1;
633     param[3] = the2;
634     param[4] = phi1;
635     param[5] = phi2;
636     G3name(gnam,name);
637     gMC->Gsvolu(name,"SPHE",GetMed(med),param,6);
638 }
639 //______________________________________________________________________
640 void AliITSBaseGeometry::Parallelepiped(const char *gnam,const TString &dis,
641                                         Double_t dx,Double_t dy,Double_t dz,
642                                         Double_t alpha,Double_t thet,
643                                         Double_t phi,Int_t med){
644     // Interface to TMC->Gsvolu() for ITS PARA geometries. Parallelepiped. It 
645     // has 6 parameters. See SetScale() for units. Default units are geant 3 
646     // [cm].
647     // Inputs:
648     //    const char *gnam  3 character geant volume name. The letter "I"
649     //                        is appended to the front to indecate that this
650     //                        is an ITS volume.
651     //    TString &dis        String containging part discription.
652     //    Double_t dx         half-length allong x-axis
653     //    Double_t dy         half-length allong y-axis
654     //    Double_t dz         half-length allong z-axis
655     //    Double_t alpha      angle formed by the y axis and by the plane 
656     //                        joining the center of teh faces parallel to the 
657     //                        z-x plane at -dY and +dy [degree].
658     //    Double_t thet       polar angle of the line joining the centers of 
659     //                        the faces at -dz and +dz in z [degree].
660     //    Double_t phi        azimuthal angle of teh line joing the centers 
661     //                        of the faaces at -dz and +dz in z [degree].
662     //    Int_t    med        media index number.
663     // Output:
664     //    none.
665     // Return.
666     //    none.
667     char name[5];
668     Float_t param[6];
669
670     param[0] = fScale*dx;
671     param[1] = fScale*dy;
672     param[2] = fScale*dz;
673     param[3] = alpha;
674     param[4] = thet;
675     param[5] = phi;
676     G3name(gnam,name);
677     gMC->Gsvolu(name,"PARA",GetMed(med),param,6);
678 }
679 //______________________________________________________________________
680 void AliITSBaseGeometry::PolyGon(const char *gnam,const TString &dis,
681                                  Double_t phi1,Double_t dphi,Int_t npdv,
682                                  Int_t nz,Double_t *z,Double_t *rmin,
683                                  Double_t *rmax,Int_t med){
684     // Interface to TMC->Gsvolu() for ITS PGON geometry. Polygon It has 10 
685     // parameters or more. See SetScale() for units. Default units are geant
686     // 3 [cm].
687     // Inputs:
688     //    const char *gnam  3 character geant volume name. The letter "I"
689     //                        is appended to the front to indecate that this
690     //                        is an ITS volume.
691     //    TString &dis        String containging part discription.
692     //    Double_t phi1       the azimuthal angle at which the volume begins 
693     //                        (angles are counted clouterclockwise) [degrees].
694     //    Double_t dphi       opening angle of the volume, which extends from 
695     //                        phi1 to phi1+dphi [degree].
696     //    Int_t npdv          the number of sides of teh cross section 
697     //                        between the given phi limits.
698     //    Int_t nz            number of planes perpendicular to the z axis 
699     //                        where the dimension of the section is given - 
700     //                        this number should be at least 2 and NP triples 
701     //                        of number must follow.
702     //    Double_t *z         array [nz] of z coordiates of the sections..
703     //    Double_t *rmin      array [nz] of radius of teh circle tangent to 
704     //                        the sides of the inner polygon in teh 
705     //                        cross-section.
706     //    Double_t *rmax      array [nz] of radius of the circle tangent to 
707     //                        the sides of the outer polygon in the 
708     //                       cross-section.
709     //    Int_t    med        media index number.
710     // Output:
711     //    none.
712     // Return.
713     //    none.
714     char name[5];
715     Float_t *param;
716     Int_t n,i;
717
718     n = 4+3*nz;
719     param = new Float_t[n];
720     param[0] = phi1;
721     param[1] = dphi;
722     param[2] = (Float_t)npdv;
723     param[3] = (Float_t)nz;
724     for(i=0;i<nz;i++){
725         param[4+3*i] = fScale*z[i];
726         param[5+3*i] = fScale*rmin[i];
727         param[6+3*i] = fScale*rmax[i];
728     } // end for i
729     G3name(gnam,name);
730     gMC->Gsvolu(name,"PGON",GetMed(med),param,n);
731
732     delete[] param;
733 }
734 //______________________________________________________________________
735 void AliITSBaseGeometry::PolyGon(AliITSPGonData &d,Int_t med){
736     // Interface to TMC->Gsvolu() for ITS PCON geometry. Poly-cone It has 9 
737     // parameters or more. See SetScale() for units. Default units are geant
738     // 3 [cm].
739     // Inputs:
740     //    AliITSPGonData &d  Object with poly cone data stored in it.
741     //    Int_t    med        media index number.
742     // Output:
743     //    none.
744     // Return.
745     //    none.
746     char name[5];
747     Float_t *param;
748     Int_t n,i,k;
749     char *j = (char *) &k;
750
751     n = 4+3*d.Nz();
752     param = new Float_t[n];
753     param[0] = d.Phi0();
754     param[1] = d.DPhi();
755     param[2] = (Float_t) d.NPhi();
756     param[3] = (Float_t) d.Nz();
757     for(i=0;i<d.Nz();i++){
758         param[4+3*i] = fScale*d.ZAt(i);
759         param[5+3*i] = fScale*d.Rmin(i);
760         param[6+3*i] = fScale*d.Rmax(i);
761     } // end for i
762     d.SetVid(AddVolName((d.GetName())->Data()));
763     k = ITSIndexToITSG3name(d.GetVid());
764     for(i=0;i<4;i++) name[i] = j[i];
765     name[4] = '\0';
766     gMC->Gsvolu(name,"PGON",GetMed(med),param,n);
767
768     delete[] param;
769 }
770 //______________________________________________________________________
771 void AliITSBaseGeometry::PolyCone(const char *gnam,const TString &dis,
772                                   Double_t phi1,Double_t dphi,Int_t nz,
773                                   Double_t *z,Double_t *rmin,Double_t *rmax,
774                                   Int_t med){
775     // Interface to TMC->Gsvolu() for ITS PCON geometry. Poly-cone It has 9 
776     // parameters or more. See SetScale() for units. Default units are geant
777     // 3 [cm].
778     // Inputs:
779     //    const char *gnam  3 character geant volume name. The letter "I"
780     //                        is appended to the front to indecate that this
781     //                        is an ITS volume.
782     //    TString &dis        String containging part discription.
783     //    Double_t phi1       the azimuthal angle at which the volume begins 
784     //                        (angles are counted clouterclockwise) [degrees].
785     //    Double_t dphi       opening angle of the volume, which extends from 
786     //                        phi1 to phi1+dphi [degree].
787     //    Int_t nz            number of planes perpendicular to the z axis 
788     //                        where the dimension of the section is given - 
789     //                        this number should be at least 2 and NP triples 
790     //                        of number must follow.
791     //    Double_t *z         Array [nz] of z coordinate of the section.
792     //    Double_t *rmin      Array [nz] of radius of teh inner circle in the 
793     //                        cross-section.
794     //    Double_t *rmax      Array [nz] of radius of the outer circle in the 
795     //                        cross-section.
796     //    Int_t    med        media index number.
797     // Output:
798     //    none.
799     // Return.
800     //    none.
801     char name[5];
802     Float_t *param;
803     Int_t n,i;
804
805     n = 3+3*nz;
806     param = new Float_t[n];
807     param[0] = phi1;
808     param[1] = dphi;
809     param[2] = (Float_t) nz;
810     for(i=0;i<nz;i++){
811         param[3+3*i] = fScale*z[i];
812         param[4+3*i] = fScale*rmin[i];
813         param[5+3*i] = fScale*rmax[i];
814     } // end for i
815     G3name(gnam,name);
816     gMC->Gsvolu(name,"PCON",GetMed(med),param,n);
817
818     delete[] param;
819 }
820 //______________________________________________________________________
821 void AliITSBaseGeometry::PolyCone(AliITSPConeData &d,Int_t med){
822     // Interface to TMC->Gsvolu() for ITS PCON geometry. Poly-cone It has 9 
823     // parameters or more. See SetScale() for units. Default units are geant
824     // 3 [cm].
825     // Inputs:
826     //    AliITSPConeData &d  Object with poly cone data stored in it.
827     //    Int_t    med        media index number.
828     // Output:
829     //    none.
830     // Return.
831     //    none.
832     char name[5];
833     Float_t *param;
834     Int_t n,i,k;
835     char *j = (char *) &k;
836
837     n = 3+3*d.Nz();
838     param = new Float_t[n];
839     param[0] = d.Phi0();
840     param[1] = d.DPhi();
841     param[2] = (Float_t) d.Nz();
842     for(i=0;i<d.Nz();i++){
843         param[3+3*i] = fScale*d.ZAt(i);
844         param[4+3*i] = fScale*d.Rmin(i);
845         param[5+3*i] = fScale*d.Rmax(i);
846     } // end for if
847     d.SetVid(AddVolName((d.GetName())->Data()));
848     k = ITSIndexToITSG3name(d.GetVid());
849     for(i=0;i<4;i++) name[i] = j[i];
850     name[4] = '\0';
851     gMC->Gsvolu(name,"PCON",GetMed(med),param,n);
852
853     delete[] param;
854 }
855 //______________________________________________________________________
856 void AliITSBaseGeometry::TubeElliptical(const char *gnam,const TString &dis,
857                                Double_t p1,Double_t p2,Double_t dz,Int_t med){
858     // Interface to TMC->Gsvolu() for ITS ELTU geometries. Elliptical 
859     // cross-section Tube. It has 3 parameters. See SetScale() 
860     // for units. Default units are geant 3 [cm]. The equation of the surface 
861     // is x^2 * p1^-2 + y^2 * p2^-2 = 1.
862     // Inputs:
863     //    const char *gnam  3 character geant volume name. The letter "I"
864     //                        is appended to the front to indecate that this
865     //                        is an ITS volume.
866     //    TString &dis        String containging part discription.
867     //    Double_t p1         semi-axis of the elipse along x.
868     //    Double_t p2         semi-axis of the elipse along y.
869     //    Double_t dz         half-length along the z-axis
870     //    Int_t    med        media index number.
871     // Output:
872     //    none.
873     // Return.
874     //    none.
875     char name[5];
876     Float_t param[3];
877
878     param[0] = fScale*p1;
879     param[1] = fScale*p2;
880     param[2] = fScale*dz;
881     G3name(gnam,name);
882     gMC->Gsvolu(name,"ELTU",GetMed(med),param,3);
883 }
884 //______________________________________________________________________
885 void AliITSBaseGeometry::HyperbolicTube(const char *gnam,const TString &dis,
886                                Double_t rmin,Double_t rmax,Double_t dz,
887                                Double_t thet,Int_t med){
888     // Interface to TMC->Gsvolu() for ITS HYPE geometries. Hyperbolic tube. 
889     // Fore example the inner and outer surfaces are hyperboloids, as would 
890     // be foumed by a system of cylinderical wires which were then rotated 
891     // tangentially about their centers. It has 4 parameters. See SetScale() 
892     // for units. Default units are geant 3 [cm]. The hyperbolic surfaces are 
893     // given by r^2 = (ztan(thet)^2 + r(z=0)^2.
894     // Inputs:
895     //    const char *gnam  3 character geant volume name. The letter "I"
896     //                        is appended to the front to indecate that this
897     //                        is an ITS volume.
898     //    TString &dis        String containging part discription.
899     //    Double_t rmin       Inner radius at z=0 where tube is narrowest.
900     //    Double_t rmax       Outer radius at z=0 where tube is narrowest.
901     //    Double_t dz         half-length along the z-axis
902     //    Double_t thet       stero angel of rotation of the two faces 
903     //                       [degrees].
904     //    Int_t    med        media index number.
905     // Output:
906     //    none.
907     // Return.
908     //    none.
909     char name[5];
910     Float_t param[4];
911
912     param[0] = fScale*rmin;
913     param[1] = fScale*rmax;
914     param[2] = fScale*dz;
915     param[3] = thet;
916     G3name(gnam,name);
917     gMC->Gsvolu(name,"HYPE",GetMed(med),param,4);
918 }
919 //______________________________________________________________________
920 void AliITSBaseGeometry::TwistedTrapezoid(const char *gnam,
921                                           const TString &dis,
922                                  Double_t dz,Double_t thet,Double_t phi,
923                                  Double_t twist,Double_t h1,Double_t bl1,
924                                  Double_t tl1,Double_t apl1,Double_t h2,
925                                  Double_t bl2,Double_t tl2,Double_t apl2,
926                                  Int_t med){
927     // Interface to TMC->Gsvolu() for ITS GTRA geometries. General twisted 
928     // trapazoid. The faces perpendicular to z are trapazia and their centers 
929     // are not necessarily on a line parallel to the z axis as the TRAP. 
930     // Additionally, the faces may be twisted so that none of their edges are 
931     // parallel. It is a TRAP shape, exept that it is twisted in the x-y 
932     // plane as a function of z. The parallel sides perpendicular to the x 
933     // axis are rotated with respect to the x axis by an angle TWIST, which 
934     // is one of the parameters. The shape is defined by the eight corners 
935     // and is assumed to be constructed of straight lines joingin points on 
936     // the boundry of the trapezoidal face at Z=-dz to the coresponding 
937     // points on the face at z=+dz. Divisions are not allowed. It has 12 
938     // parameters. See SetScale() for units. Default units are geant 3 [cm].
939     // Note: This shape suffers from the same limitations than the TRAP. The
940     // tracking routines assume that the faces are planar, but htis
941     // constraint is not easily expressed in terms of the 12 parameters. 
942     // Additionally, no check on th efaces is performed in this case. Users 
943     // should avoid to use this shape as much as possible, and if they have
944     // to do so, they should make sure that the faces are really planes. 
945     // If this is not the case, the result of the trasport is unpredictable. 
946     // To accelerat ethe computations necessary for trasport, 18 additioanl 
947     // parameters are calculated for this shape are 1 DXODZ dx/dz of the 
948     // line joing the centers of the faces at z=+_dz. 2 DYODZ dy/dz of the 
949     // line joing the centers of the faces at z=+_dz.
950     // 3 XO1    x at z=0 for line joing the + on parallel side, perpendicular 
951     //          corners at z=+_dz.
952     // 4 YO1    y at z=0 for line joing the + on parallel side, + on 
953     //          perpendicular corners at z=+-dz.
954     // 5 DXDZ1  dx/dz for line joing the + on parallel side, + on 
955     //          perpendicular corners at z=+-dz.
956     // 6 DYDZ1  dy/dz for line joing the + on parallel side, + on 
957     //          perpendicular corners at z=+-dz.
958     // 7 X02    x at z=0 for line joing the - on parallel side, + on 
959     //          perpendicular corners at z=+-dz.
960     // 8 YO2    y at z=0 for line joing the - on parallel side, + on 
961     //          perpendicular corners at z=+-dz.
962     // 9 DXDZ2  dx/dz for line joing the - on parallel side, + on 
963     //          perpendicular corners at z=+-dz.
964     // 10 DYDZ2dy/dz for line joing the - on parallel side, + on 
965     //          perpendicular corners at z=+-dz.
966     // 11 XO3   x at z=0 for line joing the - on parallel side, - on 
967     //          perpendicular corners at z=+-dz.
968     // 12 YO3   y at z=0 for line joing the - on parallel side, - on 
969     //          perpendicular corners at z=+-dz.
970     // 13 DXDZ3 dx/dzfor line joing the - on parallel side, - on 
971     //          perpendicular corners at z=+-dz.
972     // 14 DYDZ3 dydz for line joing the - on parallel side, - on 
973     //          perpendicular corners at z=+-dz.
974     // 15 XO4   x at z=0 for line joing the + on parallel side, - on 
975     //          perpendicular corners at z=+-dz.
976     // 16 YO4   y at z=0 for line joing the + on parallel side, - on 
977     //          perpendicular corners at z=+-dz.
978     // 17 DXDZ4 dx/dz for line joing the + on parallel side, - on 
979     //          perpendicular corners at z=+-dz.
980     // 18 DYDZ4 dydz for line joing the + on parallel side, - on 
981     //          perpendicular corners at z=+-dz.
982     // Inputs:
983     //    const char *gnam  3 character geant volume name. The letter "I"
984     //                        is appended to the front to indecate that this
985     //                        is an ITS volume.
986     //    TString &dis        String containging part discription.
987     //    Double_t dz         half-length along the z axis.
988     //    Double_t thet       polar angle of the line joing the center of the 
989     //                        face at -dz to the center of the one at +dz 
990     //                        [degrees].
991     //    Double_t phi        Azymuthal angle of teh line joing the centre of 
992     //                        the face at -dz to the center of the one at +dz 
993     //                        [degrees].
994     //    Double_t twist      Twist angle of the faces parallel to the x-y 
995     //                        plane at z=+-dz around an axis parallel to z 
996     //                        passing through their centre [degrees].
997     //    Double_t h1         Half-length along y of the face at -dz.
998     //    Double_t bl1        half-length along x of the side -h1 in y of the 
999     //                        face at -dz in z.
1000     //    Double_t tl1        half-length along x of the side at +h1 in y of 
1001     //                        the face at -dz in z.
1002     //    Double_t apl1       Angle with respect to the y ais from the center 
1003     //                        of the side at -h1 in y to the centere of the 
1004     //                        side at +h1 in y of the face at -dz in z 
1005     //                        [degrees].
1006     //    Double_t h2         half-length along the face at +dz.
1007     //    Double_t bl2        half-length along x of the side at -h2 in y of 
1008     //                        the face at -dz in z.
1009     //    Double_t tl2        half-length along x of the side at +h2 in y of 
1010     //                        the face at +dz in z.
1011     //    Double_t apl2       angle with respect to the y axis from the 
1012     //                        center of the side at -h2 in y to the center 
1013     //                        of the side at +h2 in y of the face at +dz in 
1014     //                        z [degrees].
1015     //    Int_t    med        media index number.
1016     // Output:
1017     //    none.
1018     // Return.
1019     //    none.
1020     char name[5];
1021     Float_t param[12];
1022
1023     param[0] = fScale*dz;
1024     param[1] = thet;
1025     param[2] = phi;
1026     param[3] = twist;
1027     param[4] = fScale*h1;
1028     param[5] = fScale*bl1;
1029     param[6] = fScale*tl1;
1030     param[7] = apl1;
1031     param[8] = fScale*h2;
1032     param[9] = fScale*bl2;
1033     param[10] = fScale*tl2;
1034     param[11] = apl2;
1035     G3name(gnam,name);
1036     gMC->Gsvolu(name,"GTRA",GetMed(med),param,12);
1037 }
1038 //______________________________________________________________________
1039 void AliITSBaseGeometry::CutTube(const char *gnam,const TString &dis,
1040                                  Double_t rmin,Double_t rmax,Double_t dz,
1041                                  Double_t phi1,Double_t phi2,Double_t lx,
1042                                  Double_t ly,Double_t lz,Double_t hx,
1043                                  Double_t hy,Double_t hz,Int_t med){
1044     // Interface to TMC->Gsvolu() for ITS CTUB geometries. Cut tube. A tube 
1045     // cut at the extremities with planes not necessarily perpendicular to 
1046     // the z axis. It has 11 parameters. See SetScale() for units. Default 
1047     // units are geant 3 [cm]. phi1 should be smaller than phi2. If this is 
1048     // not the case, the system adds 360 degrees to phi2.
1049     // Inputs:
1050     //    const char *gnam  3 character geant volume name. The letter "I"
1051     //                        is appended to the front to indecate that this
1052     //                        is an ITS volume.
1053     //    TString &dis        String containging part discription.
1054     //    Double_t rmin       Inner radius at z=0 where tube is narrowest.
1055     //    Double_t rmax       Outer radius at z=0 where tube is narrowest.
1056     //    Double_t dz         half-length along the z-axis
1057     //    Double_t dz         half-length along the z-axis
1058     //    Double_t phi1       Starting angle of the segment [degree].
1059     //    Double_t phi2       Ending angle of the segment [degree].
1060     //    Double_t lx         x component of a unit vector perpendicular to 
1061     //                        the face at -dz.
1062     //    Double_t ly         y component of a unit vector perpendicular to 
1063     //                        the face at -dz.
1064     //    Double_t lz         z component of a unit vector perpendicular to 
1065     //                        the face at -dz.
1066     //    Double_t hx         x component of a unit vector perpendicular to 
1067     //                        the face at +dz.
1068     //    Double_t hy         y component of a unit vector perpendicular to 
1069     //                        the face at +dz.
1070     //    Double_t hz         z component of a unit vector perpendicular to 
1071     //                        the face at +dz.
1072     //    Int_t    med        media index number.
1073     // Output:
1074     //    none.
1075     // Return.
1076     //    none.
1077     char name[5];
1078     Float_t param[11];
1079
1080     param[0] = fScale*rmin;
1081     param[1] = fScale*rmax;
1082     param[2] = fScale*dz;
1083     param[3] = phi1;
1084     param[4] = phi2;
1085     param[5] = lx;
1086     param[6] = ly;
1087     param[7] = lz;
1088     param[8] = hx;
1089     param[9] = hy;
1090     param[10] = hz;
1091     G3name(gnam,name);
1092     gMC->Gsvolu(name,"CTUB",GetMed(med),param,11);
1093 }
1094 //______________________________________________________________________
1095 void AliITSBaseGeometry::Pos(AliITSBaseVolParams &v,Int_t cn,
1096                              AliITSBaseVolParams &m,
1097                              TVector3 &t,Int_t irot){
1098     // Place a copy of a volume previously defined by a call to GSVOLU inside 
1099     // its mother volulme moth.
1100     // Inputs:
1101     //   const char vol[3]  3 character geant volume name. The letter "I"
1102     //                      is appended to the front to indecate that this
1103     //                      is an ITS volume.
1104     //   const char moth[3] 3 character geant volume name of the mother 
1105     //                      volume in which vol will be placed. The letter 
1106     //                      "I" is appended to the front to indecate that 
1107     //                      this is an ITS volume.
1108     //   Double_t x         The x positon of the volume in the mother's 
1109     //                      reference system
1110     //   Double_t y         The y positon of the volume in the mother's 
1111     //                      reference system
1112     //   Double_t z         The z positon of the volume in the mother's 
1113     //                      reference system
1114     //   Int_t irot         the index for the rotation matrix to be used.
1115     //                      irot=-1 => unit rotation.
1116     // Outputs:
1117     //    none.
1118     // Return:
1119     //    none.
1120     char name[5],mother[5];
1121     Float_t param[3];
1122     Int_t r=0,i;
1123     char *n = (char*)&r;
1124
1125     param[0] = fScale*t.X();
1126     param[1] = fScale*t.Y();
1127     param[2] = fScale*t.Z();
1128     r = ITSIndexToITSG3name(v.GetVid());
1129     for(i=0;i<4;i++) name[i] = n[i]; name[4] ='\0';
1130     r = ITSIndexToITSG3name(m.GetVid());
1131     for(i=0;i<4;i++) mother[i] = n[i]; mother[4] ='\0';
1132     if(irot>0) r = fidrot[irot]; else r=0;
1133     gMC->Gspos(name,cn,mother,param[0],param[1],param[2],r,"ONLY");
1134 }
1135 //______________________________________________________________________
1136 void AliITSBaseGeometry::Pos(const char *vol,Int_t cn,const char *moth,
1137                              Double_t x,Double_t y,Double_t z,Int_t irot){
1138     // Place a copy of a volume previously defined by a call to GSVOLU inside 
1139     // its mother volulme moth.
1140     // Inputs:
1141     //   const char vol[3]  3 character geant volume name. The letter "I"
1142     //                      is appended to the front to indecate that this
1143     //                      is an ITS volume.
1144     //   const char moth[3] 3 character geant volume name of the mother 
1145     //                      volume in which vol will be placed. The letter 
1146     //                      "I" is appended to the front to indecate that 
1147     //                      this is an ITS volume.
1148     //   Double_t x         The x positon of the volume in the mother's 
1149     //                      reference system
1150     //   Double_t y         The y positon of the volume in the mother's 
1151     //                      reference system
1152     //   Double_t z         The z positon of the volume in the mother's 
1153     //                      reference system
1154     //   Int_t irot         the index for the rotation matrix to be used.
1155     //                      irot=-1 => unit rotation.
1156     // Outputs:
1157     //    none.
1158     // Return:
1159     //    none.
1160     char name[5],mother[5];
1161     Float_t param[3];
1162     Int_t r=0;
1163
1164     param[0] = fScale*x;
1165     param[1] = fScale*y;
1166     param[2] = fScale*z;
1167     G3name(vol,name);
1168     G3name(moth,mother);
1169     if(irot>0) r = fidrot[irot];
1170     gMC->Gspos(name,cn,mother,param[0],param[1],param[2],r,"ONLY");
1171 }
1172 //______________________________________________________________________
1173 void AliITSBaseGeometry::Matrix(Int_t irot,Double_t thet1,Double_t phi1,
1174                        Double_t thet2,Double_t phi2,
1175                        Double_t thet3,Double_t phi3){
1176     // Defines a Geant rotation matrix. checks to see if it is the unit
1177     // matrix. If so, then no additonal matrix is defined. Stores rotation 
1178     // matrix irot in the data structure JROTM. If the matrix is not 
1179     // orthonormal, it will be corrected by setting y' perpendicular to x' 
1180     // and z' = x' X y'. A warning message is printed in this case.
1181     // Inputs:
1182     //   Int_t irot     Intex specifing which rotation matrix.
1183     //   Double_t thet1 Polar angle for axisw x [degrees].
1184     //   Double_t phi1  azimuthal angle for axis x [degrees].
1185     //   Double_t thet12Polar angle for axisw y [degrees].
1186     //   Double_t phi2  azimuthal angle for axis y [degrees].
1187     //   Double_t thet3 Polar angle for axisw z [degrees].
1188     //   Double_t phi3  azimuthal angle for axis z [degrees].
1189     // Outputs:
1190     //    none.
1191     // Return:
1192     //    none.
1193     Float_t t1,p1,t2,p2,t3,p3;
1194
1195     if(thet1==90.0&&phi1== 0.0&&
1196        thet2==90.0&&phi2==90.0&&
1197        thet3== 0.0&&phi3== 0.0){
1198         fidrot[irot] = 0; // Unit matrix
1199     }else{
1200         t1 = thet1;
1201         p1 = phi1;
1202         t2 = thet2;
1203         p2 = phi2;
1204         t3 = thet3;
1205         p3 = phi3;
1206         fits->AliMatrix(fidrot[irot],t1,p1,t2,p2,t3,p3);
1207     } // end if
1208 }
1209 //______________________________________________________________________
1210 void AliITSBaseGeometry::Matrix(Int_t irot,Int_t axis,Double_t thet){
1211     // Defines a Geant rotation matrix. checks to see if it is the unit
1212     // matrix. If so, then no additonal matrix is defined. Stores rotation 
1213     // matrix irot in the data structure JROTM. If the matrix is not 
1214     // orthonormal, it will be corrected by setting y' perpendicular to x' 
1215     // and z' = x' X y'. A warning message is printed in this case.
1216     // Inputs:
1217     //   Int_t irot         Intex specifing which rotation matrix.
1218     //   Int_t axis         Axis about which rotation is to be done.
1219     //   Double_t thet      Angle to rotate by [degrees].
1220     // Outputs:
1221     //    none.
1222     // Return:
1223     //    none.
1224
1225     if(thet==0.0){
1226         fidrot[irot] = 0; // Unit matrix
1227     }else{
1228         switch (axis) {
1229         case 0: //Rotate about x-axis, x-axis does not change.
1230             fits->AliMatrix(fidrot[irot],90.0,0.0,90.0+thet,90.0,thet,90.0);
1231             break;
1232         case 1: //Rotate about y-axis, y-axis does not change.
1233             fits->AliMatrix(fidrot[irot],360.-90.0-thet,0.0,90.0,90.0,
1234                             thet,90.0);
1235             break;
1236         case 2: //Rotate about z-axis, z-axis does not change.
1237             fits->AliMatrix(fidrot[irot],90.0,thet,90.0,360.-thet-90.0,
1238                             0.0,0.0);
1239             break;
1240         default:
1241             Error("Matrix","axis must be either 0, 1, or 2. for matrix=%d",
1242                   irot);
1243             break;
1244         } // end switch
1245     } // end if
1246 }
1247 //______________________________________________________________________
1248 void AliITSBaseGeometry::Matrix(Int_t irot,Double_t rot[3][3]){
1249     // Defines a Geant rotation matrix. checks to see if it is the unit
1250     // matrix. If so, then no additonal matrix is defined. Stores rotation 
1251     // matrix irot in the data structure JROTM. If the matrix is not 
1252     // orthonormal, it will be corrected by setting y' perpendicular to x' 
1253     // and z' = x' X y'. A warning message is printed in this case.
1254     // Inputs:
1255     //   Int_t irot         Intex specifing which rotation matrix.
1256     //   Double_t rot[3][3] The 3 by 3 rotation matrix.
1257     // Outputs:
1258     //    none.
1259     // Return:
1260     //    none.
1261
1262     if(rot[0][0]==1.0&&rot[1][1]==1.0&&rot[2][2]==1.0&&
1263        rot[0][1]==0.0&&rot[0][2]==0.0&&rot[1][0]==0.0&&
1264        rot[1][2]==0.0&&rot[2][0]==0.0&&rot[2][1]==0.0){
1265         fidrot[irot] = 0; // Unit matrix
1266     }else{
1267         Double_t si,c=180./TMath::Pi();
1268         Double_t ang[6];
1269
1270         ang[1] = TMath::ATan2(rot[0][1],rot[0][0]);
1271         if(TMath::Cos(ang[1])!=0.0) si = rot[0][0]/TMath::Cos(ang[1]);
1272         else si = rot[0][1]/TMath::Sin(ang[1]);
1273         ang[0] = TMath::ATan2(si,rot[0][2]);
1274
1275         ang[3] = TMath::ATan2(rot[1][1],rot[1][0]);
1276         if(TMath::Cos(ang[3])!=0.0) si = rot[1][0]/TMath::Cos(ang[3]);
1277         else si = rot[1][1]/TMath::Sin(ang[3]);
1278         ang[2] = TMath::ATan2(si,rot[1][2]);
1279
1280         ang[5] = TMath::ATan2(rot[2][1],rot[2][0]);
1281         if(TMath::Cos(ang[5])!=0.0) si = rot[2][0]/TMath::Cos(ang[5]);
1282         else si = rot[2][1]/TMath::Sin(ang[5]);
1283         ang[4] = TMath::ATan2(si,rot[2][2]);
1284
1285         for(Int_t i=0;i<6;i++) {ang[i] *= c; if(ang[i]<0.0) ang[i] += 360.;}
1286         fits->AliMatrix(fidrot[irot],ang[0],ang[1],ang[2],ang[3],
1287                         ang[4],ang[5]);
1288     } // end if
1289 }
1290 //______________________________________________________________________
1291 Float_t AliITSBaseGeometry::GetA(Int_t z){
1292     // Returns the isotopicaly averaged atomic number.
1293     // Inputs:
1294     //    Int_t z  Elemental number
1295     // Outputs:
1296     //    none.
1297     // Return:
1298     //    The atomic mass number.
1299     const Float_t A[]={
1300           1.00794 ,  4.0026902,  6.941   ,  9.012182 , 10.811   , // H-B
1301          12.01007 , 14.00674  , 15.9994  , 18.9984032, 20.1797  , // C-Ne
1302          22.98970 , 24.3050   , 26.981538, 28.0855   , 30.973761, // Na-P
1303          32.066   , 35.4527   , 39.948   , 39.0983   , 40.078   , // S-Ca
1304          44.95591 , 47.867    , 50.9415  , 51.9961   , 54.938049, // Sc-Mn
1305          55.845   , 58.933200 , 58.6934  , 63.546    , 65.39    , // Fe-Zn
1306          69.723   , 72.61     , 74.92160 , 78.96     , 79.904   , // Ga-Br
1307          83.80    , 85.4678   , 87.62    , 88.9085   , 91.224   , // Kr-Zr
1308          92.90638 , 95.94     , 97.907215, 101.07    ,102.90550 , // Nb-Rh
1309         106.42    ,107.8682   ,112.411   ,114.818    ,118.710   , // Pd-Sn
1310         121.760   ,127.60     ,126.90447 ,131.29     ,132.90545 , // Sb-Cs
1311         137.327   ,138.9055   ,140.116   ,140.90765  ,144.24    , // La-Nd
1312         144.912746,150.36     ,151.964   ,157.25     ,158.92534 , // Pm-Tb
1313         162.50    ,164.93032  ,167.26    ,168.93421  ,173.04    , // Dy-Yb
1314         174.967   ,178.49     ,180.9479 ,183.84      ,186.207   , // Lu-Re
1315         190.23    ,192.217    ,195.078  ,196.96655   ,200.59    , // Os-Hg
1316         204.3833  ,207.2      ,208.98038,208.982415  ,209.987131, // Tl-At
1317         222.017570,223.019731 ,226.025402,227.027747 ,232.0381  , // Rn-Th
1318         231.03588 ,238.0289   }; // Pa,U
1319
1320     if(z<1||z>92){
1321         Error("GetA","z must be 0<z<93. z=%d",z);
1322         return 0.0;
1323     } // end if
1324     return A[z-1];
1325 }
1326 //______________________________________________________________________
1327 Float_t AliITSBaseGeometry::GetStandardMaxStepSize(Int_t istd){
1328     // Returns one of a set of standard Maximum Step Size values.
1329     // Inputs:
1330     //   Int_t istd  Index to indecate which standard.
1331     // Outputs:
1332     //    none.
1333     // Return:
1334     //    The appropreate standard Maximum Step Size value [cm].
1335     Float_t t[]={1.0, // default
1336                  0.0075, // Silicon detectors...
1337                  1.0, // Air in central detectors region
1338                  1.0  // Material in non-centeral region
1339     };
1340     return t[istd];
1341 }
1342 //______________________________________________________________________
1343 Float_t AliITSBaseGeometry::GetStandardThetaMax(Int_t istd){
1344     // Returns one of a set of standard Theata Max values.
1345     // Inputs:
1346     //   Int_t istd  Index to indecate which standard.
1347     // Outputs:
1348     //    none.
1349     // Return:
1350     //    The appropreate standard Theta max value [degrees].
1351     Float_t t[]={0.1, // default
1352                  0.1, // Silicon detectors...
1353                  0.1, // Air in central detectors region
1354                  1.0  // Material in non-centeral region
1355     };
1356     return t[istd];
1357 }
1358 //______________________________________________________________________
1359 Float_t AliITSBaseGeometry::GetStandardEfraction(Int_t istd){
1360     // Returns one of a set of standard E fraction values.
1361     // Inputs:
1362     //   Int_t istd  Index to indecate which standard.
1363     // Outputs:
1364     //    none.
1365     // Return:
1366     //    The appropreate standard E fraction value [#].
1367     Float_t t[]={0.1, // default
1368                  0.1, // Silicon detectors...
1369                  0.1, // Air in central detectors region
1370                  0.5  // Material in non-centeral region
1371     };
1372     return t[istd];
1373 }
1374 //______________________________________________________________________
1375 Float_t AliITSBaseGeometry::GetStandardEpsilon(Int_t istd){
1376     // Returns one of the standard Epsilon valuse
1377     // Inputs:
1378     //    Int_t istd  index of standard cuts to get
1379     // Output:
1380     //    none.
1381     // Return:
1382     //    Float_t the standard Epsilon cut value.
1383     Float_t t[]={1.0E-4, // default
1384                  1.0E-4, // Silicon detectors...
1385                  1.0E-4, // Air in central detector region
1386                  1.0E-3, // Material in non-cneteral regions
1387     };
1388
1389     return t[istd];
1390 }
1391 //______________________________________________________________________
1392 void AliITSBaseGeometry::Element(Int_t imat,const char* name,Int_t z,
1393                                  Double_t dens,Int_t istd){
1394     // Defines a Geant single element material and sets its Geant medium
1395     // proporties. The average atomic A is assumed to be given by their
1396     // natural abundances. Things like the radiation length are calculated
1397     // for you.
1398     // Inputs:
1399     //    Int_t imat       Material number.
1400     //    const char* name Material name. No need to add a $ at the end.
1401     //    Int_t z          The elemental number.
1402     //    Double_t dens    The density of the material [g/cm^3].
1403     //    Int_t istd       Defines which standard set of transport parameters
1404     //                     which should be used.
1405     // Output:
1406     //     none.
1407     // Return:
1408     //     none.
1409     Float_t rad,Z,A=GetA(z),tmax,stemax,deemax,epsilon;
1410     char *name2;
1411     Int_t len;
1412
1413     len = strlen(name)+1;
1414     name2 = new char[len];
1415     strncpy(name2,name,len-1);
1416     name2[len-1] = '\0';
1417     name2[len-2] = '$';
1418     Z = (Float_t)z;
1419     rad = GetRadLength(z)/dens;
1420     fits->AliMaterial(imat,name2,A,Z,dens,rad,0.0,0,0);
1421     tmax    = GetStandardThetaMax(istd);    // degree
1422     stemax  = GetStandardMaxStepSize(istd);  // cm
1423     deemax  = GetStandardEfraction(istd);     // ratio
1424     epsilon = GetStandardEpsilon(istd);       //
1425     fits->AliMedium(imat,name2,imat,0,gAlice->Field()->Integ(),
1426                     gAlice->Field()->Max(),tmax,stemax,deemax,epsilon,0.0);
1427     delete[] name2;
1428 }
1429 //______________________________________________________________________
1430 void AliITSBaseGeometry::MixtureByWeight(Int_t imat,const char* name,Int_t *z,
1431                                 Double_t *w,Double_t dens,Int_t n,Int_t istd){
1432     // Defines a Geant material by a set of elements and weights, and sets 
1433     // its Geant medium proporties. The average atomic A is assumed to be 
1434     // given by their natural abundances. Things like the radiation length 
1435     // are calculated for you.
1436     // Inputs:
1437     //    Int_t imat       Material number.
1438     //    const char* name Material name. No need to add a $ at the end.
1439     //    Int_t *z         Array of The elemental numbers.
1440     //    Double_t *w      Array of relative weights.
1441     //    Double_t dens    The density of the material [g/cm^3].
1442     //    Int_t n          the number of elements making up the mixture.
1443     //    Int_t istd       Defines which standard set of transport parameters
1444     //                     which should be used.   
1445     // Output:
1446     //     none.
1447     // Return:
1448     //     none.
1449     Float_t *Z,*A,*W,tmax,stemax,deemax,epsilon;
1450     char *name2;
1451     Int_t len,i;
1452     Z = new Float_t[n];
1453     A = new Float_t[n];
1454     W = new Float_t[n];
1455
1456     len = strlen(name)+2;
1457     name2 = new char[len];
1458     strncpy(name2,name,len-1);
1459     name2[len-1] = '\0';
1460     name2[len-2] = '$';
1461     for(i=0;i<n;i++){Z[i] = (Float_t)z[i];A[i] = (Float_t)GetA(z[i]);
1462                      W[i] = (Float_t)w[i];}
1463     fits->AliMixture(imat,name2,A,Z,dens,n,W);
1464     tmax    = GetStandardThetaMax(istd);    // degree
1465     stemax  = GetStandardMaxStepSize(istd);  // cm
1466     deemax  = GetStandardEfraction(istd);     // #
1467     epsilon = GetStandardEpsilon(istd);
1468     fits->AliMedium(imat,name2,imat,0,gAlice->Field()->Integ(),
1469               gAlice->Field()->Max(),tmax,stemax,deemax,epsilon,0.0);
1470     delete[] name2;
1471     delete[] Z;
1472     delete[] A;
1473     delete[] W;
1474 }
1475 //______________________________________________________________________
1476 void AliITSBaseGeometry::MixtureByNumber(Int_t imat,const char* name,Int_t *z,
1477                                 Int_t *w,Double_t dens,Int_t n,Int_t istd){
1478     // Defines a Geant material by a set of elements and number, and sets 
1479     // its Geant medium proporties. The average atomic A is assumed to be 
1480     // given by their natural abundances. Things like the radiation length 
1481     // are calculated for you.
1482     // Inputs:
1483     //    Int_t imat       Material number.
1484     //    const char* name Material name. No need to add a $ at the end.
1485     //    Int_t *z         Array of The elemental numbers.
1486     //    Int_t_t *w       Array of relative number.
1487     //    Double_t dens    The density of the material [g/cm^3].
1488     //    Int_t n          the number of elements making up the mixture.
1489     //    Int_t istd       Defines which standard set of transport parameters
1490     //                     which should be used.   
1491     // Output:
1492     //     none.
1493     // Return:
1494     //     none.
1495     Float_t *Z,*A,*W,tmax,stemax,deemax,epsilon;
1496     char *name2;
1497     Int_t len,i;
1498     Z = new Float_t[n];
1499     A = new Float_t[n];
1500     W = new Float_t[n];
1501
1502     len = strlen(name)+1;
1503     name2 = new char[len];
1504     strncpy(name2,name,len-1);
1505     name2[len-1] = '\0';
1506     name2[len-2] = '$';
1507     for(i=0;i<n;i++){Z[i] = (Float_t)z[i];A[i] = (Float_t)GetA(z[i]);
1508                      W[i] = (Float_t)w[i];}
1509     fits->AliMixture(imat,name2,A,Z,dens,-n,W);
1510     tmax    = GetStandardThetaMax(istd);    // degree
1511     stemax  = GetStandardMaxStepSize(istd);  // cm
1512     deemax  = GetStandardEfraction(istd);     // #
1513     epsilon = GetStandardEpsilon(istd);
1514     fits->AliMedium(imat,name2,imat,0,gAlice->Field()->Integ(),
1515                     gAlice->Field()->Max(),tmax,stemax,deemax,epsilon,0.0);
1516     delete[] name2;
1517     delete[] Z;
1518     delete[] A;
1519     delete[] W;
1520 }
1521 //______________________________________________________________________
1522 Double_t AliITSBaseGeometry::RadLength(Int_t iz,Double_t a){
1523     // Computes the radiation length in accordance to the PDG 2000 Section
1524     // 23.4.1 p. 166. Transladed from the c code of Flavio Tosello.
1525     // Inputs:
1526     //    Int_t iz    The elemental number
1527     //    Dougle_t    The elemental average atomic mass number
1528     // Outputs:
1529     // Return:
1530     //    Double_t returns the radiation length of the element iz in
1531     //             [gm/cm^2].
1532     Double_t z = (Double_t)iz;
1533     Double_t alphaz = fAlpha*z;
1534     Double_t alphaz2 = alphaz*alphaz;
1535     Double_t c0 = +0.20206,c1 = -0.0369,c2 = +0.0083,c3 = -0.0020;
1536     Double_t z12,z23,l,lp,c;
1537
1538     c = alphaz2*(1./(1.+alphaz2) + c0 + c1*alphaz2 + c2*alphaz2*alphaz2
1539                   +c3*alphaz2*alphaz2*alphaz2);
1540     z12 = TMath::Exp(TMath::Log(z)/3.0);
1541     z23 = z12*z12;
1542     switch (iz){
1543     case 1: //Hydrogen
1544         l  = 5.31;
1545         lp = 6.144;
1546         break;
1547     case 2: //Helium
1548         l  = 4.79;
1549         lp = 5,621;
1550         break;
1551     case 3: //Lithium
1552         l  = 4.74;
1553         lp = 5.805;
1554         break;
1555     case 4: //Berilium
1556         l  = 4.71;
1557         lp = 5.924;
1558         break;
1559     default: //Others
1560         l  = TMath::Log(184.15/z12);
1561         lp = TMath::Log(1194.0/z23);
1562         break;
1563     } // end switch
1564     Double_t re2,b,r,xz;
1565
1566     re2 = fRe*fRe;
1567     b = 4.0*fAlpha*re2*fNa/a;
1568     r = b*z*(z*(l-c)+lp);
1569     xz = 1.0/r;
1570     return xz; // [gm/cm^2]
1571 }
1572 //======================================================================
1573 ClassImp(AliITSPConeData)
1574 //______________________________________________________________________
1575 void AliITSPConeData::Print(ostream *os){
1576     // Prints out the data kept in this class
1577     // Inputs:
1578     //    ostream *os The output stream pointer
1579     // Outputs:
1580     //    none.
1581     // Return:
1582     //    none.
1583     Int_t i;
1584
1585 #if defined __GNUC__
1586 #if __GNUC__ > 2
1587     ios::fmtflags fmt;
1588 #else
1589     Int_t fmt;
1590 #endif
1591 #else
1592 #if defined __ICC || defined __ECC
1593     ios::fmtflags fmt;
1594 #else
1595     Int_t fmt;
1596 #endif
1597 #endif
1598
1599     *os << "Volume "<< GetVid() << " Name: " << *GetName() << endl;
1600     *os << "fNz=" << fNz << " fPhi0=" << fPhi0 << " fdPhi=" << fDphi << endl;
1601     *os <<"       Z        ,      Rmin      ,      Rmax      " << endl;
1602     fmt = os->setf(ios::scientific);  // set scientific floating point output
1603     for(i=0;i<fNz;i++){
1604         *os << setprecision(16) << fZ[i] <<"\t";
1605         *os << setprecision(16) << fRmin[i] << "\t";
1606         *os << setprecision(16) << fRmax[i] << endl;
1607     } // end for i
1608     os->flags(fmt); // reset back to old formating.
1609     return;
1610 }
1611 //______________________________________________________________________
1612 void AliITSPConeData::Read(istream *is){
1613     // Read in data kept in this class
1614     // Inputs:
1615     //   istream *is  the input stream
1616     // Outputs:
1617     //   none.
1618     // Return:
1619     //   none.
1620     Int_t i;
1621     char s[50];
1622     TString t;
1623
1624     is->get(s,7);
1625     *is >> i; SetVid(i);
1626     is->get(s,7);
1627     *is >> t; SetName(t.Data());
1628     is->get(s,4);
1629     *is >> fNz;
1630     is->get(s,6);
1631     *is >> fPhi0;
1632     is->get(s,6);
1633     *is >> fDphi;
1634     is->getline(s,49);
1635     Size(fNz);
1636     for(i=0;i<fNz;i++){
1637         *is >> fZ[i] >> fRmin[i] >> fRmax[i];
1638     } // end for i
1639 }
1640 //______________________________________________________________________
1641 ostream &operator<<(ostream &os,AliITSPConeData &p){
1642     // Operator << for C++ like output
1643     // Inputs:
1644     //    ostream &os        The output stream
1645     //    AliITSPConeData &p The class to be outputed
1646     // Output:
1647     //    none.
1648     // Return:
1649     //    ostream &os        The output stream
1650
1651     p.Print(&os);
1652     return os;
1653 }
1654 //______________________________________________________________________
1655 istream &operator>>(istream &is,AliITSPConeData &r){
1656     // Operator << for C++ like output
1657     // Inputs:
1658     //    istream &is        The input stream
1659     //    AliITSPConeData &r The class to be read in
1660     // Output:
1661     //    none.
1662     // Return:
1663     //    istream &is        The input stream
1664
1665     r.Read(&is);
1666     return is;
1667 }
1668 //======================================================================
1669 ClassImp(AliITSPGonData)
1670 //______________________________________________________________________
1671 void AliITSPGonData::Print(ostream *os){
1672     // Prints out the data kept in this class
1673     // Inputs:
1674     //    ostream *os The output stream pointer
1675     // Outputs:
1676     //    none.
1677     // Return:
1678     //    none.
1679     Int_t i;
1680
1681 #if defined __GNUC__
1682 #if __GNUC__ > 2
1683     ios::fmtflags fmt;
1684 #else
1685     Int_t fmt;
1686 #endif
1687 #else
1688 #if defined __ICC || defined __ECC
1689     ios::fmtflags fmt;
1690 #else
1691     Int_t fmt;
1692 #endif
1693 #endif
1694
1695     *os << "Volume "<< GetVid() << " Name: " << *GetName() << endl;
1696     *os << "fNz=" << fNz << " fNphi=" << fNphi << " fPhi0=" << fPhi0;
1697     *os << " fdPhi=" << fDphi << endl;
1698     *os <<"       Z        ,      Rmin      ,      Rmax      " << endl;
1699     fmt = os->setf(ios::scientific);  // set scientific floating point output
1700     for(i=0;i<fNz;i++){
1701         *os << setprecision(16) << fZ[i] <<"\t";
1702         *os << setprecision(16) << fRmin[i] << "\t";
1703         *os << setprecision(16) << fRmax[i] << endl;
1704     } // end for i
1705     os->flags(fmt); // reset back to old formating.
1706     return;
1707 }
1708 //______________________________________________________________________
1709 void AliITSPGonData::Read(istream *is){
1710     // Read in data kept in this class
1711     // Inputs:
1712     //   istream *is  the input stream
1713     // Outputs:
1714     //   none.
1715     // Return:
1716     //   none.
1717     Int_t i;
1718     char s[50];
1719     TString t;
1720
1721     is->get(s,7);
1722     *is >> i;SetVid(i);
1723     is->get(s,7);
1724     *is >> t; SetName(t.Data());
1725     
1726     is->get(s,4);
1727     *is >> fNz;
1728     is->get(s,6);
1729     *is >> fNphi;
1730     is->get(s,6);
1731     *is >> fPhi0;
1732     is->get(s,6);
1733     *is >> fDphi;
1734     is->getline(s,49);
1735
1736     Size(fNz);
1737     for(i=0;i<fNz;i++){
1738         *is >> fZ[i] >> fRmin[i] >> fRmax[i];
1739     } // end for i
1740 }
1741 //______________________________________________________________________
1742 ostream &operator<<(ostream &os,AliITSPGonData &p){
1743     // Operator << for C++ like output
1744     // Inputs:
1745     //    ostream &os       The output stream
1746     //    AliITSPGonData &p The class to be outputed
1747     // Output:
1748     //    none.
1749     // Return:
1750     //    ostream &os        The output stream
1751
1752     p.Print(&os);
1753     return os;
1754 }
1755 //______________________________________________________________________
1756 istream &operator>>(istream &is,AliITSPGonData &r){
1757     // Operator << for C++ like output
1758     // Inputs:
1759     //    istream &is       The input stream
1760     //    AliITSPGonData &r The class to be read in
1761     // Output:
1762     //    none.
1763     // Return:
1764     //    istream &is        The input stream
1765
1766     r.Read(&is);
1767     return is;
1768 }
1769 //======================================================================
1770 ClassImp(AliITSTubeData)
1771 //______________________________________________________________________
1772 void AliITSTubeData::Print(ostream *os){
1773     // Prints out the data kept in this class
1774     // Inputs:
1775     //    ostream *os The output stream pointer
1776     // Outputs:
1777     //    none.
1778     // Return:
1779     //    none.
1780
1781 #if defined __GNUC__
1782 #if __GNUC__ > 2
1783     ios::fmtflags fmt;
1784 #else
1785     Int_t fmt;
1786 #endif
1787 #else
1788 #if defined __ICC || defined __ECC
1789     ios::fmtflags fmt;
1790 #else
1791     Int_t fmt;
1792 #endif
1793 #endif
1794
1795     *os << "Volume "<< GetVid() << " Name: " << *GetName() << endl;
1796     *os <<"       Z        ,      Rmin      ,      Rmax      " << endl;
1797     fmt = os->setf(ios::scientific);  // set scientific floating point output
1798     *os << setprecision(16) << fDz <<"\t";
1799     *os << setprecision(16) << fRmin << "\t";
1800     *os << setprecision(16) << fRmax << endl;
1801     os->flags(fmt); // reset back to old formating.
1802     return;
1803 }
1804 //______________________________________________________________________
1805 void AliITSTubeData::Read(istream *is){
1806     // Read in data kept in this class
1807     // Inputs:
1808     //   istream *is  the input stream
1809     // Outputs:
1810     //   none.
1811     // Return:
1812     //   none.
1813     Int_t i;
1814     char s[50];
1815     TString t;
1816
1817     is->get(s,7);
1818     *is >> i;SetVid(i);
1819     is->get(s,7);
1820     *is >> t; SetName(t.Data());
1821     
1822     is->getline(s,49);
1823         *is >> fDz >> fRmin >> fRmax;
1824 }
1825 //______________________________________________________________________
1826 ostream &operator<<(ostream &os,AliITSTubeData &p){
1827     // Operator << for C++ like output
1828     // Inputs:
1829     //    ostream &os       The output stream
1830     //    AliITSTubeData &p The class to be outputed
1831     // Output:
1832     //    none.
1833     // Return:
1834     //    ostream &os        The output stream
1835
1836     p.Print(&os);
1837     return os;
1838 }
1839 //______________________________________________________________________
1840 istream &operator>>(istream &is,AliITSTubeData &r){
1841     // Operator << for C++ like output
1842     // Inputs:
1843     //    istream &is       The input stream
1844     //    AliITSTubeData &r The class to be read in
1845     // Output:
1846     //    none.
1847     // Return:
1848     //    istream &is        The input stream
1849
1850     r.Read(&is);
1851     return is;
1852 }