Work continues.
[u/mrichter/AliRoot.git] / ITS / AliITSv11.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.4  2003/01/29 16:01:14  nilsen
19 Update today's work.
20
21 Revision 1.3  2003/01/28 17:59:54  nilsen
22 Work continuing.
23
24 Revision 1.2  2003/01/26 14:35:15  nilsen
25 Some more geometry interface functions added and a start at the SSD support
26 cone geometry. Committed to allow easy updates of partical work between authors.
27
28 Revision 1.1  2003/01/20 23:32:49  nilsen
29 New ITS geometry. Only a Skeleton for now.
30
31 $Id$
32 */
33
34 //////////////////////////////////////////////////////////////////////////////
35 //                                                                          //
36 //  Inner Traking System version 11                                         //
37 //  This class contains the base procedures for the Inner Tracking System   //
38 //                                                                          //
39 // Authors: R. Barbera                                                      //
40 // version 6.                                                               //
41 // Created  2000.                                                           //
42 //                                                                          //
43 //  NOTE: THIS IS THE  SYMMETRIC PPR geometry of the ITS.                   //
44 // THIS WILL NOT WORK                                                       //
45 // with the geometry or module classes or any analysis classes. You are     //
46 // strongly encouraged to uses AliITSv5.                                    //
47 //                                                                          //
48 //////////////////////////////////////////////////////////////////////////////
49 // See AliITSv11::StepManager().
50 #include <Riostream.h>
51 #include <stdio.h>
52 #include <stdlib.h>
53 #include <TMath.h>
54 #include <TGeometry.h>
55 #include <TNode.h>
56 #include <TTUBE.h>
57 #include <TTUBS.h>
58 #include <TPCON.h>
59 #include <TFile.h>    // only required for Tracking function?
60 #include <TCanvas.h>
61 #include <TObjArray.h>
62 #include <TLorentzVector.h>
63 #include <TObjString.h>
64 #include <TClonesArray.h>
65 #include <TBRIK.h>
66 #include <TSystem.h>
67
68
69 #include "AliRun.h"
70 #include "AliMagF.h"
71 #include "AliConst.h"
72 #include "AliITSGeant3Geometry.h"
73 #include "AliITShit.h"
74 #include "AliITS.h"
75 #include "AliITSv11.h"
76 #include "AliITSgeom.h"
77 #include "AliITSgeomSPD.h"
78 #include "AliITSgeomSDD.h"
79 #include "AliITSgeomSSD.h"
80 #include "AliITSDetType.h"
81 #include "AliITSresponseSPD.h"
82 #include "AliITSresponseSDD.h"
83 #include "AliITSresponseSSD.h"
84 #include "AliITSsegmentationSPD.h"
85 #include "AliITSsegmentationSDD.h"
86 #include "AliITSsegmentationSSD.h"
87 #include "AliITSsimulationSPD.h"
88 #include "AliITSsimulationSDD.h"
89 #include "AliITSsimulationSSD.h"
90 #include "AliITSClusterFinderSPD.h"
91 #include "AliITSClusterFinderSDD.h"
92 #include "AliITSClusterFinderSSD.h"
93
94
95 ClassImp(AliITSv11)
96
97 //______________________________________________________________________
98 AliITSv11::AliITSv11() : AliITS() {
99     ////////////////////////////////////////////////////////////////////////
100     //    Standard default constructor for the ITS version 11.
101     ////////////////////////////////////////////////////////////////////////
102 }
103 //______________________________________________________________________
104 AliITSv11::AliITSv11(const char *title) : AliITS("ITS", title){
105     ////////////////////////////////////////////////////////////////////////
106     //    Standard constructor for the ITS version 11.
107     ////////////////////////////////////////////////////////////////////////
108 }
109 //______________________________________________________________________
110 AliITSv11::~AliITSv11() {
111     ////////////////////////////////////////////////////////////////////////
112     //    Standard destructor for the ITS version 11.
113     ////////////////////////////////////////////////////////////////////////
114 }
115 //______________________________________________________________________
116 void AliITSv11::Box(const char gnam[3],const TString &dis,
117                     Double_t dx,Double_t dy,Double_t dz,Int_t med){
118     // Interface to TMC->Gsvolu() for ITS bos geometries. Box with faces
119     // perpendicular to the axes. It has 3 paramters. See SetScale() for
120     // units. Default units are geant 3 [cm].
121     // Inputs:
122     //    const char gnam[3]  3 character geant volume name. The letter "I"
123     //                        is appended to the front to indecate that this
124     //                        is an ITS volume.
125     //    TString &dis        String containging part discription.
126     //    Double_t dx         half-length of box in x-axis
127     //    Double_t dy         half-length of box in y-axis
128     //    Double_t dz         half-length of box in z-axis
129     //    Int_t    med        media index number.
130     // Output:
131     //    none.
132     // Return.
133     //    none.
134     char name[4];
135     Float_t param[3];
136
137     param[0] = fScale*dx;
138     param[1] = fScale*dy;
139     param[2] = fScale*dz;
140     name[0] = 'I';
141     for(Int_t i=0;i<3;i++) name[i+1] = gnam[i];
142     gMC->Gsvolu(name,"BOX ",fidmed[med],param,3);
143 }
144 //______________________________________________________________________
145 void AliITSv11::Trapezoid1(const char gnam[3],const TString &dis,
146                            Double_t dxn,Double_t dxp,Double_t dy,Double_t dz,
147                            Int_t med){
148     // Interface to TMC->Gsvolu() for ITS TRD1 geometries. Trapezoid with the 
149     // x dimension varing along z. It has 4 parameters. See SetScale() for
150     // units. Default units are geant 3 [cm].
151     // Inputs:
152     //    const char gnam[3]  3 character geant volume name. The letter "I"
153     //                        is appended to the front to indecate that this
154     //                        is an ITS volume.
155     //    TString &dis        String containging part discription.
156     //    Double_t dxn        half-length along x at the z surface positioned 
157     //                        at -DZ
158     //    Double_t dxp        half-length along x at the z surface positioned 
159     //                        at +DZ
160     //    Double_t dy         half-length along the y-axis
161     //    Double_t dz         half-length along the z-axis
162     //    Int_t    med        media index number.
163     // Output:
164     //    none.
165     // Return.
166     //    none.
167     char name[4];
168     Float_t param[4];
169
170     param[0] = fScale*dxn;
171     param[1] = fScale*dxp;
172     param[2] = fScale*dy;
173     param[3] = fScale*dz;
174     name[0] = 'I';
175     for(Int_t i=0;i<3;i++) name[i+1] = gnam[i];
176     gMC->Gsvolu(name,"TRD1",fidmed[med],param,4);
177 }
178 //______________________________________________________________________
179 void AliITSv11::Trapezoid2(const char gnam[3],const TString &dis,Double_t dxn,
180                            Double_t dxp,Double_t dyn,Double_t dyp,Double_t dz,
181                            Int_t med){
182     // Interface to TMC->Gsvolu() for ITS TRD2 geometries. Trapezoid with the 
183     // x and y dimension varing along z. It has 5 parameters. See SetScale() 
184     // for units. Default units are geant 3 [cm].
185     // Inputs:
186     //    const char gnam[3]  3 character geant volume name. The letter "I"
187     //                        is appended to the front to indecate that this
188     //                        is an ITS volume.
189     //    TString &dis        String containging part discription.
190     //    Double_t dxn        half-length along x at the z surface positioned 
191     //                        at -DZ
192     //    Double_t dxp        half-length along x at the z surface positioned 
193     //                        at +DZ
194     //    Double_t dyn        half-length along x at the z surface positioned 
195     //                        at -DZ
196     //    Double_t dyp        half-length along x at the z surface positioned 
197     //                        at +DZ
198     //    Double_t dz         half-length along the z-axis
199     //    Int_t    med        media index number.
200     // Output:
201     //    none.
202     // Return.
203     //    none.
204     char name[4];
205     Float_t param[5];
206
207     param[0] = fScale*dxn;
208     param[1] = fScale*dxp;
209     param[2] = fScale*dyn;
210     param[3] = fScale*dyp;
211     param[4] = fScale*dz;
212     name[0] = 'I';
213     for(Int_t i=0;i<3;i++) name[i+1] = gnam[i];
214     gMC->Gsvolu(name,"TRD2",fidmed[med],param,5);
215 }
216 //______________________________________________________________________
217 void AliITSv11::Trapezoid(const char gnam[3],const TString &dis,Double_t dz,
218                           Double_t thet,Double_t phi,Double_t h1,Double_t bl1,
219                           Double_t tl1,Double_t alp1,Double_t h2,Double_t bl2,
220                           Double_t tl2,Double_t alp2,Int_t med){
221     // Interface to TMC->Gsvolu() for ITS TRAP geometries. General Trapezoid, 
222     // The faces perpendicular to z are trapezia and their centers are not 
223     // necessarily on a line parallel to the z axis. This shape has 11 
224     // parameters, but only cosidering that the faces should be planar, only 9 
225     // are really independent. A check is performed on the user parameters and 
226     // a message is printed in case of non-planar faces. Ignoring this warning 
227     // may cause unpredictable effects at tracking time. See SetScale() 
228     // for units. Default units are geant 3 [cm].
229     // Inputs:
230     //    const char gnam[3]  3 character geant volume name. The letter "I"
231     //                        is appended to the front to indecate that this
232     //                        is an ITS volume.
233     //    TString &dis        String containging part discription.
234     //    Double_t dz         Half-length along the z-asix
235     //    Double_t thet       Polar angle of the line joing the center of the 
236     //                        face at -dz to the center of the one at dz 
237     //                        [degree].
238     //    Double_t phi        aximuthal angle of the line joing the center of 
239     //                        the face at -dz to the center of the one at +dz 
240     //                        [degree].
241     //    Double_t h1         half-length along y of the face at -dz.
242     //    Double_t bl1        half-length along x of the side at -h1 in y of 
243     //                        the face at -dz in z.
244     //    Double_t tl1        half-length along x of teh side at +h1 in y of 
245     //                        the face at -dz in z.
246     //    Double_t alp1       angle with respect to the y axis from the center 
247     //                        of the side at -h1 in y to the cetner of the 
248     //                        side at +h1 in y of the face at -dz in z 
249     //                        [degree].
250     //    Double_t h2         half-length along y of the face at +dz
251     //    Double_t bl2        half-length along x of the side at -h2 in y of
252     //                        the face at +dz in z.
253     //    Double_t tl2        half-length along x of the side at _h2 in y of 
254     //                        the face at +dz in z.
255     //    Double_t alp2       angle with respect to the y axis from the center 
256     //                        of the side at -h2 in y to the center of the 
257     //                        side at +h2 in y of the face at +dz in z 
258     //                        [degree].
259     //    Int_t    med        media index number.
260     // Output:
261     //    none.
262     // Return.
263     //    none.
264     char name[4];
265     Float_t param[11];
266
267     param[0] = fScale*dz;
268     param[1] = thet;
269     param[2] = phi;
270     param[3] = fScale*h1;
271     param[4] = fScale*bl1;
272     param[5] = fScale*tl1;
273     param[6] = alp1;
274     param[7] = fScale*h2;
275     param[8] = fScale*bl2;
276     param[9] = fScale*tl2;
277     param[10] = alp2;
278     name[0] = 'I';
279     for(Int_t i=0;i<3;i++) name[i+1] = gnam[i];
280     gMC->Gsvolu(name,"TRAP",fidmed[med],param,11);
281 }
282 //______________________________________________________________________
283 void AliITSv11::Tube(const char gnam[3],const TString &dis,Double_t rmin,
284                      Double_t rmax,Double_t dz,Int_t med){
285     // Interface to TMC->Gsvolu() for ITS TUBE geometries. Simple Tube. It has
286     // 3 parameters. See SetScale() 
287     // for units. Default units are geant 3 [cm].
288     // Inputs:
289     //    const char gnam[3]  3 character geant volume name. The letter "I"
290     //                        is appended to the front to indecate that this
291     //                        is an ITS volume.
292     //    TString &dis        String containging part discription.
293     //    Double_t rmin       Inside Radius.
294     //    Double_t rmax       Outside Radius.
295     //    Double_t dz         half-length along the z-axis
296     //    Int_t    med        media index number.
297     // Output:
298     //    none.
299     // Return.
300     //    none.
301     char name[4];
302     Float_t param[3];
303
304     param[0] = fScale*rmin;
305     param[1] = fScale*rmax;
306     param[2] = fScale*dz;
307     name[0] = 'I';
308     for(Int_t i=0;i<3;i++) name[i+1] = gnam[i];
309     gMC->Gsvolu(name,"TUBE",fidmed[med],param,3);
310 }
311 //______________________________________________________________________
312 void AliITSv11::TubeSegment(const char gnam[3],const TString &dis,
313                             Double_t rmin,Double_t rmax,Double_t dz,
314                             Double_t phi1,Double_t phi2,Int_t med){
315     // Interface to TMC->Gsvolu() for ITS TUBE geometries. Phi segment of a 
316     // tube. It has 5  parameters. Phi1 should be smaller than phi2. If this is
317     // not the case, the system adds 360 degrees to phi2. See SetScale() 
318     // for units. Default units are geant 3 [cm].
319     // Inputs:
320     //    const char gnam[3]  3 character geant volume name. The letter "I"
321     //                        is appended to the front to indecate that this
322     //                        is an ITS volume.
323     //    TString &dis        String containging part discription.
324     //    Double_t rmin       Inside Radius.
325     //    Double_t rmax       Outside Radius.
326     //    Double_t dz         half-length along the z-axis
327     //    Double_t phi1       Starting angle of the segment [degree].
328     //    Double_t phi2       Ending angle of the segment [degree].
329     //    Int_t    med        media index number.
330     // Output:
331     //    none.
332     // Return.
333     //    none.
334     char name[4];
335     Float_t param[5];
336
337     param[0] = fScale*rmin;
338     param[1] = fScale*rmax;
339     param[2] = fScale*dz;
340     param[3] = phi1;
341     param[4] = phi2;
342     name[0] = 'I';
343     for(Int_t i=0;i<3;i++) name[i+1] = gnam[i];
344     gMC->Gsvolu(name,"TUBS",fidmed[med],param,5);
345 }
346 //______________________________________________________________________
347 void AliITSv11::Cone(const char gnam[3],const TString &dis,Double_t dz,
348                      Double_t rmin1,Double_t rmax1,Double_t rmin2,
349                      Double_t rmax2,Int_t med){
350     // Interface to TMC->Gsvolu() for ITS Cone geometries. Conical tube. It 
351     // has 5 parameters. See SetScale() 
352     // for units. Default units are geant 3 [cm].
353     // Inputs:
354     //    const char gnam[3]  3 character geant volume name. The letter "I"
355     //                        is appended to the front to indecate that this
356     //                        is an ITS volume.
357     //    TString &dis        String containging part discription.
358     //    Double_t dz         half-length along the z-axis
359     //    Double_t rmin1      Inside Radius at -dz.
360     //    Double_t rmax1      Outside Radius at -dz.
361     //    Double_t rmin2      inside radius at +dz.
362     //    Double_t rmax2      outside radius at +dz.
363     //    Int_t    med        media index number.
364     // Output:
365     //    none.
366     // Return.
367     //    none.
368     char name[4];
369     Float_t param[5];
370
371     param[0] = fScale*dz;
372     param[1] = fScale*rmin1;
373     param[2] = fScale*rmax1;
374     param[3] = fScale*rmin2;
375     param[4] = fScale*rmax2;
376     name[0] = 'I';
377     for(Int_t i=0;i<3;i++) name[i+1] = gnam[i];
378     gMC->Gsvolu(name,"CONS",fidmed[med],param,5);
379 }
380 //______________________________________________________________________
381 void AliITSv11::ConeSegment(const char gnam[3],const TString &dis,Double_t dz,
382                             Double_t rmin1,Double_t rmax1,Double_t rmin2,
383                             Double_t rmax2,Double_t phi1,Double_t phi2,
384                             Int_t med){
385     // Interface to TMC->Gsvolu() for ITS ConS geometries. One segment of a 
386     // conical tube. It has 7 parameters. Phi1 should be smaller than phi2. If 
387     // this is not the case, the system adds 360 degrees to phi2. See 
388     // SetScale() for units. Default units are geant 3 [cm].
389     // Inputs:
390     //    const char gnam[3]  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-axis
395     //    Double_t rmin1      Inside Radius at -dz.
396     //    Double_t rmax1      Outside Radius at -dz.
397     //    Double_t rmin2      inside radius at +dz.
398     //    Double_t rmax2      outside radius at +dz.
399     //    Double_t phi1       Starting angle of the segment [degree].
400     //    Double_t phi2       Ending angle of the segment [degree].
401     //    Int_t    med        media index number.
402     // Output:
403     //    none.
404     // Return.
405     //    none.
406     char name[4];
407     Float_t param[7];
408
409     param[0] = fScale*dz;
410     param[1] = fScale*rmin1;
411     param[2] = fScale*rmax1;
412     param[3] = fScale*rmin2;
413     param[4] = fScale*rmax2;
414     param[5] = phi1;
415     param[6] = phi2;
416     name[0] = 'I';
417     for(Int_t i=0;i<3;i++) name[i+1] = gnam[i];
418     gMC->Gsvolu(name,"CONS",fidmed[med],param,7);
419 }
420 //______________________________________________________________________
421 void AliITSv11::Sphere(const char gnam[3],const TString &dis,Double_t rmin,
422                        Double_t rmax,Double_t the1,Double_t the2,Double_t phi1,
423                        Double_t phi2,Int_t med){
424     // Interface to TMC->Gsvolu() for ITS SPHE geometries. Segment of a 
425     // sphereical shell. It has 6 parameters. See SetScale() 
426     // for units. Default units are geant 3 [cm].
427     // Inputs:
428     //    const char gnam[3]  3 character geant volume name. The letter "I"
429     //                        is appended to the front to indecate that this
430     //                        is an ITS volume.
431     //    TString &dis        String containging part discription.
432     //    Double_t rmin       Inside Radius.
433     //    Double_t rmax       Outside Radius.
434     //    Double_t the1       staring polar angle of the shell [degree].
435     //    Double_t the2       ending polar angle of the shell [degree].
436     //    Double_t phui       staring asimuthal angle of the shell [degree].
437     //    Double_t phi2       ending asimuthal angle of the shell [degree].
438     //    Int_t    med        media index number.
439     // Output:
440     //    none.
441     // Return.
442     //    none.
443     char name[4];
444     Float_t param[6];
445
446     param[0] = fScale*rmin;
447     param[1] = fScale*rmax;
448     param[2] = the1;
449     param[3] = the2;
450     param[4] = phi1;
451     param[5] = phi2;
452     name[0] = 'I';
453     for(Int_t i=0;i<3;i++) name[i+1] = gnam[i];
454     gMC->Gsvolu(name,"SPHE",fidmed[med],param,6);
455 }
456 //______________________________________________________________________
457 void AliITSv11::Parallelepiped(const char gnam[3],const TString &dis,
458                                Double_t dx,Double_t dy,Double_t dz,
459                                Double_t alph,Double_t thet,Double_t phi,
460                                Int_t med){
461     // Interface to TMC->Gsvolu() for ITS PARA geometries. Parallelepiped. It 
462     // has 6 parameters. See SetScale() for units. Default units are geant 3 
463     // [cm].
464     // Inputs:
465     //    const char gnam[3]  3 character geant volume name. The letter "I"
466     //                        is appended to the front to indecate that this
467     //                        is an ITS volume.
468     //    TString &dis        String containging part discription.
469     //    Double_t dx         half-length allong x-axis
470     //    Double_t dy         half-length allong y-axis
471     //    Double_t dz         half-length allong z-axis
472     //    Double_t alpha      angle formed by the y axis and by the plane 
473     //                        joining the center of teh faces parallel to the 
474     //                        z-x plane at -dY and +dy [degree].
475     //    Double_t thet       polar angle of the line joining the centers of 
476     //                        the faces at -dz and +dz in z [degree].
477     //    Double_t phi        azimuthal angle of teh line joing the centers of 
478     //                        the faaces at -dz and +dz in z [degree].
479     //    Int_t    med        media index number.
480     // Output:
481     //    none.
482     // Return.
483     //    none.
484     char name[4];
485     Float_t param[6];
486
487     param[0] = fScale*dx;
488     param[1] = fScale*dy;
489     param[2] = fScale*dz;
490     param[3] = alpha;
491     param[4] = thet;
492     param[5] = phi;
493     name[0] = 'I';
494     for(Int_t i=0;i<3;i++) name[i+1] = gnam[i];
495     gMC->Gsvolu(name,"PARA",fidmed[med],param,6);
496 }
497 //______________________________________________________________________
498 void AliITSv11::Polygon(const char gnam[3],const TString &dis,Double_t phi1,
499                         Double_t dphi,Int_t npdv,Int_t nz,Double_t *z,
500                         Double_t *rmin,Double_t *rmax,Double_t ,Int_t med){
501     // Interface to TMC->Gsvolu() for ITS PGON geometry. Polygon It has 10 
502     // parameters or more. See SetScale() for units. Default units are geant 3 
503     // [cm].
504     // Inputs:
505     //    const char gnam[3]  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 phi1       the azimuthal angle at which the volume begins 
510     //                        (angles are counted clouterclockwise) [degrees].
511     //    Double_t dphi       opening angle of the volume, which extends from 
512     //                        phi1 to phi1+dphi [degree].
513     //    Int_t npdv          the number of sides of teh cross section between 
514     //                        the given phi limits.
515     //    Int_t nz            number of planes perpendicular to the z axis 
516     //                        where the dimension of the section is given - 
517     //                        this number should be at least 2 and NP triples 
518     //                        of number must follow.
519     //    Double_t *z         array [nz] of z coordiates of the sections..
520     //    Double_t *rmin      array [nz] of radius of teh circle tangent to 
521     //                        the sides of the inner polygon in teh 
522     //                        cross-section.
523     //    Double_t *rmax      array [nz] of radius of the circle tangent to 
524     //                        the sides of the outer polygon in the 
525     //                       cross-section.
526     //    Int_t    med        media index number.
527     // Output:
528     //    none.
529     // Return.
530     //    none.
531     char name[4];
532     Float_t *param;
533     Int_t n,i;
534
535     n = 4+3*nz;
536     param = new Float_t[n]
537     param[0] = phi1;
538     param[1] = dphi;
539     param[2] = (Float_t)npdv;
540     param[3] = (Float_t)nz;
541     for(i=0;i<nz;i++){
542         param[4+3*i] = z[i];
543         param[5+3*i] = rmin[i];
544         param[6+3*i] = rmax[i];
545     } // end for i
546     name[0] = 'I';
547     for(i=0;i<3;i++) name[i+1] = gnam[i];
548     gMC->Gsvolu(name,"PGON",fidmed[med],param,n);
549
550     delete[] param;
551 }
552 //______________________________________________________________________
553 void AliITSv11::PolyCone(const char gnam[3],const TString &dis,Double_t phi1,
554                          Double_t dphi,Int_t nz,Double_t *z,Double_t *rmin,
555                          Double_t *rmax,Int_t med){
556     // Interface to TMC->Gsvolu() for ITS PCON geometry. Poly-cone It has 9 
557     // parameters or more. See SetScale() for units. Default units are geant 3 
558     // [cm].
559     // Inputs:
560     //    const char gnam[3]  3 character geant volume name. The letter "I"
561     //                        is appended to the front to indecate that this
562     //                        is an ITS volume.
563     //    TString &dis        String containging part discription.
564     //    Double_t phi1       the azimuthal angle at which the volume begins 
565     //                        (angles are counted clouterclockwise) [degrees].
566     //    Double_t dphi       opening angle of the volume, which extends from 
567     //                        phi1 to phi1+dphi [degree].
568     //    Int_t nz            number of planes perpendicular to the z axis 
569     //                        where the dimension of the section is given - 
570     //                        this number should be at least 2 and NP triples 
571     //                        of number must follow.
572     //    Double_t *z         Array [nz] of z coordinate of the section.
573     //    Double_t *rmin      Array [nz] of radius of teh inner circle in the 
574     //                        cross-section.
575     //    Double_t *rmax      Array [nz] of radius of the outer circle in the 
576     //                        cross-section.
577     //    Int_t    med        media index number.
578     // Output:
579     //    none.
580     // Return.
581     //    none.
582     char name[4];
583     Float_t *param;
584     Int_t n,i;
585
586     n = 3+3*nz;
587     param = new Float_t[n];
588     param[0] = phi1;
589     param[1] = dphi;
590     param[2] = (Float_t) nz;
591     for(i=0;i<nz;i++){
592         param[3+3*i] = z[i];
593         param[4+3*i] = rmin[i];
594         param[5+3*i] = rmax[i];
595     } // end for i
596     name[0] = 'I';
597     for(i=0;i<3;i++) name[i+1] = gnam[i];
598     gMC->Gsvolu(name,"PCON",fidmed[med],param,n);
599
600     delete[] param;
601 }
602 //______________________________________________________________________
603 void AliITSv11::TubeElliptical(const char gnam[3],const TString &dis,
604                                Double_t p1,Double_t p2,Double_t dz,Int_t med){
605     // Interface to TMC->Gsvolu() for ITS ELTU geometries. Elliptical 
606     // cross-section Tube. It has 3 parameters. See SetScale() 
607     // for units. Default units are geant 3 [cm]. The equation of the surface 
608     // is x^2 * p1^-2 + y^2 * p2^-2 = 1.
609     // Inputs:
610     //    const char gnam[3]  3 character geant volume name. The letter "I"
611     //                        is appended to the front to indecate that this
612     //                        is an ITS volume.
613     //    TString &dis        String containging part discription.
614     //    Double_t p1         semi-axis of the elipse along x.
615     //    Double_t p2         semi-axis of the elipse along y.
616     //    Double_t dz         half-length along the z-axis
617     //    Int_t    med        media index number.
618     // Output:
619     //    none.
620     // Return.
621     //    none.
622     char name[4];
623     Float_t param[3];
624
625     param[0] = fScale*p1;
626     param[1] = fScale*p2;
627     param[2] = fScale*dz;
628     name[0] = 'I';
629     for(Int_t i=0;i<3;i++) name[i+1] = gnam[i];
630     gMC->Gsvolu(name,"ELTU",fidmed[med],param,3);
631 }
632 //______________________________________________________________________
633 void AliITSv11::HyperbolicTube(const char gnam[3],const TString &dis,
634                                Double_t rmin,Double_t rmax,Double_t dz,
635                                Double_t thet,Int_t med){
636     // Interface to TMC->Gsvolu() for ITS HYPE geometries. Hyperbolic tube. 
637     // Fore example the inner and outer surfaces are hyperboloids, as would be 
638     // foumed by a system of cylinderical wires which were then rotated 
639     // tangentially about their centers. It has 4 parameters. See SetScale() 
640     // for units. Default units are geant 3 [cm]. The hyperbolic surfaces are 
641     // given by r^2 = (ztan(thet)^2 + r(z=0)^2.
642     // Inputs:
643     //    const char gnam[3]  3 character geant volume name. The letter "I"
644     //                        is appended to the front to indecate that this
645     //                        is an ITS volume.
646     //    TString &dis        String containging part discription.
647     //    Double_t rmin       Inner radius at z=0 where tube is narrowest.
648     //    Double_t rmax       Outer radius at z=0 where tube is narrowest.
649     //    Double_t dz         half-length along the z-axis
650     //    Double_t thet       stero angel of rotation of the two faces 
651     //                       [degrees].
652     //    Int_t    med        media index number.
653     // Output:
654     //    none.
655     // Return.
656     //    none.
657     char name[4];
658     Float_t param[4];
659
660     param[0] = fScale*rmin;
661     param[1] = fScale*rmax;
662     param[2] = fScale*dz;
663     param[3] = thet;
664     name[0] = 'I';
665     for(Int_t i=0;i<3;i++) name[i+1] = gnam[i];
666     gMC->Gsvolu(name,"HYPE",fidmed[med],param,4);
667 }
668 //______________________________________________________________________
669 void AliITSv11::TwistedTrapezoid(const char gnam[3],const TString &dis,
670                                  Double_t dz,Double_t thet,Double_t phi,
671                                  Double_t twist,Double_t h1,Double_t bl1,
672                                  Double_t tl1,Double_t apl1,Double_t h2,
673                                  Double_t bl2,Double_t tl2,Double_t apl2,
674                                  Int_t med){
675     // Interface to TMC->Gsvolu() for ITS GTRA geometries. General twisted 
676     // trapazoid. The faces perpendicular to z are trapazia and their centers 
677     // are not necessarily on a line parallel to the z axis as the TRAP. 
678     // Additionally, the faces may be twisted so that none of their edges are 
679     // parallel. It is a TRAP shape, exept that it is twisted in the x-y plane 
680     // as a function of z. The parallel sides perpendicular to the x axis are 
681     // rotated with respect to the x axis by an angle TWIST, which is one of 
682     // the parameters. The shape is defined by the eight corners and is assumed
683     // to be constructed of straight lines joingin points on the boundry of the
684     // trapezoidal face at Z=-dz to the coresponding points on the face at 
685     // z=+dz. Divisions are not allowed. It has 12 parameters. See SetScale() 
686     // for units. Default units are geant 3 [cm]. Note: This shape suffers from
687     // the same limitations than the TRAP. The tracking routines assume that 
688     // the faces are planar, but htis constraint is not easily expressed in 
689     // terms of the 12 parameters. Additionally, no check on th efaces is 
690     // performed in this case. Users should avoid to use this shape as much as 
691     // possible, and if they have to do so, they should make sure that the 
692     // faces are really planes. If this is not the case, the result of the 
693     // trasport is unpredictable. To accelerat ethe computations necessary for 
694     // trasport, 18 additioanl parameters are calculated for this shape are
695     // 1 DXODZ dx/dz of the line joing the centers of the faces at z=+_dz.
696     // 2 DYODZ dy/dz of the line joing the centers of the faces at z=+_dz.
697     // 3 XO1    x at z=0 for line joing the + on parallel side, perpendicular 
698     //          corners at z=+_dz.
699     // 4 YO1    y at z=0 for line joing the + on parallel side, + on 
700     //          perpendicular corners at z=+-dz.
701     // 5 DXDZ1  dx/dz for line joing the + on parallel side, + on 
702     //          perpendicular corners at z=+-dz.
703     // 6 DYDZ1  dy/dz for line joing the + on parallel side, + on 
704     //          perpendicular corners at z=+-dz.
705     // 7 X02    x at z=0 for line joing the - on parallel side, + on 
706     //          perpendicular corners at z=+-dz.
707     // 8 YO2    y at z=0 for line joing the - on parallel side, + on 
708     //          perpendicular corners at z=+-dz.
709     // 9 DXDZ2  dx/dz for line joing the - on parallel side, + on 
710     //          perpendicular corners at z=+-dz.
711     // 10 DYDZ2dy/dz for line joing the - on parallel side, + on 
712     //          perpendicular corners at z=+-dz.
713     // 11 XO3   x at z=0 for line joing the - on parallel side, - on 
714     //          perpendicular corners at z=+-dz.
715     // 12 YO3   y at z=0 for line joing the - on parallel side, - on 
716     //          perpendicular corners at z=+-dz.
717     // 13 DXDZ3 dx/dzfor line joing the - on parallel side, - on 
718     //          perpendicular corners at z=+-dz.
719     // 14 DYDZ3 dydz for line joing the - on parallel side, - on 
720     //          perpendicular corners at z=+-dz.
721     // 15 XO4   x at z=0 for line joing the + on parallel side, - on 
722     //          perpendicular corners at z=+-dz.
723     // 16 YO4   y at z=0 for line joing the + on parallel side, - on 
724     //          perpendicular corners at z=+-dz.
725     // 17 DXDZ4 dx/dz for line joing the + on parallel side, - on 
726     //          perpendicular corners at z=+-dz.
727     // 18 DYDZ4 dydz for line joing the + on parallel side, - on 
728     //          perpendicular corners at z=+-dz.
729     // Inputs:
730     //    const char gnam[3]  3 character geant volume name. The letter "I"
731     //                        is appended to the front to indecate that this
732     //                        is an ITS volume.
733     //    TString &dis        String containging part discription.
734     //    Double_t dz         half-length along the z axis.
735     //    Double_t thet       polar angle of the line joing the center of the 
736     //                        face at -dz to the center of the one at +dz 
737     //                        [degrees].
738     //    Double_t phi        Azymuthal angle of teh line joing the centre of 
739     //                        the face at -dz to the center of the one at +dz 
740     //                        [degrees].
741     //    Double_t twist      Twist angle of the faces parallel to the x-y 
742     //                        plane at z=+-dz around an axis parallel to z 
743     //                        passing through their centre [degrees].
744     //    Double_t h1         Half-length along y of the face at -dz.
745     //    Double_t bl1        half-length along x of the side -h1 in y of the 
746     //                        face at -dz in z.
747     //    Double_t tl1        half-length along x of the side at +h1 in y of 
748     //                        the face at -dz in z.
749     //    Double_t apl1       Angle with respect to the y ais from the center 
750     //                        of the side at -h1 in y to the centere of the 
751     //                        side at +h1 in y of the face at -dz in z 
752     //                        [degrees].
753     //    Double_t h2         half-length along the face at +dz.
754     //    Double_t bl2        half-length along x of the side at -h2 in y of 
755     //                        the face at -dz in z.
756     //    Double_t tl2        half-length along x of the side at +h2 in y of 
757     //                        the face at +dz in z.
758     //    Double_t apl2       angle with respect to the y axis from the center 
759     //                        of the side at -h2 in y to the center of the side
760     //                        at +h2 in y of the face at +dz in z [degrees].
761     //    Int_t    med        media index number.
762     // Output:
763     //    none.
764     // Return.
765     //    none.
766     char name[4];
767     Float_t param[12];
768
769     param[0] = fScale*dz;
770     param[1] = thet;
771     param[2] = phi;
772     param[3] = twist;
773     param[4] = fScale*h1;
774     param[5] = fScale*bl1;
775     param[6] = fScale*tl1;
776     param[7] = alp1;
777     param[8] = fScale*h2;
778     param[9] = fScale*bl2;
779     param[10] = fScale*tl2;
780     param[11] = alp2;
781     name[0] = 'I';
782     for(Int_t i=0;i<3;i++) name[i+1] = gnam[i];
783     gMC->Gsvolu(name,"GTRA",fidmed[med],param,12);
784 }
785 //______________________________________________________________________
786 void AliITSv11::CutTube(const char gnam[3],const TString &dis,Double_t rmin,
787                         Double_t rmax,Double_t dz,Double_t phi1,Double_t phi2,
788                         Double_t lx,Double_t ly,Double_t lz,Double_t hx,
789                         Double_t hy,Double_t hz,Int_t med){
790     // Interface to TMC->Gsvolu() for ITS CTUB geometries. Cut tube. A tube cut
791     // at the extremities with planes not necessarily perpendicular tot he z 
792     // axis. It has 11 parameters. See SetScale() for units. Default units are 
793     // geant 3 [cm]. phi1 should be smaller than phi2. If this is not the case,
794     // the system adds 360 degrees to phi2.
795     // Inputs:
796     //    const char gnam[3]  3 character geant volume name. The letter "I"
797     //                        is appended to the front to indecate that this
798     //                        is an ITS volume.
799     //    TString &dis        String containging part discription.
800     //    Double_t rmin       Inner radius at z=0 where tube is narrowest.
801     //    Double_t rmax       Outer radius at z=0 where tube is narrowest.
802     //    Double_t dz         half-length along the z-axis
803     //    Double_t dz         half-length along the z-axis
804     //    Double_t phi1       Starting angle of the segment [degree].
805     //    Double_t phi2       Ending angle of the segment [degree].
806     //    Double_t lx         x component of a unit vector perpendicular to 
807     //                        the face at -dz.
808     //    Double_t ly         y component of a unit vector perpendicular to 
809     //                        the face at -dz.
810     //    Double_t lz         z component of a unit vector perpendicular to 
811     //                        the face at -dz.
812     //    Double_t hx         x component of a unit vector perpendicular to 
813     //                        the face at +dz.
814     //    Double_t hy         y component of a unit vector perpendicular to 
815     //                        the face at +dz.
816     //    Double_t hz         z component of a unit vector perpendicular to 
817     //                        the face at +dz.
818     //    Int_t    med        media index number.
819     // Output:
820     //    none.
821     // Return.
822     //    none.
823     char name[4];
824     Float_t param[11];
825
826     param[0] = fScale*rmin;
827     param[1] = fScale*rmax;
828     param[2] = fScale*dz;
829     param[3] = phi1;
830     param[4] = phi2;
831     param[5] = lx;
832     param[6] = ly;
833     param[7] = lz;
834     param[8] = hx;
835     param[9] = hy;
836     param[10] = hz;
837     name[0] = 'I';
838     for(Int_t i=0;i<3;i++) name[i+1] = gnam[i];
839     gMC->Gsvolu(name,"CTUB",fidmed[med],param,11);
840 }
841 //______________________________________________________________________
842 void AliITSv11::Pos(const char vol[3],Int_t cn,const char moth[3],Double_t x,
843                     Double_t y,Double_t z,Int_t irot){
844     // Place a copy of a volume previously defined by a call to GSVOLU inside 
845     // its mother volulme moth.
846     // Inputs:
847     //   const char vol[3]  3 character geant volume name. The letter "I"
848     //                      is appended to the front to indecate that this
849     //                      is an ITS volume.
850     //   const char moth[3] 3 character geant volume name of the mother volume 
851     //                      in which vol will be placed. The letter "I" is 
852     //                      appended to the front to indecate that this is an 
853     //                      ITS volume.
854     //   Double_t x         The x positon of the volume in the mother's 
855     //                      reference system
856     //   Double_t y         The y positon of the volume in the mother's 
857     //                      reference system
858     //   Double_t z         The z positon of the volume in the mother's 
859     //                      reference system
860     //   Int_t irot         the index for the rotation matrix to be used.
861     //                      irot=-1 => unit rotation.
862     // Outputs:
863     //    none.
864     // Return:
865     //    none.
866     char name[4],mother[4];
867     Float_t param[3];
868     Int_t r=0,i;
869
870     param[0] = x;
871     param[1] = y;
872     param[2] = z;
873     name[0] = 'I';
874     for(i=0;i<3;i++) name[i+1] = vol[i];
875     mother[0] = 'I';
876     for(i=0;i<3;i++) mother[i+1] = moth[i];
877     if(irot>=0) r=fidrot[irot];
878     fMC->Gspos(name,mother,param[0],param[1],param[2],r,"ONLY");
879 }
880 //______________________________________________________________________
881 void AliITSv11::Matrix(Int_t irot,Double_t thet1,Double_t phi1,
882                        Double_t thet2,Double_t phi2,
883                        Double_t thet3,Double_t phi3){
884     // Defines a Geant rotation matrix. checks to see if it is the unit
885     // matrix. If so, then no additonal matrix is defined. Stores rotation 
886     // matrix irot in the data structure JROTM. If the matrix is not 
887     // orthonormal, it will be corrected by setting y' perpendicular to x' 
888     // and z' = x' X y'. A warning message is printed in this case.
889     // Inputs:
890     //   Int_t irot     Intex specifing which rotation matrix.
891     //   Double_t thet1 Polar angle for axisw x [degrees].
892     //   Double_t phi1  azimuthal angle for axis x [degrees].
893     //   Double_t thet12Polar angle for axisw y [degrees].
894     //   Double_t phi2  azimuthal angle for axis y [degrees].
895     //   Double_t thet3 Polar angle for axisw z [degrees].
896     //   Double_t phi3  azimuthal angle for axis z [degrees].
897     // Outputs:
898     //    none.
899     // Return:
900     //    none.
901     Float_t t1,p1,t2,p2,t3,p3;
902
903     if(thet1==90.0&&phi1==0.0&&thet2==90.0&&phi2==90.0&&thet3==0.0&&phi3==0.0){
904         fidrot[irot] = 0; // Unit matrix
905     }else{
906         t1 = thet1;
907         p1 = phi1;
908         t2 = thet2;
909         p2 = phi2;
910         t3 = thet3;
911         p3 = phi3
912         AliMatrix(fidrot[irot],t1,p1,t2,p2,t3,p3);
913     } // end if
914 }
915 //______________________________________________________________________
916 void AliITSv11::Matrix(Int_t irot,Int_t axis,Double_t thet){
917     // Defines a Geant rotation matrix. checks to see if it is the unit
918     // matrix. If so, then no additonal matrix is defined. Stores rotation 
919     // matrix irot in the data structure JROTM. If the matrix is not 
920     // orthonormal, it will be corrected by setting y' perpendicular to x' 
921     // and z' = x' X y'. A warning message is printed in this case.
922     // Inputs:
923     //   Int_t irot         Intex specifing which rotation matrix.
924     //   Int_t axis         Axis about which rotation is to be done.
925     //   Double_t thet      Angle to rotate by [degrees].
926     // Outputs:
927     //    none.
928     // Return:
929     //    none.
930
931     if(thet==0.0){
932         fidrot[irot] = 0; // Unit matrix
933     }else{
934         switch (irot) {
935         case 0: //Rotate about x-axis, x-axis does not change.
936             AliMatrix(fidrot[irot],90.0,0.0,90.0+thet,90.0,thet,90.0);
937             break;
938         case 1: //Rotate about y-axis, y-axis does not change.
939             AliMatrix(fidrot[irot],-90.0-thet,0.0,90.0,90.0,thet,90.0);
940             break;
941         case 2: //Rotate about z-axis, z-axis does not change.
942             AliMatrix(fidrot[irot],90.0,thet,90.0,-thet-90.0,0.0,0.0);
943             break;
944         default:
945             Error("Matrix","axis must be either 0, 1, or 2. for matrix=%d",
946                   irot);
947             break;
948         } // end switch
949     } // end if
950 }
951 //______________________________________________________________________
952 void AliITSv11::Matrix(Int_t irot,Double_t rot[3][3]){
953     // Defines a Geant rotation matrix. checks to see if it is the unit
954     // matrix. If so, then no additonal matrix is defined. Stores rotation 
955     // matrix irot in the data structure JROTM. If the matrix is not 
956     // orthonormal, it will be corrected by setting y' perpendicular to x' 
957     // and z' = x' X y'. A warning message is printed in this case.
958     // Inputs:
959     //   Int_t irot         Intex specifing which rotation matrix.
960     //   Double_t rot[3][3] The 3 by 3 rotation matrix.
961     // Outputs:
962     //    none.
963     // Return:
964     //    none.
965
966     if(rot[0][0]==1.0&&rot[1][1]==1.0&&rot[2][2]==1.0&&
967        rot[0][1]==0.0&&rot[0][2]==0.0&&rot[1][0]==0.0&&
968        rot[1][2]==0.0&&rot[2][0]==0.0&&rot[2][1]==0.0){
969         fidrot[irot] = 0; // Unit matrix
970     }else{
971         Double_t si,c=180./TMath::Pi();
972         Double_t ang[6];
973
974         ang[1] = TMath::ATan2(rot[0][1],rot[0][0]);
975         if(TMath::Cos(ang[1])!=0.0) si = rot[0][0]/TMath::Cos(ang[1]);
976         else si = rot[0][1]/TMath::Sin(ang[1]);
977         ang[0] = TMath::ATan2(si,rot[0][2]);
978
979         ang[3] = TMath::ATan2(rot[1][1],rot[1][0]);
980         if(TMath::Cos(ang[3])!=0.0) si = rot[1][0]/TMath::Cos(ang[3]);
981         else si = rot[1][1]/TMath::Sin(ang[3]);
982         ang[2] = TMath::ATan2(si,rot[1][2]);
983
984         ang[5] = TMath::ATan2(rot[2][1],rot[2][0]);
985         if(TMath::Cos(ang[5])!=0.0) si = rot[2][0]/TMath::Cos(ang[5]);
986         else si = rot[2][1]/TMath::Sin(ang[5]);
987         ang[4] = TMath::ATan2(si,rot[2][2]);
988
989         for(Int_t i=0;i<6;i++) {ang[i] *= c; if(ang[i]<0.0) ang[i] += 360.;}
990         AliMatrix(fidrot[irot],ang[0],ang[1],ang[2],ang[3],ang[4],ang[5]);
991     } // end if
992 }
993 //______________________________________________________________________
994 Float_t AliITSv11::GetA(Int_t z){
995     // Returns the isotopicaly averaged atomic number.
996     // Inputs:
997     //    Int_t z  Elemental number
998     // Outputs:
999     //    none.
1000     // Return:
1001     //    The atomic mass number.
1002     const Float_t A[]={ 1.00794 ,  4.0026902,  6.941   ,  9.012182 , 10.811   ,
1003                        12.01007 , 14.00674  , 15.9994  , 18.9984032, 20.1797  ,
1004                        22.98970 , 24.3050   , 26.981538, 28.0855   , 30.973761,
1005                        32.066   , 35.4527   , 39.948   , 39.0983   , 40.078   ,
1006                        44.95591 , 47.867    , 50.9415  , 51.9961   , 54.938049,
1007                        55.845   , 58.933200 , 58.6934  , 63.546    , 65.39    ,
1008                        69.723   , 72.61     , 74.92160 , 78.96     , 79.904   ,
1009                        83.80    , 85.4678   , 87.62    , 88.9085   , 91.224   ,
1010                        92.90638 , 95.94     , 97.907215, 101.07    ,102.90550 ,
1011                       106.42    ,107.8682   ,112.411   ,114.818    ,118.710   ,
1012                       121.760   ,127.60     ,126.90447 ,131.29     ,132.90545 ,
1013                       137.327   ,138.9055   ,140.116   ,140.90765  ,144.24    ,
1014                       144.912746,150.36     ,151.964   ,157.25     ,158.92534 ,
1015                       162.50     ,164.93032 ,167.26    ,168.93421  ,173.04    ,
1016                       174.967    ,178.49    ,180.9479 ,183.84      ,186.207   ,
1017                       190.23     ,192.217   ,195.078  ,196.96655   ,200.59    ,
1018                       204.3833   ,207.2     ,208.98038,208.982415  ,209.987131,
1019                       222.017570 ,223.019731,226.025402,227.027747 ,232.0381  ,
1020                       231.03588  238.0289};
1021
1022     if(z<1||z>92){
1023         Error("GetA","z must be 0<z<93. z=%d",z);
1024         return 0.0;
1025     } // end if
1026     return A[z-1];
1027 }
1028 //______________________________________________________________________
1029 Float_t AliITSv11::GetStandardMaxStepSize(Int_t istd){
1030     // Returns one of a set of standard Maximum Step Size values.
1031     // Inputs:
1032     //   Int_t istd  Index to indecate which standard.
1033     // Outputs:
1034     //    none.
1035     // Return:
1036     //    The appropreate standard Maximum Step Size value [cm].
1037     Float_t t[]={1.0, // default
1038                  0.0075, // Silicon detectors...
1039                  1.0, // Air in central detectors region
1040                  1.0  // Material in non-centeral region
1041     };
1042     return t[istd];
1043 }
1044 //______________________________________________________________________
1045 Float_t AliITSv11::GetStandardThetaMax(Int_t istd){
1046     // Returns one of a set of standard Theata Max values.
1047     // Inputs:
1048     //   Int_t istd  Index to indecate which standard.
1049     // Outputs:
1050     //    none.
1051     // Return:
1052     //    The appropreate standard Theta max value [degrees].
1053     Float_t t[]={0.1, // default
1054                  0.1, // Silicon detectors...
1055                  0.1, // Air in central detectors region
1056                  1.0  // Material in non-centeral region
1057     };
1058     return t[istd];
1059 }
1060 //______________________________________________________________________
1061 Float_t AliITSv11::GetStandardEfraction(Int_t istd){
1062     // Returns one of a set of standard E fraction values.
1063     // Inputs:
1064     //   Int_t istd  Index to indecate which standard.
1065     // Outputs:
1066     //    none.
1067     // Return:
1068     //    The appropreate standard E fraction value [#].
1069     Float_t t[]={0.1, // default
1070                  0.1, // Silicon detectors...
1071                  0.1, // Air in central detectors region
1072                  1.0  // Material in non-centeral region
1073     };
1074     return t[istd];
1075 }
1076 //______________________________________________________________________
1077 void AliITSv11::Element(Int_t imat,const char* name,Int_t z,Double_t dens,
1078                         Int_t istd){
1079     // Defines a Geant single element material and sets its Geant medium
1080     // proporties. The average atomic A is assumed to be given by their
1081     // natural abundances. Things like the radiation length are calculated
1082     // for you.
1083     // Inputs:
1084     //    Int_t imat       Material number.
1085     //    const char* name Material name. No need to add a $ at the end.
1086     //    Int_t z          The elemental number.
1087     //    Double_t dens    The density of the material [g/cm^3].
1088     //    Int_t istd       Defines which standard set of transport parameters
1089     //                     which should be used.
1090     // Output:
1091     //     none.
1092     // Return:
1093     //     none.
1094     Float_t rad,Z,A=GetA(z),tmax,stemax,deemax,epsilon;
1095     char *name2;
1096     Int_t len;
1097
1098     len = strlng(name)+1;
1099     name2 = new char[len];
1100     strncpy(name2,name,len-1);
1101     name2[len-1] = '\0';
1102     name2[len-2] = '$';
1103     Z = (Float_t)z;
1104     rad = GetRadLength(z)/dens;
1105     AliMaterial(imat,name2,A,Z,dens,rad,0.0,0,0);
1106     tmax    = GetStandardTheataMax(istd);    // degree
1107     stemax  = GetStandardMaxStepSize(istd);  // cm
1108     deemax  = GetStandardEfraction(istd);     // #
1109     epsilon = GetStandardEpsilon(istd);
1110     AliMedium(imat,name2,imat,0,gAlice->Field()->Integ(),
1111               gAlice->Field()->Max(),tmax,stemax,deemax,epsilon,0.0);
1112     delete[] name2;
1113 }
1114 //______________________________________________________________________
1115 void AliITSv11::MixtureByWeight(Int_t imat,const char* name,Int_t *z,
1116                                 Double_t *w,Double_t dens,Int_t n,Int_t istd){
1117     // Defines a Geant material by a set of elements and weights, and sets 
1118     // its Geant medium proporties. The average atomic A is assumed to be 
1119     // given by their natural abundances. Things like the radiation length 
1120     // are calculated for you.
1121     // Inputs:
1122     //    Int_t imat       Material number.
1123     //    const char* name Material name. No need to add a $ at the end.
1124     //    Int_t *z         Array of The elemental numbers.
1125     //    Double_t *w      Array of relative weights.
1126     //    Double_t dens    The density of the material [g/cm^3].
1127     //    Int_t n          the number of elements making up the mixture.
1128     //    Int_t istd       Defines which standard set of transport parameters
1129     //                     which should be used.   
1130     // Output:
1131     //     none.
1132     // Return:
1133     //     none.
1134     Float_t rad,*Z,*A,tmax,stemax,deemax,epsilon;
1135     char *name2;
1136     Int_t len,i;
1137     Z = new Float_t[n];
1138     A = new Float_t[n];
1139
1140     len = strlng(name)+1;
1141     name2 = new char[len];
1142     strncpy(name2,name,len-1);
1143     name2[len-1] = '\0';
1144     name2[len-2] = '$';
1145     for(i=0;i<n;i++){Z[i] = (Float_t)z[i];A[i] = (Float_t)GetA(z[i]);
1146                      W[i] = (Float_t)w[i]}
1147     rad = GetRadLength(z)/dens;
1148     AliMixture(imat,name2,A,Z,dens,n,W);
1149     tmax    = GetStandardTheataMax(istd);    // degree
1150     stemax  = GetStandardMaxStepSize(istd);  // cm
1151     deemax  = GetStandardEfraction(istd);     // #
1152     epsilon = GetStandardEpsilon(istd);
1153     AliMedium(imat,name2,imat,0,gAlice->Field()->Integ(),
1154               gAlice->Field()->Max(),tmax,stemax,deemax,epsilon,0.0);
1155     delete[] name2;
1156 }
1157 //______________________________________________________________________
1158 void AliITSv11::MixtureByNumber(Int_t imat,const char* name,Int_t *z,
1159                                 Int_t *w,Double_t dens,Int_t n,Int_t istd){
1160     // Defines a Geant material by a set of elements and number, and sets 
1161     // its Geant medium proporties. The average atomic A is assumed to be 
1162     // given by their natural abundances. Things like the radiation length 
1163     // are calculated for you.
1164     // Inputs:
1165     //    Int_t imat       Material number.
1166     //    const char* name Material name. No need to add a $ at the end.
1167     //    Int_t *z         Array of The elemental numbers.
1168     //    Int_t_t *w       Array of relative number.
1169     //    Double_t dens    The density of the material [g/cm^3].
1170     //    Int_t n          the number of elements making up the mixture.
1171     //    Int_t istd       Defines which standard set of transport parameters
1172     //                     which should be used.   
1173     // Output:
1174     //     none.
1175     // Return:
1176     //     none.
1177     Float_t rad,*Z,*A,tmax,stemax,deemax,epsilon;
1178     char *name2;
1179     Int_t len,i;
1180     Z = new Float_t[n];
1181     A = new Float_t[n];
1182
1183     len = strlng(name)+1;
1184     name2 = new char[len];
1185     strncpy(name2,name,len-1);
1186     name2[len-1] = '\0';
1187     name2[len-2] = '$';
1188     for(i=0;i<n;i++){Z[i] = (Float_t)z[i];A[i] = (Float_t)GetA(z[i]);
1189                      W[i] = (Float_t)w[i]}
1190     rad = GetRadLength(z)/dens;
1191     AliMixture(imat,name2,A,Z,dens,-n,W);
1192     tmax    = GetStandardTheataMax(istd);    // degree
1193     stemax  = GetStandardMaxStepSize(istd);  // cm
1194     deemax  = GetStandardEfraction(istd);     // #
1195     epsilon = GetStandardEpsilon(istd);
1196     AliMedium(imat,name2,imat,0,gAlice->Field()->Integ(),
1197               gAlice->Field()->Max(),tmax,stemax,deemax,epsilon,0.0);
1198     delete[] name2;
1199 //______________________________________________________________________
1200 void AliITSv11::SSDConeDetail(TVector3 &tran,const char moth[3],Int_t mat0){
1201     // Defines the volumes and materials for the ITS SSD Support cone.
1202     // Based on drawings ALR-0767 and ALR-0767/3. Units are in mm.
1203     // Inputs:
1204     //   Double_t zShift  The z shift to be applied to the final volume.
1205     // Outputs:
1206     //   none.
1207     // Return:
1208     //   none.
1209     Double_t th = 13.0; //mm, Thickness of Rohacell+carbon fiber
1210     Double_t ct=1.5; //mm, Carbon finber thickness
1211     Double_t r=15.0; // mm, Radius of curvature.
1212     Double_t tc=51.0; // angle of SSD cone [degrees].
1213     Double_t sintc=Sind(tc),costc=Cosd(tc),tantc=Tand(tc);
1214     Double_t z0=0.0,zcylinder=170.0,zpost=196.0;
1215     Double_t Routmax=0.5*985.0,RoutHole=0.5*965.0,Routmin=0.5*945.0;
1216     Double_t Rholemax=0.5*890.0,Rholemin=0.5*740.0;
1217     Double_t RPostmin=316.0,dRPost=23.0,zpostmax=196.0,phi0post=30.0;
1218     Double_t Rinmax=0.5*590.0,Rincylinder=0.5*597.0,RinHole=0.5*575.0,
1219              Rinmin=0.5*562.0,dzin=15.0;
1220     Int_t nspoaks=12,ninscrews=40,npost=4,nmounts=4;
1221     Int_t SSDcf=man0+1; // SSD support cone Carbon Fiber materal number.
1222     Int_t SSDfs=mat0+2; // SSD support cone inserto stesalite 4411w.
1223     Int_t SSDfo=mat0+3; // SSD support cone foam, Rohacell 50A.
1224     Int_t SSDsw=mat0+4; // SSD support cone screw material,Stainless steal
1225     Int_t ncse=0; // number of screw ends (copy number)
1226     Int_t ncpe=0; // number of pin end (copy number)
1227     Int_t ncst=0; // number of screw tops (copy number)
1228     Double_t t; // some general angle [degrees].
1229     Double_t phi0=0.0,dphi=360.0,x,y,z;
1230     Int_t i,j,k,l,n,nz,nrad=0;
1231
1232     SetScalemm();
1233     // Lets start with the upper left outer carbon fiber surface.
1234     // Between za[2],rmaxa[2] and za[4],rmaxa[4] there is a curved section
1235     // given by rmaxa = rmaxa[2]-r*Sind(t) for 0<=t<=tc and 
1236     // za = za[2] + r*Cosd(t) for 0<=t<=tc. Simularly between za[1],rmina[1
1237     // and za[3],rmina[3] there is a curve section given by
1238     // rmina = rmina[1]-r*Sind(t) for 0<=t<=tc and za = za[1]+r&Sind(t)
1239     // for t<=0<=tc. These curves have been replaced by straight lines
1240     // between the equivelent points for simplicity.
1241     Double_t dza = th/sintc-(Routmax-Routmin)/tantc;
1242     if(dza<=0){ // The number or order of the points are in error for a proper
1243         // call to pcons!
1244         Error("SSDcone","The definition of the points for a call to PCONS is"
1245               " in error. abort.");
1246         return;
1247     } // end if
1248     nz = 7;
1249     Double_t *za    = new Double_t[nz];
1250     Double_t *rmina = new Double_t[nz];
1251     Double_t *rmaxa = new Double_t[nz];
1252     za[0]    = z0;
1253     rmina[0] = Routmin;
1254     rmaxa[0] = Routmax;
1255     za[1]    = za[0]+13.5-5.0 - dza; // za[2] - dza.
1256     rmina[1] = rmina[0];
1257     rmaxa[1] =rmaxa[0];
1258     za[2]    = za[0]+13.5-5.0; // From Drawing ALR-0767 and ALR-0767/3
1259     rmaxa[2] = rmaxa[0];
1260     za[3]    = za[1]+rc*sintc;
1261     rmina[3] = rmina[1]-rc*sintc;
1262     rmina[2] = rmina[1]+(rmina[3]-rmina[1])*(za[2]-za[1])/(za[3]-za[1]);
1263     za[4]    = za[2]+rc*sintc;
1264     rmaxa[4] = rmaxa[2]-rc*sintc;
1265     rmaxa[3] = rmaxa[2]+(rmaxa[4]-rmaxa[2])*(za[3]-za[2])/(za[4]-za[2]);
1266     rmina[5] = Rholemax;
1267     za[5]    = za[3]+(za[4]-za[3])*(rmina[5]-rmina[3])/(rmina[4]-rmina[3]);
1268     rmina[4] = rmina[3]+(rmina[5]-rmina[3])*(za[4]-za[3])/(za[5]-za[3]);
1269     za[6]    = th/sinth+za[5];
1270     rmina[6] = Rholemax;
1271     rmaxa[6] = rmina[6];
1272     rmaxa[5] = rmaxa[4]+(rmaxa[6]-rmaxa[4])*(za[5]-za[4])/(za[6]-za[4]);
1273     //
1274     PolyCone("SCA","SSD Suport cone Carbon Fiber Surface outer left",
1275              phi0,dphi,nz,*z,*rmin,*rmax,SSDcf);
1276     Pos("SCA",1,moth,trans.x(),trans.y(),trans.z(),0);
1277     XMatrix(1,180.0);
1278     Pos("SCA",2,moth,trans.x(),trans.y(),-trans.z(),1);
1279     Za[0] = 1.; Wa[0] = ; // Hydrogen Content
1280     Za[1] = 6.; Wa[1] = ; // Carbon Content
1281     MixtureByWeight(SSDcf,"Carbon Fiber for SSD support cone",Z,W,dens,2);
1282     //
1283     // Now lets define the Inserto Stesalite 4411w material volume.
1284     nz = 6;
1285     Double_t *zb    = new Double_t[nz];
1286     Double_t *rminb = new Double_t[nz];
1287     Double_t *rmaxb = new Double_t[nz];
1288     zb[0] = z0;
1289     rminb[0] = rmina[0]+ct;
1290     rmaxb[0] = rmaxa[0]-ct;
1291     zb[1] = za[1];
1292     rminb[1] = rminb[0];
1293     rmaxb[1] = rmaxb[0];
1294     zb[2] = za[2];
1295     rmaxb[2] = rmaxb[1];
1296     zb[3] = za[4] - ct/sintc;
1297     rmaxb[3] = rmaxb[2] - (rc-ct)*sintc;
1298     zb[4] = za[3]+ct/sintc;
1299     rminb[4] = rminb[1]-(rc-ct)*sintc;
1300     rminb[2] = rminb[1]+(rminb[4]-rminb[1])*(zb[2]-zb[1])/(zb[4]-zb[1]);
1301     rminb[3] = rminb[1]+(rminb[4]-rminb[1])*(zb[3]-zb[1])/(zb[4]-zb[1]);
1302     zb[5] = zb[4]+(ct-2.*ct)/sintc;
1303     rminb[5] = rminb[4]+(ct-2.*ct)*tantc;
1304     rmaxb[5] = rminb[5];
1305     rmaxb[4] = rmaxb[3]+(rmaxb[5]-rmaxb[3])*(zb[4]-zb[3])/(zb[5]-zb[3]);
1306     PolyCone("SCB","SSD Suport cone Inserto Stesalite left edge",
1307              phi0,dphi,nz,*zb,*rminb,*rmaxb,SSDfs);
1308     Pos("SCB",1,"SCA",0.0,.0,0.0,0);
1309     Za[0] = 1.; Wa[0] = ; // Hydrogen Content
1310     Za[1] = 6.; Wa[1] = ; // Carbon Content
1311     MixtureByWeight(SSDfs,"Inserto stealite 4411w for SSD support cone",
1312                     Z,W,dens,3);
1313     //
1314     // Now lets define the Rohacell foam material volume.
1315     nz = 4;
1316     Double_t *zc    = new Double_t[nz];
1317     Double_t *rminc = new Double_t[nz];
1318     Double_t *rmaxc = new Double_t[nz];
1319     zc[0] = zb[4];
1320     rminc[0] = rminb[4];
1321     rmaxc[0] = rmminc[0];
1322     zc[1] = zb[5];
1323     rmaxc[1] = rminb[5];
1324     zc[2] = za[5] + ct/sintc;
1325     rminc[2] = rmina[5]+ct; // leave space for carbon fiber covering hole.
1326     rminc[1] = rminc[0] +(rminc[2]-rminc[0])*(zc[1]-zc[0])/(zc[2]-zc[0]);
1327     zc[3] = za[6] - ct/sintc;
1328     rminc[3] = rmina[6]+ct;
1329     rmaxc[3] = rminc[3];
1330     rmaxc[2] = rmaxc[1]+(rmaxc[3]-rmaxc[1])*(zc[2]-zc[1])/(zc[3]-zc[1]);
1331     PolyCone("SCC","SSD Suport cone Rohacell foam left edge",
1332              phi0,dphi,nz,*zc,*rminc,*rmaxc,SSDfo);
1333     Pos("SCC",1,"SCA",0.0,.0,0.0,0);
1334     Za[0] = 1.; Wa[0] = ; // Hydrogen Content
1335     Za[1] = 6.; Wa[1] = ; // Carbon Content
1336     MixtureByWeight(SSDfo,"Foam core (Rohacell 50A) for SSD support cone",
1337                     Z,W,dens,3);
1338     //
1339     // In volume SCB, th Inserto Stesalite 4411w material volume, there
1340     // are a number of Stainless steel screw and pin studs which will be
1341     // filled with screws/studs.
1342     Double_t rmin=0.0,rmax=6.0,dz=0.5*10.0; // mm
1343     Tube("SCD","Screw+stud used to mount things to the SSD support cone",
1344          rmin,rmax,dz,SSDsw);
1345     rmin=0.0;rmax=6.0;dz=0.5*12.0; // mm
1346     Tube("SCE","pin used to mount things to the SSD support cone",
1347          rmin,rmax,dz,SSDsw);
1348     Za[0] =  6.; Wa[0] = ; // Carbon Content
1349     Za[1] = 25.; Wa[1] = ; // Iron Content
1350     MixtureByWeight(SSDsw,"Stainless steal screw, pin, and stud material",
1351                     Z,W,dens,3);
1352     k=l=0;
1353     for(i=0;i<2;i++){ // position for ITS-TPC mounting brackets
1354         for(j=0;j<2;j++){ // 2 screws per bracket
1355             ncse++;
1356             t = -5.0+10.0*((Double_t)j)+180.*((Double_t)i);
1357             x = RoutHole*Sind(t);
1358             y = RoutHole*Cosd(t);
1359             z = dz;
1360             Pos("SCD",ncse,"SCB",x,y,z,0);
1361         } // end for j
1362         for(j=0;j<3;j++){ // 3 pins per bracket
1363             ncpe++;
1364             t = -3.0+3.0*((Double_t)j)+180.*((Double_t)i);
1365             x = RoutHole*Sind(t);
1366             y = RoutHole*Cosd(t);
1367             z = dz;
1368             Pos("SCE",ncpe,"SCB",x,y,z,0);
1369         } // end for j
1370     } // end for i
1371     for(i=0;i<2;i++){ // position for ITS-rail mounting brackets
1372         for(j=0;j<4;j++){ // 4 screws per bracket
1373             Double_t a[4]={0.0,2.0,5.0,7.0}; // Relative angles.
1374             ncse++;
1375             t = 90.0-a[j]+187.*((Double_t)i);
1376             x = RoutHole*Sind(t);
1377             y = RoutHole*Cosd(t);
1378             z = dz;
1379             Pos("SCD",kncs,"SCB",x,y,z,0);
1380         } // end for j
1381         for(j=0;j<2;j++){ // 2 pins per bracket
1382             ncpe++;
1383             t = 88+7.0*((Double_t)j)+184.*((Double_t)i);
1384             x = RoutHole*Sind(t);
1385             y = RoutHole*Cosd(t);
1386             z = dz;
1387             Pos("SCE",ncse,"SCB",x,y,z,0);
1388         } // end for j
1389     } // end for i
1390     for(i=0;i<nmounts;i++){ // mounting holes/screws for beam pipe support
1391         // and SPD cone support (dump side,non-dump side has them to).
1392         for(j=0;j<2;j++){ // 2 screws per bracket
1393             ncse++;
1394             t = 180.*20./(RoutHole*TMath::Pi());
1395             t = 45.0+((Doulbe_t)(j-1))*t+90.*((Double_t)i);
1396             x = RoutHole*Sind(t);
1397             y = RoutHole*Cosd(t);
1398             z = dz;
1399             Pos("SCD",ncse,"SCB",x,y,z,0);
1400         } // end for j
1401         for(j=0;j<1;j++){ // 1 pins per bracket
1402             ncpe++;
1403             t = 45.0+90.*((Double_t)i);
1404             x = RoutHole*Sind(t);
1405             y = RoutHole*Cosd(t);
1406             z = dz;
1407             Pos("SCE",ncpe,"SCB",x,y,z,0);
1408         } // end for j
1409     } // end for i
1410     //
1411     // There is no carbon fiber between this upper left section and the
1412     // SSD spoaks. We remove it by replacing it with Rohacell foam.
1413     t = ct/(0.5*(Rholemax+Rholemin));// It is not posible to get the
1414     // carbon fiber thickness uniform in this phi direction. We can only
1415     // make it a fixed angular thickness.
1416     t *= 180.0/TMath::Pi();
1417     dphi = 5.0 - 2.0*t; // degrees
1418     phi0 = 12.5+t; // degrees see drawing ALR-0767.
1419     nz = 4;
1420     Double_t *zf    = new Double_t[nz];
1421     Double_t *rminf = new Double_t[nz];
1422     Double_t *rmaxf = new Double_t[nz];
1423     zf[0] = zc[2];
1424     rminf[0] = rminc[3];
1425     rmaxf[0] = rminf[0];
1426     rminf[1] = rmina[5];
1427     rmaxf[1] = rminf[0];
1428     zf[1] = zc[0]+(zc[2]-zc[0])*(rminf[1]-rminc[0])/(rminc[2]-rminc[0]);
1429     zf[2] = zc[3];
1430     rminf[2] = rminf[1];
1431     rmaxf[2] = rmaxf[1];
1432     zf[3] = zc[1]+(zc[3]-zc[1])*(rmaxf[3]-rmaxc[1])/(rmaxc[3]-rmaxc[1]);
1433     rminf[3] = rmina[5];
1434     rmaxf[3] = rminf[3];
1435     PolyCone("SCF","SSD Suport cone Rohacell foam left edge",
1436              phi0,dphi,nz,*zc,*rminc,*rmaxc,SSDfo);
1437     Pos("SCF",1,"SCA",0.0,.0,0.0,0);
1438     for(i=1;i<nspoaks;i++){
1439         Zmatrix(irot+i,360./((Double_t)nspoaks));
1440         Pos("SCG",i+1,"SCA",0.0,.0,0.0,irot+i);
1441     } // end for i
1442     //=================================================================
1443     // Now for the spoak part of the SSD cone.
1444     // It is not posible to inclue the radius of curvature between
1445     // the spoak part and the upper left part of the SSD cone or lowwer right
1446     // part. This would be discribed by the following curves.
1447     // R = Rmax - (5mm)*Sin(t) phi = phi0+(5mm*180/(Pi*RoutHole))*Sin(t) 
1448     // where 0<=t<=90 For the inner curve a simular equiation holds.
1449     phi0 = 12.5; // degrees see drawing ALR-0767.
1450     dphi = 5.0; // degrees
1451     nz = 4;
1452     Double_t *zg    = new Double_t[nz];
1453     Double_t *rming = new Double_t[nz];
1454     Double_t *rmaxg = new Double_t[nz];
1455     zg[0] = zb[5];
1456     rming[0] = rmina[5];
1457     rmaxg[0] = rming[0];
1458     zg[1] = za[6];
1459     rming[1] = -thatc*(zg[1]-za[3])+rmina[3];
1460     rmaxg[1] = rmaxg[0];
1461     rming[2] = Rholemin;
1462     zg[2] = za[3]-(rming[2]-rmina[3])/tantc;
1463     rmaxg[2] = -thatc*(zg[2]-za[4])+rmaxa[4];
1464     rming[3] = rming[2];
1465     rmaxg[3] = rming[3];
1466     zg[3] = za[4]-(rmaxg[3]-rmaxa[4])/tantc;
1467     PolyCone("SCG","SSD spoak carbon fiber surfaces",
1468              phi0,dphi,nz,*zc,*rminc,*rmaxc,SSDcf);
1469     Pos("SCG",i+1,"SCA",0.0,.0,0.0,0);
1470     for(i=1;i<nspoaks;i++){
1471         Pos("SCG",i+1,"SCA",0.0,.0,0.0,irot+i);
1472     } // end for i
1473     // For the foam core.
1474     t = ct/(0.5*(Rholemax+Rholemin));// It is not posible to get the
1475     // carbon fiber thickness uniform in this phi direction. We can only
1476     // make it a fixed angular thickness.
1477     t *= 180.0/TMath::Pi();
1478     dphi = 5.0 - 2.0*t; // degrees
1479     phi0 = 12.5+t; // degrees see drawing ALR-0767.
1480     nz = 4;
1481     Double_t *zh    = new Double_t[nz];
1482     Double_t *rminh = new Double_t[nz];
1483     Double_t *rmaxh = new Double_t[nz];
1484     zh[0] = zf[2];
1485     rminh[0] = rming[0];
1486     rmaxh[0] = rmaxg[0];
1487     zh[1] = zf[3];
1488     rminh[1] = rming[1]-(ct/sintc-(zg[1]-zh[1]))*tantc;
1489     rmaxh[1] = rmaxh[0];
1490     zh[2] = zg[2]+ct/tanth;
1491     rminh[2] = rming[2];
1492     rmaxh[2] = rmaxg[2]-(ct/sintc-(zg[2]-zh[2]))*tantc;
1493     zh[3] = zg[3]-ct/sintc;
1494     rminh[3] = rminh[2];
1495     rmaxh[3] = rminh[3];
1496     PolyCone("SCH","SSD spoak foam core",
1497              phi0,dphi,nz,*zc,*rminc,*rmaxc,SSDfo);
1498     Pos("SCH",1,"SCG",0.0,.0,0.0,0);
1499     //
1500     //==================================================================
1501     // Now for the Inner most part of the SSD cone.
1502     phi0 = 0.0;
1503     dphi = 360.0;
1504     nz = 8;
1505     Double_t *zi = new Double_t[nz];
1506     Double_t *rmini = new Double_t[nz];
1507     Double_t *rmaxi = new Double_t[nz];
1508     Double_t za,rmina,rmaxa; // additional point not needed in call to pcons.
1509     zi[0] = zg[2];
1510     rmini[0] = rming[2];
1511     rmaxi[0] = rmini[0];
1512     zi[1] = zg[3];
1513     rmini[1] = -tantc*(zi[1]-za[3])+rmina[3];
1514     rmaxi[1] = rmaxi[0];
1515     rmini[5] = Rinmin;
1516     rmaxi[5] = Rinmax+rc*sintc;
1517     zi[5] =za[4]+(rmaxa[4]-rmaxi[5])/tantc;
1518     zia = zi[5]+rc*costc;
1519     rminia = rmini[5];
1520     rmaxia = Rinmax;
1521     zi[3] = zia-dzin;
1522     zi[2] = zi[3] -rc*costc;
1523     rmini[2] = -tantc*(zi[2]-za[3])+rmina[3];
1524     rmaxi[2] = -tantc*(zi[2]-za[4])+rmaxa[4];
1525     rmini[3] = rmini[2] -rc*costc;
1526     zi[4] = zi[3];
1527     rmini[4] = Rinmin;
1528     rmaxi[4] = -tantc*(zi[4]-za[4])+rmaxa[4];
1529     rmaxi[3] = rmaxi[4];
1530     zi[6] = zcylinder;
1531     rmini[6] = Rinmin;
1532     rmaxi[6] = rmaxi[5] - (zi[5]-zi[6])*(rmaxi[5]-rmaxa)/(zi[5]-zia);
1533     zi[7] = zi[6];
1534     rmini[7] = Rincylinder;
1535     rmaxi[7] = rmaxi[6];
1536     rmini[8] = Rincylinder;
1537     rmaxi[8] = Rini[8];
1538     zi[8] = zi[5]+(rmaxi[8]-rmaxi[5])*(zia-zi[5])/(rmaxa-rmaxi[5]);
1539     PolyCone("SCI","SSD lower/inner right part of SSD cone",
1540              phi0,dphi,nz,*zc,*rminc,*rmaxc,SSDcf);
1541     Pos("SCI",1,mother,0.0,.0,0.0,0);
1542     // Now for Inserto volume at the inner most radius.
1543     phi0 = 0.0;
1544     dphi = 360.0;
1545     nz = 7;
1546     Double_t *zk = new Double_t[nz];
1547     Double_t *rmink = new Double_t[nz];
1548     Double_t *rmaxk = new Double_t[nz];
1549     zk[1] = zi[3]+ct;
1550     zk[0] = zk[1]-(rc+ct)*costc;
1551     rmink[0] = rmini[3]+(rc+ct)*sintc;
1552     rmaxk[0] = rmink[0];
1553     rmink[1] = rmini[3];
1554     zk[2] = zk[1];
1555     rmink[2] = rmini[6];
1556     rmaxk[2] = rmaxk[1];
1557     zk[3] = zk[0]+(th+2.0*ct)*costc;
1558     rmink[3] = rmini[6];
1559     rmaxk[3] = rmaxk[0]+(th+2.0*ct)*sintc;
1560     rmaxk[1] = rmaxk[0]+(rmaxk[3]-rmaxk[0])*(zk[1]-zk[0])/(zk[3]-zk[0]);
1561     rmink[4] = rmini[6];
1562     rmaxk[4] = rmaxi[5]-ct*sintc;
1563     zk[4] = zc[1]+(zc3[3]-zc[1])*(rmaxk[4]-rmaxc[1])/(rmaxc[3]-rmaxc[1]);
1564     zk[5] = zi[5]-rc*costc-ct;
1565     rmink[5] = rmini[6];
1566     rmaxk[5] = rmini[8];
1567     zk[6] = zi[6];
1568     rmink[6] = rmini[6];
1569     rmaxk[6] = rmaxi[6];
1570     PolyCone("SCK","SSD inner most inserto material",
1571              phi0,dphi,nz,*zc,*rminc,*rmaxc,SSDfs);
1572     Pos("SCK",1,"SCI",0.0,.0,0.0,0);
1573     // Now for foam core at the inner most radius.
1574     phi0 = 0.0;
1575     dphi = 360.0;
1576     nz = 4;
1577     Double_t *zj = new Double_t[nz];
1578     Double_t *rminj = new Double_t[nz];
1579     Double_t *rmaxj = new Double_t[nz];
1580     rminj[0] = rmini[0]-ct;
1581     zj[0] = zc[0]+(zc[2]-zc[0])*(rminj[0]-rminc[0])/(rminc[2]-rminc[0]);
1582     rmaxj[0] = rminj[0];
1583     rmaxj[1] = rmaxj[0];
1584     zj[1] = zc[1]+(zc[3]-zc[1])*(rmaxj[1]-rmaxc[1])/(rmaxc[3]-rmaxc[1]);
1585     rminj[1] = rminc[0]+(rminc[2]-rminc[0])*(zj[1]-zc[0])/(zc[2]-zc[0]);
1586     zj[2] = zk[0];
1587     rminj[2] = rkmin[0];
1588     rmaxj[2] = rmaxc[1]+(rmaxc[3]-rmaxc[1])*(zj[2]-zc[1])/(zc[3]-zc[1]);
1589     zj[3] = zk[3];
1590     rminj[3] = rmaxk[3];
1591     rmaxj[3] = rminj[3];
1592     PolyCone("SCJ","SSD inner most foam core",
1593              phi0,dphi,nz,*zc,*rminc,*rmaxc,SSDfo);
1594     Pos("SCJ",1,"SCI",0.0,.0,0.0,0);
1595     // Now for foam core at the top of the inner most radius where 
1596     // the spoaks are.
1597     t = ct/(0.5*(Rholemax+Rholemin));// It is not posible to get the
1598     // carbon fiber thickness uniform in this phi direction. We can only
1599     // make it a fixed angular thickness.
1600     t *= 180.0/TMath::Pi();
1601     dphi = 5.0 - 2.0*t; // degrees
1602     phi0 = 12.5+t; // degrees see drawing ALR-0767.
1603     nz = 4;
1604     Double_t *zl = new Double_t[nz];
1605     Double_t *rminl = new Double_t[nz];
1606     Double_t *rmaxl = new Double_t[nz];
1607     zl[0] = zh[2];
1608     rminl[0] = rmini[0];
1609     rmaxl[0] = rminl[0];
1610     zl[1] = zj[0];
1611     rminl[1] = rminj[1];
1612     rmaxl[1] = rmaxi[0];
1613     zl[2] = zh[3];
1614     rminl[2] = rminl[1];
1615     rmaxl[2] = rmaxl[1];
1616     zl[3] = zj[1];
1617     rminl[3] = rminl[2];
1618     rmaxl[3] = rminl[3];
1619     PolyCone("SCL","SSD inner most foam core",
1620              phi0,dphi,nz,*zc,*rminc,*rmaxc,SSDfo);
1621     Pos("SCL",1,"SCI",0.0,.0,0.0,0);
1622     for(i=1;i<nspoaks;i++){
1623         Pos("SCG",i+1,"SCA",0.0,.0,0.0,irot+i);
1624     } // end for i
1625     // Now for the SSD mounting posts
1626     dphi = 180.0*dRPost/(RPostmin+0.5*dRPost)/TMath::Pi(); // degrees
1627     phi0 = phi0post; //
1628     nz = 3;
1629     Double_t *zo = new Double_t[nz];
1630     Double_t *rmino = new Double_t[nz];
1631     Double_t *rmaxo = new Double_t[nz];
1632     rmino[0] = RPostmin+dRPost;
1633     rmaxo[0] = rmino[0];
1634     zo[0] = za[4]+(rmaxa[4]-Rmaxo[0])/tantc;
1635     rmino[1] = RPostmin;
1636     zo[1] = za[4]+(rmaxa[4]-Rmino[1])/tantc;
1637     rmaxo[1] = rmaxo[0];
1638     zo[2] = z0+zpostmax;
1639     rmino[2] = RPostmin;
1640     rmaxo[2] = rmin0[2]+dRPost;
1641     PolyCone("SCO","SSD mounting post, carbon fiber",
1642              phi0,dphi,nz,*zc,*rminc,*rmaxc,SSDcf);
1643     Pos("SCO",1,mother,0.0,.0,0.0,0);
1644     for(i=1;i<nposts;i++){
1645         Zmatrix(irot+i,360./((Double_t)nposts));
1646         Pos("SCO",i+1,mother,0.0,.0,0.0,irot+i);
1647     } // end for i
1648     // Now for the SSD mounting posts
1649     t = 180.0*ct/(RPostmin+0.5*dRPost)/TMath::Pi();
1650     dphi = dphi-2.0*t; // degrees
1651     phi0 = phi0+t; //
1652     nz = 3;
1653     Double_t *zp = new Double_t[nz];
1654     Double_t *rminp = new Double_t[nz];
1655     Double_t *rmaxp = new Double_t[nz];
1656     rminp[0] = rmino[0]-ct;
1657     rmaxp[0] = rminp[0];
1658     zp[0] = za[4]+(rmaxa[4]-Rmaxp[0])/tantc;
1659     rminp[1] = rmino[0]+ct;
1660     rmaxp[1] = rmino[0]-ct;
1661     zp[1] = za[4]+(rmaxa[4]-Rminp[1])/tantc;
1662     rminp[2] = rminp[1];
1663     rmaxp[2] = rmaxp[1];
1664     zp[2] = z0-zpostmax;
1665     PolyCone("SCP","SSD mounting post, Inserto",
1666              phi0,dphi,nz,*zc,*rminc,*rmaxc,SSDfs);
1667     Pos("SCP",1,"SCO",0.0,.0,0.0,0);
1668     // This insrto continues into the SSD cone displacing the foam
1669     // and the carbon fiber surface at those points where the posts are.
1670     nz = 4;
1671     Double_t *zm = new Double_t[nz];
1672     Double_t *rminm = new Double_t[nz];
1673     Double_t *rmaxm = new Double_t[nz];
1674     Double_t *zn = new Double_t[nz];
1675     Double_t *rminn = new Double_t[nz];
1676     Double_t *rmaxn = new Double_t[nz];
1677     rminm[0] = RPostmin+dRPost-ct;
1678     rmaxm[0] = rminm[0];
1679     zm[0] = zj[0]+(zj[2]-zj[0])*(rminm[0]-rminj[0])/(rminj[2]-rminj[0]);
1680     rmaxm[1] = rmaxm[0];
1681     zm[1] = zj[1]+(zj[3]-zj[1])*(rmaxm[1]-rmaxj[1])/(rmaxj[3]-rmaxj[1]);
1682     rminm[2] = RPostmin+ct;
1683     zm[2] = zj[0]+(zj[2]-zj[0])*(rminm[2]-rminj[0])/(rminj[2]-rminm[0]);
1684     rmaxm[2] = rjmax[1]+(rjmax[3]-rmnax[1])*(zm[2]-zj[1])/(zj[3]-zj[1]);
1685     rminm[3] = rminm[2];
1686     rmaxm[3] = rminm[3];
1687     zn[0] = zm[1];
1688     rminn[0] = rmaxm[1];
1689     rmaxn[0] = rminn[0];
1690     rmaxn[1] = rmaxn[0];
1691     zn[1] = za4+(rmaxa[4]-rmaxn[1])/tantc;
1692     rminn[1] = rmaxj[1]+(rmaxj[3]-rmaxj[1])*(zn[1]-zj[1])/(zj[3]-zj[1]);
1693     zn[2] = zm[3];
1694     rminn[2] = rminm[3];
1695     rmaxn[2] = -tantc*(zn[2]-za[4])+rmaxa[4];
1696     rminn[3] = rminn[2];
1697     rmaxn[3] = rminn[3];
1698     zn]3] = za[4]+(rmaxa[4]-rmaxn[3])/tantc;
1699     Pos("SCM",1,"SCJ",0.0,.0,0.0,0);
1700     Pos("SCN",1,"SCI",0.0,.0,0.0,0);
1701     for(i=1;i<nposts;i++){
1702         Pos("SCN",i+1,"SCJ",0.0,.0,0.0,irot+i);
1703         Pos("SCM",i+1,"SCI",0.0,.0,0.0,irot+i);
1704     } // end for i
1705     //
1706     //==============================================================
1707     delete[] za;delete[] rmina;delete[] rmaxa;
1708     delete[] zb;delete[] rminb;delete[] rmaxb;
1709     delete[] zc;delete[] rminc;delete[] rmaxc;
1710     delete[] zd;delete[] rmind;delete[] rmaxd;
1711     delete[] ze;delete[] rmine;delete[] rmaxe;
1712     delete[] zf;delete[] rminf;delete[] rmaxf;
1713     delete[] zg;delete[] rming;delete[] rmaxg;
1714     delete[] zh;delete[] rminh;delete[] rmaxh;
1715     delete[] zi;delete[] rmini;delete[] rmaxi;
1716     delete[] zj;delete[] rminj;delete[] rmaxj;
1717     // Set back to cm default scale before exiting.
1718     SetScalecm();
1719     return;
1720 }
1721 //______________________________________________________________________
1722 void AliITSv11::CreateGeometry(){
1723     ////////////////////////////////////////////////////////////////////////
1724     // This routine defines and Creates the geometry for version 11 of the ITS.
1725     ////////////////////////////////////////////////////////////////////////
1726 }
1727 //______________________________________________________________________
1728 void AliITSv11::CreateMaterials(){
1729 ////////////////////////////////////////////////////////////////////////
1730   //
1731   // Create ITS materials
1732   //     This function defines the default materials used in the Geant
1733   // Monte Carlo simulations for the geometries AliITSv1, AliITSv3,
1734   // AliITSv11.
1735   // In general it is automatically replaced by
1736   // the CreatMaterials routine defined in AliITSv?. Should the function
1737   // CreateMaterials not exist for the geometry version you are using this
1738   // one is used. See the definition found in AliITSv5 or the other routine
1739   // for a complete definition.
1740   //
1741 }
1742 //______________________________________________________________________
1743 void AliITSv11::InitAliITSgeom(){
1744     //     Based on the geometry tree defined in Geant 3.21, this
1745     // routine initilizes the Class AliITSgeom from the Geant 3.21 ITS geometry
1746     // sturture.
1747 }
1748
1749 //______________________________________________________________________
1750 void AliITSv11::Init(){
1751     ////////////////////////////////////////////////////////////////////////
1752     //     Initialise the ITS after it has been created.
1753     ////////////////////////////////////////////////////////////////////////
1754 }
1755 //______________________________________________________________________
1756 void AliITSv11::SetDefaults(){
1757     // sets the default segmentation, response, digit and raw cluster classes
1758 }
1759 //______________________________________________________________________
1760 void AliITSv11::DrawModule(){
1761     ////////////////////////////////////////////////////////////////////////
1762     //     Draw a shaded view of the FMD version 11.
1763     ////////////////////////////////////////////////////////////////////////
1764 }
1765 //______________________________________________________________________
1766 void AliITSv11::StepManager(){
1767     ////////////////////////////////////////////////////////////////////////
1768     //    Called for every step in the ITS, then calles the AliITShit class
1769     // creator with the information to be recoreded about that hit.
1770     //     The value of the macro ALIITSPRINTGEOM if set to 1 will allow the
1771     // printing of information to a file which can be used to create a .det
1772     // file read in by the routine CreateGeometry(). If set to 0 or any other
1773     // value except 1, the default behavior, then no such file is created nor
1774     // it the extra variables and the like used in the printing allocated.
1775     ////////////////////////////////////////////////////////////////////////
1776 }
1777