c3e725a5660c099aa714523e94298a630d5b0481
[u/mrichter/AliRoot.git] / TGeant3 / TGeant3.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.41  2000/12/18 11:33:50  alibrary
19 New call frequence histograms per module and volume
20
21 Revision 1.40  2000/12/06 10:06:58  morsch
22 Add all D and B baryons produced by HIJING to PDG DataBase.
23
24 Revision 1.39  2000/11/30 07:12:54  alibrary
25 Introducing new Rndm and QA classes
26
27 Revision 1.38  2000/10/30 15:19:06  morsch
28 Xi(b) (pdg code 5232) added to Pdg data base.
29
30 Revision 1.37  2000/10/02 21:28:16  fca
31 Removal of useless dependecies via forward declarations
32
33 Revision 1.36  2000/09/14 07:08:41  fca
34 Introducing glvolu in the interface
35
36 Revision 1.35  2000/09/12 14:27:10  morsch
37 No instance of AliDecayer created to initialize fDecayer.
38
39 Revision 1.34  2000/09/07 12:12:01  morsch
40 Comment inside comment removed.
41
42 Revision 1.33  2000/09/06 16:03:42  morsch
43 Set ExternalDecayer, Decayer  and SetForceDecay methods added.
44 Gspart calls for charmed and bottom hadrons added.
45 Decay mode definitions for charmed and beauty hadrons have been taken out.
46 They will be  handled by an external decayer.
47
48 Revision 1.32  2000/08/24 16:28:53  hristov
49 TGeant3::IsNewTrack corrected by F.Carminati
50
51 Revision 1.31  2000/07/13 16:19:10  fca
52 Mainly coding conventions + some small bug fixes
53
54 Revision 1.30  2000/07/12 08:56:30  fca
55 Coding convention correction and warning removal
56
57 Revision 1.29  2000/07/11 18:24:59  fca
58 Coding convention corrections + few minor bug fixes
59
60 Revision 1.28  2000/06/29 10:51:55  morsch
61 Add some charmed and bottom baryons to the particle list (TDatabasePDG). This
62 is needed by Hijing. Should be part of a future review of TDatabasePDG.
63
64 Revision 1.27  2000/06/21 17:40:15  fca
65 Adding possibility to set ISTRA, PAI model
66
67 Revision 1.26  2000/05/16 13:10:41  fca
68 New method IsNewTrack and fix for a problem in Father-Daughter relations
69
70 Revision 1.25  2000/04/07 11:12:35  fca
71 G4 compatibility changes
72
73 Revision 1.24  2000/02/28 21:03:57  fca
74 Some additions to improve the compatibility with G4
75
76 Revision 1.23  2000/02/23 16:25:25  fca
77 AliVMC and AliGeant3 classes introduced
78 ReadEuclid moved from AliRun to AliModule
79
80 Revision 1.22  2000/01/18 15:40:13  morsch
81 Interface to GEANT3 routines GFTMAT, GBRELM and GPRELM added
82 Define geant particle type 51: Feedback Photon with Cherenkov photon properties.
83
84 Revision 1.21  2000/01/17 19:41:17  fca
85 Add SetERAN function
86
87 Revision 1.20  2000/01/12 11:29:27  fca
88 Close material file
89
90 Revision 1.19  1999/12/17 09:03:12  fca
91 Introduce a names array
92
93 Revision 1.18  1999/11/26 16:55:39  fca
94 Reimplement CurrentVolName() to avoid memory leaks
95
96 Revision 1.17  1999/11/03 16:58:28  fca
97 Correct source of address violation in creating character string
98
99 Revision 1.16  1999/11/03 13:17:08  fca
100 Have ProdProcess return const char*
101
102 Revision 1.15  1999/10/26 06:04:50  fca
103 Introduce TLorentzVector in AliMC::GetSecondary. Thanks to I.Hrivnacova
104
105 Revision 1.14  1999/09/29 09:24:30  fca
106 Introduction of the Copyright and cvs Log
107
108 */
109
110 ///////////////////////////////////////////////////////////////////////////////
111 //                                                                           //
112 //  Interface Class to the Geant3.21 MonteCarlo                              //
113 //                                                                           //
114 //Begin_Html
115 /*
116 <img src="picts/TGeant3Class.gif">
117 */
118 //End_Html
119 //                                                                           //
120 //                                                                           //
121 ///////////////////////////////////////////////////////////////////////////////
122
123 #include "dlfcn.h"
124 #include "ctype.h" 
125
126 #include "TROOT.h" 
127 #include "TDatabasePDG.h"
128 #include "TLorentzVector.h"
129
130 #include "THIGZ.h" 
131 #include "TGeant3.h" 
132
133 #include "AliCallf77.h" 
134 #include "AliDecayer.h" 
135
136 #ifndef WIN32 
137 # define gzebra  gzebra_ 
138 # define grfile  grfile_ 
139 # define gpcxyz  gpcxyz_ 
140 # define ggclos  ggclos_ 
141 # define glast   glast_ 
142 # define ginit   ginit_ 
143 # define gcinit  gcinit_ 
144 # define grun    grun_ 
145 # define gtrig   gtrig_ 
146 # define gtrigc  gtrigc_ 
147 # define gtrigi  gtrigi_ 
148 # define gwork   gwork_ 
149 # define gzinit  gzinit_ 
150 # define gfmate  gfmate_ 
151 # define gfpart  gfpart_ 
152 # define gftmed  gftmed_ 
153 # define gftmat  gftmat_ 
154 # define gmate   gmate_ 
155 # define gpart   gpart_ 
156 # define gsdk    gsdk_ 
157 # define gsmate  gsmate_ 
158 # define gsmixt  gsmixt_ 
159 # define gspart  gspart_ 
160 # define gstmed  gstmed_ 
161 # define gsckov  gsckov_
162 # define gstpar  gstpar_ 
163 # define gfkine  gfkine_ 
164 # define gfvert  gfvert_ 
165 # define gskine  gskine_ 
166 # define gsvert  gsvert_ 
167 # define gphysi  gphysi_ 
168 # define gdebug  gdebug_ 
169 # define gekbin  gekbin_ 
170 # define gfinds  gfinds_ 
171 # define gsking  gsking_ 
172 # define gskpho  gskpho_ 
173 # define gsstak  gsstak_ 
174 # define gsxyz   gsxyz_ 
175 # define gtrack  gtrack_ 
176 # define gtreve  gtreve_ 
177 # define gtreveroot  gtreveroot_ 
178 # define grndm   grndm_ 
179 # define grndmq  grndmq_ 
180 # define gdtom   gdtom_ 
181 # define glmoth  glmoth_ 
182 # define gmedia  gmedia_ 
183 # define gmtod   gmtod_ 
184 # define gsdvn   gsdvn_ 
185 # define gsdvn2  gsdvn2_ 
186 # define gsdvs   gsdvs_ 
187 # define gsdvs2  gsdvs2_ 
188 # define gsdvt   gsdvt_ 
189 # define gsdvt2  gsdvt2_
190 # define gsord   gsord_ 
191 # define gspos   gspos_ 
192 # define gsposp  gsposp_ 
193 # define gsrotm  gsrotm_ 
194 # define gprotm  gprotm_ 
195 # define gsvolu  gsvolu_ 
196 # define gprint  gprint_ 
197 # define gdinit  gdinit_ 
198 # define gdopt   gdopt_ 
199 # define gdraw   gdraw_ 
200 # define gdrayt  gdrayt_
201 # define gdrawc  gdrawc_ 
202 # define gdrawx  gdrawx_ 
203 # define gdhead  gdhead_ 
204 # define gdwmn1  gdwmn1_ 
205 # define gdwmn2  gdwmn2_ 
206 # define gdwmn3  gdwmn3_ 
207 # define gdxyz   gdxyz_ 
208 # define gdcxyz  gdcxyz_ 
209 # define gdman   gdman_ 
210 # define gdspec  gdspec_ 
211 # define gdtree  gdtree_ 
212 # define gdelet  gdelet_ 
213 # define gdclos  gdclos_ 
214 # define gdshow  gdshow_ 
215 # define gdopen  gdopen_ 
216 # define dzshow  dzshow_ 
217 # define gsatt   gsatt_ 
218 # define gfpara  gfpara_
219 # define gckpar  gckpar_
220 # define gckmat  gckmat_
221 # define glvolu  glvolu_
222 # define geditv  geditv_
223 # define mzdrop  mzdrop_
224
225 # define ertrak  ertrak_
226 # define ertrgo  ertrgo_
227  
228 # define setbomb setbomb_
229 # define setclip setclip_
230
231 # define gbrelm gbrelm_
232 # define gprelm gprelm_
233 #else 
234 # define gzebra  GZEBRA 
235 # define grfile  GRFILE 
236 # define gpcxyz  GPCXYZ 
237 # define ggclos  GGCLOS 
238 # define glast   GLAST 
239 # define ginit   GINIT 
240 # define gcinit  GCINIT 
241 # define grun    GRUN 
242 # define gtrig   GTRIG 
243 # define gtrigc  GTRIGC 
244 # define gtrigi  GTRIGI 
245 # define gwork   GWORK 
246 # define gzinit  GZINIT 
247 # define gfmate  GFMATE 
248 # define gfpart  GFPART 
249 # define gftmed  GFTMED 
250 # define gftmat  GFTMAT
251 # define gmate   GMATE 
252 # define gpart   GPART 
253 # define gsdk    GSDK 
254 # define gsmate  GSMATE 
255 # define gsmixt  GSMIXT 
256 # define gspart  GSPART 
257 # define gstmed  GSTMED 
258 # define gsckov  GSCKOV
259 # define gstpar  GSTPAR 
260 # define gfkine  GFKINE 
261 # define gfvert  GFVERT 
262 # define gskine  GSKINE 
263 # define gsvert  GSVERT 
264 # define gphysi  GPHYSI 
265 # define gdebug  GDEBUG 
266 # define gekbin  GEKBIN 
267 # define gfinds  GFINDS 
268 # define gsking  GSKING 
269 # define gskpho  GSKPHO 
270 # define gsstak  GSSTAK 
271 # define gsxyz   GSXYZ 
272 # define gtrack  GTRACK 
273 # define gtreve  GTREVE 
274 # define gtreveroot  GTREVEROOT
275 # define grndm   GRNDM
276 # define grndmq  GRNDMQ
277 # define gdtom   GDTOM 
278 # define glmoth  GLMOTH 
279 # define gmedia  GMEDIA 
280 # define gmtod   GMTOD 
281 # define gsdvn   GSDVN 
282 # define gsdvn2  GSDVN2 
283 # define gsdvs   GSDVS 
284 # define gsdvs2  GSDVS2 
285 # define gsdvt   GSDVT 
286 # define gsdvt2  GSDVT2
287 # define gsord   GSORD 
288 # define gspos   GSPOS 
289 # define gsposp  GSPOSP 
290 # define gsrotm  GSROTM 
291 # define gprotm  GPROTM 
292 # define gsvolu  GSVOLU 
293 # define gprint  GPRINT 
294 # define gdinit  GDINIT
295 # define gdopt   GDOPT 
296 # define gdraw   GDRAW
297 # define gdrayt  GDRAYT
298 # define gdrawc  GDRAWC
299 # define gdrawx  GDRAWX 
300 # define gdhead  GDHEAD
301 # define gdwmn1  GDWMN1
302 # define gdwmn2  GDWMN2
303 # define gdwmn3  GDWMN3
304 # define gdxyz   GDXYZ
305 # define gdcxyz  GDCXYZ
306 # define gdman   GDMAN
307 # define gdfspc  GDFSPC
308 # define gdspec  GDSPEC
309 # define gdtree  GDTREE
310 # define gdelet  GDELET
311 # define gdclos  GDCLOS
312 # define gdshow  GDSHOW
313 # define gdopen  GDOPEN
314 # define dzshow  DZSHOW 
315 # define gsatt   GSATT 
316 # define gfpara  GFPARA
317 # define gckpar  GCKPAR
318 # define gckmat  GCKMAT
319 # define glvolu  GLVOLU
320 # define geditv  GEDITV
321 # define mzdrop  MZDROP 
322
323 # define ertrak  ERTRAK
324 # define ertrgo  ERTRGO
325  
326 # define setbomb SETBOMB
327 # define setclip SETCLIP
328  
329 # define gbrelm GBRELM
330 # define gprelm GPRELM
331
332 #endif 
333
334 //____________________________________________________________________________ 
335 extern "C" 
336 {
337   //
338   // Prototypes for GEANT functions
339   //
340   void type_of_call gzebra(const int&); 
341
342   void type_of_call gpcxyz(); 
343
344   void type_of_call ggclos(); 
345
346   void type_of_call glast(); 
347
348   void type_of_call ginit(); 
349
350   void type_of_call gcinit(); 
351
352   void type_of_call grun(); 
353
354   void type_of_call gtrig(); 
355
356   void type_of_call gtrigc(); 
357
358   void type_of_call gtrigi(); 
359
360   void type_of_call gwork(const int&); 
361
362   void type_of_call gzinit(); 
363
364   void type_of_call gmate(); 
365
366   void type_of_call gpart(); 
367
368   void type_of_call gsdk(Int_t &, Float_t *, Int_t *); 
369
370   void type_of_call gfkine(Int_t &, Float_t *, Float_t *, Int_t &,
371                            Int_t &, Float_t *, Int_t &); 
372
373   void type_of_call gfvert(Int_t &, Float_t *, Int_t &, Int_t &, 
374                            Float_t &, Float_t *, Int_t &); 
375
376   void type_of_call gskine(Float_t *,Int_t &, Int_t &, Float_t *,
377                            Int_t &, Int_t &); 
378
379   void type_of_call gsvert(Float_t *,Int_t &, Int_t &, Float_t *,
380                            Int_t &, Int_t &); 
381
382   void type_of_call gphysi(); 
383
384   void type_of_call gdebug(); 
385
386   void type_of_call gekbin(); 
387
388   void type_of_call gfinds(); 
389
390   void type_of_call gsking(Int_t &); 
391
392   void type_of_call gskpho(Int_t &); 
393
394   void type_of_call gsstak(Int_t &); 
395
396   void type_of_call gsxyz(); 
397
398   void type_of_call gtrack(); 
399
400   void type_of_call gtreve(); 
401
402   void type_of_call gtreveroot(); 
403
404   void type_of_call grndm(Float_t *r, const Int_t &n)
405   {gMC->Rndm(r,n);}
406
407   void type_of_call grndmq(Int_t &, Int_t &, const Int_t &,
408                            DEFCHARD DEFCHARL)
409   {/*printf("Dummy grndmq called\n");*/}
410
411   void type_of_call gdtom(Float_t *, Float_t *, Int_t &); 
412
413   void type_of_call glmoth(DEFCHARD, Int_t &, Int_t &, Int_t *,
414                            Int_t *, Int_t * DEFCHARL); 
415
416   void type_of_call gmedia(Float_t *, Int_t &); 
417
418   void type_of_call gmtod(Float_t *, Float_t *, Int_t &); 
419
420   void type_of_call gsrotm(const Int_t &, const Float_t &, const Float_t &,
421                            const Float_t &, const Float_t &, const Float_t &,
422                            const Float_t &); 
423
424   void type_of_call gprotm(const Int_t &); 
425
426   void type_of_call grfile(const Int_t&, DEFCHARD, 
427                            DEFCHARD DEFCHARL DEFCHARL); 
428
429   void type_of_call gfmate(const Int_t&, DEFCHARD, Float_t &, Float_t &,
430                            Float_t &, Float_t &, Float_t &, Float_t *,
431                            Int_t& DEFCHARL); 
432
433   void type_of_call gfpart(const Int_t&, DEFCHARD, Int_t &, Float_t &,
434                            Float_t &, Float_t &, Float_t *, Int_t & DEFCHARL); 
435
436   void type_of_call gftmed(const Int_t&, DEFCHARD, Int_t &, Int_t &, Int_t &,
437                            Float_t &, Float_t &, Float_t &, Float_t &,
438                            Float_t &, Float_t &, Float_t *, Int_t * DEFCHARL); 
439
440   void type_of_call gftmat(const Int_t&, const Int_t&, DEFCHARD, const Int_t&,
441                            Float_t*, Float_t*
442                            ,Float_t *, Int_t & DEFCHARL);
443
444   void type_of_call gsmate(const Int_t&, DEFCHARD, Float_t &, Float_t &,
445                            Float_t &, Float_t &, Float_t &, Float_t *,
446                            Int_t & DEFCHARL); 
447
448   void type_of_call gsmixt(const Int_t&, DEFCHARD, Float_t *, Float_t *,
449                            Float_t &, Int_t &, Float_t * DEFCHARL); 
450
451   void type_of_call gspart(const Int_t&, DEFCHARD, Int_t &, Float_t &,
452                            Float_t &, Float_t &, Float_t *, Int_t & DEFCHARL); 
453
454
455   void type_of_call gstmed(const Int_t&, DEFCHARD, Int_t &, Int_t &, Int_t &,
456                            Float_t &, Float_t &, Float_t &, Float_t &,
457                            Float_t &, Float_t &, Float_t *, Int_t & DEFCHARL); 
458
459   void type_of_call gsckov(Int_t &itmed, Int_t &npckov, Float_t *ppckov,
460                            Float_t *absco, Float_t *effic, Float_t *rindex);
461   void type_of_call gstpar(const Int_t&, DEFCHARD, Float_t & DEFCHARL); 
462
463   void type_of_call gsdvn(DEFCHARD,DEFCHARD, Int_t &, Int_t &
464                           DEFCHARL DEFCHARL); 
465
466   void type_of_call gsdvn2(DEFCHARD,DEFCHARD, Int_t &, Int_t &, Float_t &,
467                            Int_t & DEFCHARL DEFCHARL); 
468
469   void type_of_call gsdvs(DEFCHARD,DEFCHARD, Float_t &, Int_t &, Int_t &
470                           DEFCHARL DEFCHARL); 
471
472   void type_of_call gsdvs2(DEFCHARD,DEFCHARD, Float_t &, Int_t &, Float_t &,
473                            Int_t & DEFCHARL DEFCHARL); 
474
475   void type_of_call gsdvt(DEFCHARD,DEFCHARD, Float_t &, Int_t &, Int_t &,
476                           Int_t & DEFCHARL DEFCHARL); 
477
478   void type_of_call gsdvt2(DEFCHARD,DEFCHARD, Float_t &, Int_t &, Float_t&,
479                            Int_t &, Int_t & DEFCHARL DEFCHARL); 
480
481   void type_of_call gsord(DEFCHARD, Int_t & DEFCHARL); 
482
483   void type_of_call gspos(DEFCHARD, Int_t &, DEFCHARD, Float_t &, Float_t &,
484                           Float_t &, Int_t &, DEFCHARD DEFCHARL DEFCHARL
485                           DEFCHARL); 
486
487   void type_of_call gsposp(DEFCHARD, Int_t &, DEFCHARD, Float_t &, Float_t &,
488                            Float_t &, Int_t &, DEFCHARD,  
489                            Float_t *, Int_t & DEFCHARL DEFCHARL DEFCHARL); 
490
491   void type_of_call gsvolu(DEFCHARD, DEFCHARD, Int_t &, Float_t *, Int_t &,
492                            Int_t & DEFCHARL DEFCHARL); 
493
494   void type_of_call gsatt(DEFCHARD, DEFCHARD, Int_t & DEFCHARL DEFCHARL); 
495
496   void type_of_call gfpara(DEFCHARD , Int_t&, Int_t&, Int_t&, Int_t&, Float_t*,
497                            Float_t* DEFCHARL);
498
499   void type_of_call gckpar(Int_t&, Int_t&, Float_t*);
500
501   void type_of_call gckmat(Int_t&, DEFCHARD DEFCHARL);
502
503   void type_of_call glvolu(Int_t&, Int_t*, Int_t*, Int_t&);
504
505   void type_of_call gprint(DEFCHARD,const int& DEFCHARL); 
506
507   void type_of_call gdinit(); 
508
509   void type_of_call gdopt(DEFCHARD,DEFCHARD DEFCHARL DEFCHARL); 
510   
511   void type_of_call gdraw(DEFCHARD,Float_t &,Float_t &, Float_t &,Float_t &,
512                           Float_t &, Float_t &, Float_t & DEFCHARL); 
513   void type_of_call gdrayt(DEFCHARD,Float_t &,Float_t &, Float_t &,Float_t &,
514                            Float_t &, Float_t &, Float_t & DEFCHARL); 
515   void type_of_call gdrawc(DEFCHARD,Int_t &, Float_t &, Float_t &, Float_t &,
516                           Float_t &, Float_t & DEFCHARL); 
517   void type_of_call gdrawx(DEFCHARD,Float_t &, Float_t &, Float_t &, Float_t &,
518                            Float_t &, Float_t &, Float_t &, Float_t &,
519                            Float_t & DEFCHARL); 
520   void type_of_call gdhead(Int_t &,DEFCHARD, Float_t & DEFCHARL);
521   void type_of_call gdxyz(Int_t &);
522   void type_of_call gdcxyz();
523   void type_of_call gdman(Float_t &, Float_t &);
524   void type_of_call gdwmn1(Float_t &, Float_t &);
525   void type_of_call gdwmn2(Float_t &, Float_t &);
526   void type_of_call gdwmn3(Float_t &, Float_t &);
527   void type_of_call gdspec(DEFCHARD DEFCHARL);
528   void type_of_call gdfspc(DEFCHARD, Int_t &, Int_t & DEFCHARL) {;}
529   void type_of_call gdtree(DEFCHARD, Int_t &, Int_t & DEFCHARL);
530
531   void type_of_call gdopen(Int_t &);
532   void type_of_call gdclos();
533   void type_of_call gdelet(Int_t &);
534   void type_of_call gdshow(Int_t &);
535   void type_of_call geditv(Int_t &) {;}
536
537
538   void type_of_call dzshow(DEFCHARD,const int&,const int&,DEFCHARD,const int&,
539                            const int&, const int&, const int& DEFCHARL
540                            DEFCHARL); 
541
542   void type_of_call mzdrop(Int_t&, Int_t&, DEFCHARD DEFCHARL);
543
544   void type_of_call setbomb(Float_t &);
545   void type_of_call setclip(DEFCHARD, Float_t &,Float_t &,Float_t &,Float_t &,
546                             Float_t &, Float_t & DEFCHARL); 
547
548   void type_of_call ertrak(const Float_t *const x1, const Float_t *const p1,
549                            const Float_t *x2, const Float_t *p2,
550                            const Int_t &ipa, DEFCHARD DEFCHARL);
551
552   void type_of_call ertrgo();
553   
554     float type_of_call gbrelm(const Float_t &z, const Float_t& t, const Float_t& cut);
555     float type_of_call gprelm(const Float_t &z, const Float_t& t, const Float_t& cut);
556 }
557
558 //
559 // Geant3 global pointer
560 //
561 static const Int_t kDefSize = 600;
562
563 ClassImp(TGeant3) 
564  
565 //____________________________________________________________________________ 
566 TGeant3::TGeant3()
567
568   //
569   // Default constructor
570   //
571
572  
573 //____________________________________________________________________________ 
574 TGeant3::TGeant3(const char *title, Int_t nwgeant) 
575        :AliMC("TGeant3",title) 
576 {
577   //
578   // Standard constructor for TGeant3 with ZEBRA initialisation
579   // 
580    
581   if(nwgeant) {
582     gzebra(nwgeant); 
583     ginit(); 
584     gzinit();
585   } else {
586     gcinit();
587   }
588   //
589   // Load Address of Geant3 commons    
590   LoadAddress(); 
591   //
592   // Zero number of particles
593   fNPDGCodes=0;
594   fDecayer=0;
595
596
597 //____________________________________________________________________________ 
598 Int_t TGeant3::CurrentMaterial(Float_t &a, Float_t &z, Float_t &dens,
599                                Float_t &radl, Float_t &absl) const
600 {
601   //
602   // Return the parameters of the current material during transport
603   //
604   z     = fGcmate->z;
605   a     = fGcmate->a;
606   dens  = fGcmate->dens;
607   radl  = fGcmate->radl;
608   absl  = fGcmate->absl;
609   return 1;  //this could be the number of elements in mixture
610 }
611    
612 //____________________________________________________________________________ 
613 void TGeant3::DefaultRange()
614
615   //
616   // Set range of current drawing pad to 20x20 cm
617   //
618   if (!gHigz) {
619     new THIGZ(kDefSize); 
620     gdinit();
621   }
622   gHigz->Range(0,0,20,20);
623 }
624
625 //____________________________________________________________________________ 
626 void TGeant3::InitHIGZ() 
627
628   //
629   // Initialise HIGZ
630   //
631   if (!gHigz) {
632     new THIGZ(kDefSize); 
633     gdinit();
634   }
635 }
636  
637 //____________________________________________________________________________ 
638 void TGeant3::LoadAddress() 
639
640   //
641   // Assigns the address of the GEANT common blocks to the structures
642   // that allow their access from C++
643   //
644   void *handle = dlopen (NULL, RTLD_LAZY);
645
646 #ifndef WIN32
647   fQuest  = (Quest_t *)  dlsym(handle,"quest_");
648   fGcbank = (Gcbank_t *) dlsym(handle,"gcbank_");
649   fGclink = (Gclink_t *) dlsym(handle,"gclink_");
650   fGccuts = (Gccuts_t *) dlsym(handle,"gccuts_");
651   fGcmulo = (Gcmulo_t *) dlsym(handle,"gcmulo_");
652   fGcflag = (Gcflag_t *) dlsym(handle,"gcflag_");
653   fGckine = (Gckine_t *) dlsym(handle,"gckine_");
654   fGcking = (Gcking_t *) dlsym(handle,"gcking_");
655   fGckin2 = (Gckin2_t *) dlsym(handle,"gckin2_");
656   fGckin3 = (Gckin3_t *) dlsym(handle,"gckin3_");
657   fGcmate = (Gcmate_t *) dlsym(handle,"gcmate_");
658   fGctmed = (Gctmed_t *) dlsym(handle,"gctmed_");
659   fGctrak = (Gctrak_t *) dlsym(handle,"gctrak_");
660   fGctpol = (Gctpol_t *) dlsym(handle,"gctpol_");
661   fGcvolu = (Gcvolu_t *) dlsym(handle,"gcvolu_");
662   fGcnum  = (Gcnum_t *)  dlsym(handle,"gcnum_");
663   fGcsets = (Gcsets_t *) dlsym(handle,"gcsets_");
664   fGcphys = (Gcphys_t *) dlsym(handle,"gcphys_");
665   fGcphlt = (Gcphlt_t *) dlsym(handle,"gcphlt_");
666   fGcopti = (Gcopti_t *) dlsym(handle,"gcopti_");
667   fGctlit = (Gctlit_t *) dlsym(handle,"gctlit_");
668   fGcvdma = (Gcvdma_t *) dlsym(handle,"gcvdma_");
669   
670   // Commons for GEANE
671   fErtrio = (Ertrio_t *) dlsym(handle,"ertrio_");
672   fEropts = (Eropts_t *) dlsym(handle,"eropts_");
673   fEroptc = (Eroptc_t *) dlsym(handle,"eroptc_");
674   fErwork = (Erwork_t *) dlsym(handle,"erwork_");
675 #else  
676   fQuest  = (Quest_t *)  dlsym(handle,"QUEST");
677   fGcbank = (Gcbank_t *) dlsym(handle,"GCBANK");
678   fGclink = (Gclink_t *) dlsym(handle,"GCLINK");
679   fGccuts = (Gccuts_t *) dlsym(handle,"GCCUTS");
680   fGcmulo = (Gcmulo_t *) dlsym(handle,"GCMULO");
681   fGcflag = (Gcflag_t *) dlsym(handle,"GCFLAG");
682   fGckine = (Gckine_t *) dlsym(handle,"GCKINE");
683   fGcking = (Gcking_t *) dlsym(handle,"GCKING");
684   fGckin2 = (Gckin2_t *) dlsym(handle,"GCKIN2");
685   fGckin3 = (Gckin3_t *) dlsym(handle,"GCKIN3");
686   fGcmate = (Gcmate_t *) dlsym(handle,"GCMATE");
687   fGctmed = (Gctmed_t *) dlsym(handle,"GCTMED");
688   fGctrak = (Gctrak_t *) dlsym(handle,"GCTRAK");
689   fGctpol = (Gctpol_t *) dlsym(handle,"GCTPOL");
690   fGcvolu = (Gcvolu_t *) dlsym(handle,"GCVOLU");
691   fGcnum  = (Gcnum_t *)  dlsym(handle,"GCNUM");
692   fGcsets = (Gcsets_t *) dlsym(handle,"GCSETS");
693   fGcphys = (Gcphys_t *) dlsym(handle,"GCPHYS");
694   fGcphlt = (Gcphlt_t *) dlsym(handle,"GCPHLT");
695   fGcopti = (Gcopti_t *) dlsym(handle,"GCOPTI");
696   fGctlit = (Gctlit_t *) dlsym(handle,"GCTLIT");
697   fGcvdma = (Gcvdma_t *) dlsym(handle,"GCVDMA");
698   
699   // Commons for GEANE
700   fErtrio = (Ertrio_t *) dlsym(handle,"ERTRIO");
701   fEropts = (Eropts_t *) dlsym(handle,"EROPTS");
702   fEroptc = (Eroptc_t *) dlsym(handle,"EROPTC");
703   fErwork = (Erwork_t *) dlsym(handle,"ERWORK");
704 #endif
705   
706   // Variables for ZEBRA store
707   //
708   fZlq = (Int_t *) &(fGcbank->lmain)-1;
709   fZiq = (Int_t *) &(fGcbank->lmain)+7;
710   fZq  = (Float_t *)fZiq; 
711
712
713
714 //_____________________________________________________________________________
715 void TGeant3::GeomIter()
716 {
717   //
718   // Geometry iterator for moving upward in the geometry tree
719   // Initialise the iterator
720   //
721   fNextVol=fGcvolu->nlevel;
722 }
723
724 //____________________________________________________________________________ 
725 void TGeant3::FinishGeometry()
726 {
727   //Close the geometry structure
728   Ggclos();
729 }
730   
731 //____________________________________________________________________________ 
732 Int_t TGeant3::NextVolUp(Text_t *name, Int_t &copy)
733 {
734   //
735   // Geometry iterator for moving upward in the geometry tree
736   // Return next volume up
737   //
738   Int_t i, gname;
739   fNextVol--;
740   if(fNextVol>=0) {
741     gname=fGcvolu->names[fNextVol];
742     copy=fGcvolu->number[fNextVol];
743     i=fGcvolu->lvolum[fNextVol];
744     name = fVolNames[i-1];
745     if(gname == fZiq[fGclink->jvolum+i]) return i;
746     else printf("GeomTree: Volume %s not found in bank\n",name);
747   }
748   return 0;
749 }
750
751 //_____________________________________________________________________________
752 void TGeant3::BuildPhysics()
753 {
754   Gphysi();
755 }
756
757 //_____________________________________________________________________________
758 Int_t TGeant3::CurrentVolID(Int_t &copy) const
759 {
760   //
761   // Returns the current volume ID and copy number
762   //
763   Int_t i, gname;
764   if( (i=fGcvolu->nlevel-1) < 0 ) {
765     Warning("CurrentVolID","Stack depth only %d\n",fGcvolu->nlevel);
766   } else {
767     gname=fGcvolu->names[i];
768     copy=fGcvolu->number[i];
769     i=fGcvolu->lvolum[i];   
770     if(gname == fZiq[fGclink->jvolum+i]) return i;
771     else Warning("CurrentVolID","Volume %4s not found\n",(char*)&gname);
772   }
773   return 0;
774 }
775
776 //_____________________________________________________________________________
777 Int_t TGeant3::CurrentVolOffID(Int_t off, Int_t &copy) const
778 {
779   //
780   // Return the current volume "off" upward in the geometrical tree 
781   // ID and copy number
782   //
783   Int_t i, gname;
784   if( (i=fGcvolu->nlevel-off-1) < 0 ) {
785     Warning("CurrentVolOffID","Offset requested %d but stack depth %d\n",
786             off,fGcvolu->nlevel);
787   } else {
788     gname=fGcvolu->names[i];
789     copy=fGcvolu->number[i];          
790     i=fGcvolu->lvolum[i];    
791     if(gname == fZiq[fGclink->jvolum+i]) return i;
792     else Warning("CurrentVolOffID","Volume %4s not found\n",(char*)&gname);
793   }
794   return 0;
795 }
796
797 //_____________________________________________________________________________
798 const char* TGeant3::CurrentVolName() const
799 {
800   //
801   // Returns the current volume name
802   //
803   Int_t i, gname;
804   if( (i=fGcvolu->nlevel-1) < 0 ) {
805     Warning("CurrentVolName","Stack depth %d\n",fGcvolu->nlevel);
806   } else {
807     gname=fGcvolu->names[i];
808     i=fGcvolu->lvolum[i];   
809     if(gname == fZiq[fGclink->jvolum+i]) return fVolNames[i-1];
810     else Warning("CurrentVolName","Volume %4s not found\n",(char*) &gname);
811   }
812   return 0;
813 }
814
815 //_____________________________________________________________________________
816 const char* TGeant3::CurrentVolOffName(Int_t off) const
817 {
818   //
819   // Return the current volume "off" upward in the geometrical tree 
820   // ID, name and copy number
821   // if name=0 no name is returned
822   //
823   Int_t i, gname;
824   if( (i=fGcvolu->nlevel-off-1) < 0 ) {
825     Warning("CurrentVolOffName",
826             "Offset requested %d but stack depth %d\n",off,fGcvolu->nlevel);
827   } else {
828     gname=fGcvolu->names[i];
829     i=fGcvolu->lvolum[i];    
830     if(gname == fZiq[fGclink->jvolum+i]) return fVolNames[i-1];
831     else Warning("CurrentVolOffName","Volume %4s not found\n",(char*)&gname);
832   }
833   return 0;
834 }
835
836 //_____________________________________________________________________________
837 Int_t TGeant3::IdFromPDG(Int_t pdg) const 
838 {
839   //
840   // Return Geant3 code from PDG and pseudo ENDF code
841   //
842   for(Int_t i=0;i<fNPDGCodes;++i)
843     if(pdg==fPDGCode[i]) return i;
844   return -1;
845 }
846
847 //_____________________________________________________________________________
848 Int_t TGeant3::PDGFromId(Int_t id) const 
849 {
850   //
851   // Return PDG code and pseudo ENDF code from Geant3 code
852   //
853   if(id>0 && id<fNPDGCodes) return fPDGCode[id];
854   else return -1;
855 }
856
857 //_____________________________________________________________________________
858 void TGeant3::DefineParticles() 
859 {
860   //
861   // Define standard Geant 3 particles
862   Gpart();
863   //
864   // Load standard numbers for GEANT particles and PDG conversion
865   fPDGCode[fNPDGCodes++]=-99;   //  0 = unused location
866   fPDGCode[fNPDGCodes++]=22;    //  1 = photon
867   fPDGCode[fNPDGCodes++]=-11;   //  2 = positron
868   fPDGCode[fNPDGCodes++]=11;    //  3 = electron
869   fPDGCode[fNPDGCodes++]=12;    //  4 = neutrino e
870   fPDGCode[fNPDGCodes++]=-13;   //  5 = muon +
871   fPDGCode[fNPDGCodes++]=13;    //  6 = muon -
872   fPDGCode[fNPDGCodes++]=111;   //  7 = pi0
873   fPDGCode[fNPDGCodes++]=211;   //  8 = pi+
874   fPDGCode[fNPDGCodes++]=-211;  //  9 = pi-
875   fPDGCode[fNPDGCodes++]=130;   // 10 = Kaon Long
876   fPDGCode[fNPDGCodes++]=321;   // 11 = Kaon +
877   fPDGCode[fNPDGCodes++]=-321;  // 12 = Kaon -
878   fPDGCode[fNPDGCodes++]=2112;  // 13 = Neutron
879   fPDGCode[fNPDGCodes++]=2212;  // 14 = Proton
880   fPDGCode[fNPDGCodes++]=-2212; // 15 = Anti Proton
881   fPDGCode[fNPDGCodes++]=310;   // 16 = Kaon Short
882   fPDGCode[fNPDGCodes++]=221;   // 17 = Eta
883   fPDGCode[fNPDGCodes++]=3122;  // 18 = Lambda
884   fPDGCode[fNPDGCodes++]=3222;  // 19 = Sigma +
885   fPDGCode[fNPDGCodes++]=3212;  // 20 = Sigma 0
886   fPDGCode[fNPDGCodes++]=3112;  // 21 = Sigma -
887   fPDGCode[fNPDGCodes++]=3322;  // 22 = Xi0
888   fPDGCode[fNPDGCodes++]=3312;  // 23 = Xi-
889   fPDGCode[fNPDGCodes++]=3334;  // 24 = Omega-
890   fPDGCode[fNPDGCodes++]=-2112; // 25 = Anti Proton
891   fPDGCode[fNPDGCodes++]=-3122; // 26 = Anti Proton
892   fPDGCode[fNPDGCodes++]=-3222; // 27 = Anti Sigma -
893   fPDGCode[fNPDGCodes++]=-3212; // 28 = Anti Sigma 0
894   fPDGCode[fNPDGCodes++]=-3112; // 29 = Anti Sigma 0
895   fPDGCode[fNPDGCodes++]=-3322; // 30 = Anti Xi 0
896   fPDGCode[fNPDGCodes++]=-3312; // 31 = Anti Xi +
897   fPDGCode[fNPDGCodes++]=-3334; // 32 = Anti Omega +
898
899
900   Int_t mode[6];
901   Int_t kz, ipa;
902   Float_t bratio[6];
903
904   /* --- Define additional particles */
905   Gspart(33, "OMEGA(782)", 3, 0.782, 0., 7.836e-23);
906   fPDGCode[fNPDGCodes++]=223;   // 33 = Omega(782)
907   
908   Gspart(34, "PHI(1020)", 3, 1.019, 0., 1.486e-22);
909   fPDGCode[fNPDGCodes++]=333;   // 34 = PHI (1020)
910
911   Gspart(35, "D +", 4, 1.87, 1., 1.066e-12);
912   fPDGCode[fNPDGCodes++]=411;   // 35 = D+
913
914   Gspart(36, "D -", 4, 1.87, -1., 1.066e-12);
915   fPDGCode[fNPDGCodes++]=-411;  // 36 = D-
916
917   Gspart(37, "D 0", 3, 1.865, 0., 4.2e-13);
918   fPDGCode[fNPDGCodes++]=421;   // 37 = D0
919
920   Gspart(38, "ANTI D 0", 3, 1.865, 0., 4.2e-13);
921   fPDGCode[fNPDGCodes++]=-421;  // 38 = D0 bar
922
923   fPDGCode[fNPDGCodes++]=-99;  // 39 = unassigned
924
925   fPDGCode[fNPDGCodes++]=-99;  // 40 = unassigned
926
927   fPDGCode[fNPDGCodes++]=-99;  // 41 = unassigned
928
929   Gspart(42, "RHO +", 4, 0.768, 1., 4.353e-24);
930   fPDGCode[fNPDGCodes++]=213;   // 42 = RHO+
931
932   Gspart(43, "RHO -", 4, 0.768, -1., 4.353e-24);
933   fPDGCode[fNPDGCodes++]=-213;   // 43 = RHO-
934
935   Gspart(44, "RHO 0", 3, 0.768, 0., 4.353e-24);
936   fPDGCode[fNPDGCodes++]=113;   //  44 = RHO0
937
938   //
939   // Use ENDF-6 mapping for ions = 10000*z+10*a+iso
940   // and add 1 000 000
941   // and numbers above 5 000 000 for special applications
942   //
943
944   const Int_t kion=10000000;
945
946   const Int_t kspe=50000000;
947
948   TDatabasePDG *pdgDB = TDatabasePDG::Instance();
949
950   const Double_t kAu2Gev=0.9314943228;
951   const Double_t khSlash = 1.0545726663e-27;
952   const Double_t kErg2Gev = 1/1.6021773349e-3;
953   const Double_t khShGev = khSlash*kErg2Gev;
954   const Double_t kYear2Sec = 3600*24*365.25;
955 //
956 // Bottom mesons
957 // mass and life-time from PDG
958   pdgDB->AddParticle("B(s)*0","B(s)*0",
959                      5.4163, kTRUE, 0.047, +0.,"Meson",  533);
960
961   pdgDB->AddParticle("B(s)*0 bar","B(s)*0 bar",
962                      5.4163, kTRUE, 0.047, -0.,"Meson", -533);
963
964 // Charmed baryons
965 // 
966 // value for mass used by Hijing
967   pdgDB->AddParticle("Sigma(c)*+","Sigma(c)*+",
968                      2.4536, kTRUE, -1., +1.,"Baryon",  4214);
969
970   pdgDB->AddParticle("Sigma(c)*-","Sigma(c)*-",
971                      2.4536, kTRUE, -1., -1.,"Baryon", -4214);
972 // equivalent to 4312 ? Hijing uses m=2.55
973   pdgDB->AddParticle("Xsi(c)0","Xsi(c)0",
974                      2.4703, kTRUE, -1., +0.,"Baryon",  4132);
975
976   pdgDB->AddParticle("Xsi(c)0 bar","Xsi(c)0 bar",
977                      2.4703, kTRUE, -1., -0.,"Baryon", -4132);
978 // equivalent to 4322 ? Hijing uses m=2.55
979   pdgDB->AddParticle("Xi(c)+","Xi(c)+",
980                      2.4656, kFALSE, -1., +1.,"Baryon",  4232);
981   
982   pdgDB->AddParticle("Xi(c)-","Xi(c)-",
983                      2.4656, kFALSE, -1., -1.,"Baryon", -4232);
984 // mass values from Hijing
985
986   pdgDB->AddParticle("Xsi(c)*0","Xsi(c)*0",
987                      2.63, kTRUE, -1., +0.,"Baryon",  4314);
988
989   pdgDB->AddParticle("Xsi(c)*0 bar","Xsi(c)*0 bar",
990                      2.63, kTRUE, -1., -0.,"Baryon", -4314);
991
992   pdgDB->AddParticle("Xsi(c)*+","Xsi(c)*+",
993                      2.63, kTRUE, -1., +1.,"Baryon",  4324);
994
995   pdgDB->AddParticle("Xsi(c)*-","Xsi(c)*-",
996                      2.63, kTRUE, -1., -1.,"Baryon", -4324);
997
998 // pdg mass value, Hijing uses m=2.73.
999   pdgDB->AddParticle("Omega(c)0","Omega(c)0",
1000                      2.7040, kFALSE, khShGev/0.064e-12, +0.,"Baryon",  4332);
1001   
1002   pdgDB->AddParticle("Omega(c)0 bar","Omega(c)0 bar",
1003                      2.7040, kFALSE, khShGev/0.064e-12, -0.,"Baryon", -4332);
1004 // mass value from Hijing
1005   pdgDB->AddParticle("Omega(c)*0","Omega(c)*0",
1006                      2.8000, kFALSE, -1., +0.,"Baryon",  4334);
1007   
1008   pdgDB->AddParticle("Omega(c)*0 bar","Omega(c)*0",
1009                      2.8000, kFALSE, -1., -0.,"Baryon", -4334);
1010
1011
1012 // Xi(cc)
1013
1014   pdgDB->AddParticle("Xsi(cc)+","Xsi(cc)+",
1015                      3.60, kTRUE, -1., +1.,"Baryon",  4412);
1016
1017   pdgDB->AddParticle("Xsi(cc) bar-","Xsi(cc) bar-",
1018                      3.60, kTRUE, -1., -1.,"Baryon", -4412);
1019
1020   pdgDB->AddParticle("Xsi*(cc)+","Xsi*(cc)+",
1021                      3.66, kTRUE, -1., +1.,"Baryon",  4414);
1022
1023   pdgDB->AddParticle("Xsi*(cc) bar-","Xsi*(cc) bar-",
1024                      3.66, kTRUE, -1., -1.,"Baryon", -4414);
1025
1026
1027   pdgDB->AddParticle("Xsi(cc)++","Xsi(cc)++",
1028                      3.60, kTRUE, -1., +2.,"Baryon",  4422);
1029
1030   pdgDB->AddParticle("Xsi(cc) bar--","Xsi(cc) bar--",
1031                      3.60, kTRUE, -1., -2.,"Baryon", -4422);
1032
1033
1034   pdgDB->AddParticle("Xsi*(cc)++","Xsi*(cc)++",
1035                      3.66, kTRUE, -1., +2.,"Baryon",  4424);
1036
1037   pdgDB->AddParticle("Xsi*(cc) bar-","Xsi*(cc) bar-",
1038                      3.66, kTRUE, -1., -2.,"Baryon", -4424);
1039
1040   pdgDB->AddParticle("Omega(cc)+","Omega(cc)+",
1041                      3.78, kTRUE, -1., +1.,"Baryon",  4432);
1042
1043   pdgDB->AddParticle("Omega(cc) bar-","Omega(cc) bar-",
1044                      3.78, kTRUE, -1., -1.,"Baryon", -4432);
1045
1046   pdgDB->AddParticle("Omega*(cc)+","Omega*(cc)+",
1047                      3.82, kTRUE, -1., +1.,"Baryon",  4434);
1048
1049   pdgDB->AddParticle("Omega*(cc) bar-","Omega*(cc) bar-",
1050                      3.82, kTRUE, -1., -1.,"Baryon", -4434);
1051
1052
1053   pdgDB->AddParticle("Omega*(ccc)+","Omega*(cc)++",
1054                      4.91, kTRUE, -1., +2.,"Baryon",  4444);
1055
1056   pdgDB->AddParticle("Omega*(ccc) bar--","Omega*(cc) bar--",
1057                      4.91, kTRUE, -1., -2.,"Baryon", -4444);
1058
1059
1060
1061 // Bottom baryons
1062 //
1063 // mass value from Hijing
1064   pdgDB->AddParticle("Sigma(b)*+","Sigma(b)*+",
1065                      5.8100, kFALSE, -1., +1.,"Baryon", 5224);
1066
1067   pdgDB->AddParticle("Sigma(b)*-","Sigma(b)*-",
1068                      5.8100, kFALSE, -1., -1.,"Baryon", -5224);
1069
1070
1071   pdgDB->AddParticle("Xi(b)0","Xi(b)0",
1072                      5.8400, kFALSE, -1., +0.,"Baryon", 5232);
1073
1074   pdgDB->AddParticle("Xi(b)0 bar","Xi(b)0 bar",
1075                      5.8100, kFALSE, -1., -0.,"Baryon", -5232);
1076
1077 // B(s) 
1078   pdgDB->AddParticle("Xi'(b)-","Xi'(b)-",
1079                      5.9600, kFALSE, -1., -1.,"Baryon", 5312);
1080
1081   pdgDB->AddParticle("Xi'(b) bar+","Xi'(b) bar+",
1082                      5.9600, kFALSE, -1.,  1.,"Baryon", -5312);
1083
1084   pdgDB->AddParticle("Xi*(b)-","Xi*(b)-",
1085                      5.9700, kFALSE, -1., -1.,"Baryon", 5314);
1086
1087   pdgDB->AddParticle("Xi*(b) bar+","Xi*(b) bar+",
1088                      5.9700, kFALSE, -1.,  1.,"Baryon", -5314);
1089
1090   pdgDB->AddParticle("Xi'(b)0","Xi'(b)0",
1091                      5.9600, kFALSE, -1., -0.,"Baryon", 5322);
1092
1093   pdgDB->AddParticle("Xi'(b) bar0","Xi'(b) bar0",
1094                      5.9600, kFALSE, -1.,  0.,"Baryon", -5322);
1095
1096   pdgDB->AddParticle("Xi*(b)0","Xi*(b)0",
1097                      5.9700, kFALSE, -1., -0.,"Baryon", 5324);
1098
1099   pdgDB->AddParticle("Xi*(b) bar0","Xi*(b) bar0",
1100                      5.9700, kFALSE, -1.,  0.,"Baryon", -5324);
1101
1102   pdgDB->AddParticle("Omega(b)-","Omega(b)-",
1103                      6.1200, kFALSE, -1., -1.,"Baryon", 5332);
1104
1105   pdgDB->AddParticle("Omega(b) bar+","Omega(b) bar+",
1106                      6.1200, kFALSE, -1.,  1.,"Baryon", -5332);
1107
1108   pdgDB->AddParticle("Omega*(b)-","Omega*(b)-",
1109                      6.1300, kFALSE, -1., -1.,"Baryon", 5334);
1110
1111   pdgDB->AddParticle("Omega*(b) bar+","Omega*(b) bar+",
1112                      6.1300, kFALSE, -1.,  1.,"Baryon", -5334);
1113
1114
1115   pdgDB->AddParticle("Omega*(b)-","Omega*(b)-",
1116                      6.1300, kFALSE, -1., -1.,"Baryon", 5334);
1117
1118   pdgDB->AddParticle("Omega*(b) bar+","Omega*(b) bar+",
1119                      6.1300, kFALSE, -1.,  1.,"Baryon", -5334);
1120
1121 // B(c) 
1122
1123   pdgDB->AddParticle("Omega(bc)0","Omega(bc)0",
1124                      7.1900, kFALSE, -1., -0.,"Baryon", 5342);
1125
1126   pdgDB->AddParticle("Omega(bc) bar0","Omega(bc) bar0",
1127                      7.1900, kFALSE, -1.,  0.,"Baryon", -5342);
1128
1129   pdgDB->AddParticle("Xi'(bc)0","Xi'(bc)0",
1130                      7.0400, kFALSE, -1., -0.,"Baryon", 5412);
1131
1132   pdgDB->AddParticle("Xi'(bc) bar0","Xi'(bc) bar0",
1133                      7.0400, kFALSE, -1.,  0.,"Baryon", -5412);
1134
1135   pdgDB->AddParticle("Xi*(bc)0","Xi*(bc)0",
1136                      7.0500, kFALSE, -1., -0.,"Baryon", 5414);
1137
1138   pdgDB->AddParticle("Xi*(bc) bar0","Xi*(bc) bar0",
1139                      7.0500, kFALSE, -1.,  0.,"Baryon", -5414);
1140
1141   pdgDB->AddParticle("Xi'(bc)+","Xi'(bc)+",
1142                      7.0400, kFALSE, -1., +1.,"Baryon", 5422);
1143
1144   pdgDB->AddParticle("Xi'(bc) bar-","Xi'(bc) bar-",
1145                      7.0400, kFALSE, -1., -1.,"Baryon", -5422);
1146
1147   pdgDB->AddParticle("Xi*(bc)+","Xi*(bc)+",
1148                      7.0500, kFALSE, -1., +1.,"Baryon", 5424);
1149
1150   pdgDB->AddParticle("Xi*(bc) bar-","Xi*(bc) bar-",
1151                      7.0500, kFALSE, -1., -1.,"Baryon", -5424);
1152
1153   pdgDB->AddParticle("Omega'(bc)0","Omega'(bc)0",
1154                      7.2100, kFALSE, -1., -0.,"Baryon", 5432);
1155
1156   pdgDB->AddParticle("Omega'(bc) bar0","Omega'(bc) bar0",
1157                      7.2100, kFALSE, -1.,  0.,"Baryon", -5432);
1158
1159   pdgDB->AddParticle("Omega*(bc)0","Omega*(bc)0",
1160                      7.2200, kFALSE, -1., -0.,"Baryon", 5434);
1161
1162   pdgDB->AddParticle("Omega*(bc) bar0","Omega*(bc) bar0",
1163                      7.2200, kFALSE, -1.,  0.,"Baryon", -5434);
1164 // B(bcc)
1165   pdgDB->AddParticle("Omega(bcc)+","Omega(bcc)+",
1166                      8.3100, kFALSE, -1., +1.,"Baryon", 5442);
1167
1168   pdgDB->AddParticle("Omega(bcc) bar-","Omega(bcc) bar-",
1169                      8.3100, kFALSE, -1., -1.,"Baryon", -5442);
1170
1171   pdgDB->AddParticle("Omega*(bcc)+","Omega*(bcc)+",
1172                     8.3100, kFALSE, -1., +1.,"Baryon", 5444);
1173
1174   pdgDB->AddParticle("Omega*(bcc) bar-","Omega*(bcc) bar-",
1175                      8.3100, kFALSE, -1., -1.,"Baryon", -5444);
1176
1177
1178
1179
1180 // B(bb)
1181
1182   pdgDB->AddParticle("Xsi(bb)-","Xsi(bb)-",
1183                      10.4200, kFALSE, -1., -1.,"Baryon", 5512);
1184   
1185   pdgDB->AddParticle("Xsi(bb) bar+","Xsi(bb) bar+",
1186                      10.4200, kFALSE, -1., +1.,"Baryon", -5512);
1187
1188   pdgDB->AddParticle("Xsi*(bb)-","Xsi*(bb)-",
1189                      10.4400, kFALSE, -1., -1.,"Baryon", 5514);
1190   
1191   pdgDB->AddParticle("Xsi*(bb) bar+","Xsi*(bb) bar+",
1192                      10.4400, kFALSE, -1., +1.,"Baryon", -5514);
1193
1194   pdgDB->AddParticle("Xsi(bb)0","Xsi(bb)0",
1195                      10.4200, kFALSE, -1., -0.,"Baryon", 5522);
1196   
1197   pdgDB->AddParticle("Xsi(bb) bar0","Xsi(bb) bar0",
1198                      10.4200, kFALSE, -1., +0.,"Baryon", -5522);
1199
1200   pdgDB->AddParticle("Xsi*(bb)0","Xsi*(bb)0",
1201                      10.4400, kFALSE, -1., -0.,"Baryon", 5524);
1202   
1203   pdgDB->AddParticle("Xsi*(bb) bar0","Xsi*(bb) bar0",
1204                      10.4400, kFALSE, -1., +0.,"Baryon", -5524);
1205
1206   pdgDB->AddParticle("Omega*(bb)-","Omega(bb)-",
1207                      10.6000, kFALSE, -1., -1.,"Baryon", 5532);
1208
1209   pdgDB->AddParticle("Omega(bb) bar+","Omega(bb) bar+",
1210                      10.6000, kFALSE, -1., +1.,"Baryon", -5532);
1211
1212   pdgDB->AddParticle("Omega*(bb)-","Omega*(bb)-",
1213                      10.6000, kFALSE, -1., -1.,"Baryon", 5534);
1214
1215   pdgDB->AddParticle("Omega*(bb) bar+","Omega*(bb) bar+",
1216                      10.6000, kFALSE, -1., +1.,"Baryon", -5534);
1217
1218 // B(bbc)
1219
1220   pdgDB->AddParticle("Omega(bbc)0","Omega(bbc)0",
1221                      11.7100, kFALSE, -1., -0.,"Baryon", 5542);
1222
1223   pdgDB->AddParticle("Omega(bbc) bar0","Omega(bbc) bar0",
1224                      11.7100, kFALSE, -1., +0.,"Baryon", -5542);
1225
1226   pdgDB->AddParticle("Omega*(bbc)0","Omega*(bbc)0",
1227                      11.7100, kFALSE, -1., -0.,"Baryon", 5544);
1228
1229   pdgDB->AddParticle("Omega*(bbc) bar0","Omega*(bbc) bar0",
1230                      11.7100, kFALSE, -1., +0.,"Baryon", -5544);
1231 // B(bbb)
1232
1233   pdgDB->AddParticle("Omega*(bbb)-","Omega*(bbb)-",
1234                      15.1000, kFALSE, -1., -1.,"Baryon", 5544);
1235
1236   pdgDB->AddParticle("Omega*(bbb) bar+","Omega*(bbb) bar+",
1237                      15.100, kFALSE, -1., +1.,"Baryon", -5544);
1238
1239 //
1240 //
1241   pdgDB->AddParticle("Deuteron","Deuteron",2*kAu2Gev+8.071e-3,kTRUE,
1242                      0,1,"Ion",kion+10020);
1243   fPDGCode[fNPDGCodes++]=kion+10020;   // 45 = Deuteron
1244
1245   pdgDB->AddParticle("Triton","Triton",3*kAu2Gev+14.931e-3,kFALSE,
1246                      khShGev/(12.33*kYear2Sec),1,"Ion",kion+10030);
1247   fPDGCode[fNPDGCodes++]=kion+10030;   // 46 = Triton
1248
1249   pdgDB->AddParticle("Alpha","Alpha",4*kAu2Gev+2.424e-3,kTRUE,
1250                      khShGev/(12.33*kYear2Sec),2,"Ion",kion+20040);
1251   fPDGCode[fNPDGCodes++]=kion+20040;   // 47 = Alpha
1252
1253   fPDGCode[fNPDGCodes++]=0;   // 48 = geantino mapped to rootino
1254
1255   pdgDB->AddParticle("HE3","HE3",3*kAu2Gev+14.931e-3,kFALSE,
1256                      0,2,"Ion",kion+20030);
1257   fPDGCode[fNPDGCodes++]=kion+20030;   // 49 = HE3
1258
1259   pdgDB->AddParticle("Cherenkov","Cherenkov",0,kFALSE,
1260                      0,0,"Special",kspe+50);
1261   fPDGCode[fNPDGCodes++]=kspe+50;   // 50 = Cherenkov
1262
1263   Gspart(51, "FeedbackPhoton", 7, 0., 0.,1.e20 );
1264   pdgDB->AddParticle("FeedbackPhoton","FeedbackPhoton",0,kFALSE,
1265                      0,0,"Special",kspe+51);
1266   fPDGCode[fNPDGCodes++]=kspe+51;   // 51 = FeedbackPhoton
1267   Gspart(52, "Lambda_c+", 4, 2.2849, +1., 2.06e-13);
1268   fPDGCode[fNPDGCodes++]=4122;   //52 = Lambda_c+
1269
1270   Gspart(53, "Lambda_c-", 4, 2.2849, -1., 2.06e-13);
1271   fPDGCode[fNPDGCodes++]=-4122; //53 = Lambda_c-  
1272
1273   Gspart(54, "D_s+", 4, 1.9685, +1., 4.67e-13);
1274   fPDGCode[fNPDGCodes++]=431;   //54 = D_s+
1275
1276   Gspart(55, "D_s-", 4, 1.9685, -1., 4.67e-13);
1277   fPDGCode[fNPDGCodes++]=-431; //55 = D_s-
1278
1279   Gspart(56, "Tau+", 5, 1.77705, +1., 2.9e-13);
1280   fPDGCode[fNPDGCodes++]=15;   //56 = Tau+
1281
1282   Gspart(57, "Tau-", 5, 1.77705, -1., 2.9e-13);
1283   fPDGCode[fNPDGCodes++]=-15;  //57 = Tau-  
1284
1285   Gspart(58, "B0",     3, 5.2792, +0., 1.56e-12);
1286   fPDGCode[fNPDGCodes++]=511;   //58 = B0
1287
1288   Gspart(59, "B0 bar", 3, 5.2792, -0., 1.56e-12);
1289   fPDGCode[fNPDGCodes++]=-511;  //58 = B0bar
1290
1291   Gspart(60, "B+",     4, 5.2789, +1., 1.65e-12);
1292   fPDGCode[fNPDGCodes++]=521;   //60 = B+
1293
1294   Gspart(61, "B-",     4, 5.2789, -1., 1.65e-12);
1295   fPDGCode[fNPDGCodes++]=-521;  //61 = B-
1296
1297   Gspart(62, "Bs",     3, 5.3693, +0., 1.54e-12);
1298   fPDGCode[fNPDGCodes++]=521;   //62 = B_s
1299
1300   Gspart(63, "Bs bar", 3, 5.3693, -0., 1.54e-12);
1301   fPDGCode[fNPDGCodes++]=-521;  //63 = B_s bar
1302
1303   Gspart(64, "Lambda_b",     3, 5.624, +0., 1.24e-12);
1304   fPDGCode[fNPDGCodes++]=5122;   //64 = Lambda_b
1305
1306   Gspart(65, "Lambda_b bar", 3, 5.624, -0., 1.24e-12);
1307   fPDGCode[fNPDGCodes++]=-5122;  //65 = Lambda_b bar
1308
1309   Gspart(66, "J/Psi", 3.09688, 3, 0., 0.);
1310   fPDGCode[fNPDGCodes++]=443;       // 66 = J/Psi
1311
1312   Gspart(67, "Psi Prime", 3, 3.686, 0., 0.);
1313   fPDGCode[fNPDGCodes++]=20443;    // 67 = Psi prime
1314
1315   Gspart(68, "Upsilon(1S)", 9.46037, 3, 0., 0.);
1316   fPDGCode[fNPDGCodes++]=553;       // 68 = Upsilon(1S)
1317
1318   Gspart(69, "Upsilon(2S)", 10.0233, 3, 0., 0.);
1319   fPDGCode[fNPDGCodes++]=20553;       // 69 = Upsilon(2S)
1320
1321   Gspart(70, "Upsilon(3S)", 10.3553, 3, 0., 0.);
1322   fPDGCode[fNPDGCodes++]=30553;       // 70 = Upsilon(3S)
1323
1324 /* --- Define additional decay modes --- */
1325 /* --- omega(783) --- */
1326     for (kz = 0; kz < 6; ++kz) {
1327         bratio[kz] = 0.;
1328         mode[kz] = 0;
1329     }
1330     ipa = 33;
1331     bratio[0] = 89.;
1332     bratio[1] = 8.5;
1333     bratio[2] = 2.5;
1334     mode[0] = 70809;
1335     mode[1] = 107;
1336     mode[2] = 908;
1337     Gsdk(ipa, bratio, mode);
1338 /* --- phi(1020) --- */
1339     for (kz = 0; kz < 6; ++kz) {
1340         bratio[kz] = 0.;
1341         mode[kz] = 0;
1342     }
1343     ipa = 34;
1344     bratio[0] = 49.;
1345     bratio[1] = 34.4;
1346     bratio[2] = 12.9;
1347     bratio[3] = 2.4;
1348     bratio[4] = 1.3;
1349     mode[0] = 1112;
1350     mode[1] = 1610;
1351     mode[2] = 4407;
1352     mode[3] = 90807;
1353     mode[4] = 1701;
1354     Gsdk(ipa, bratio, mode);
1355 /* --- D+ --- */
1356     /*
1357     for (kz = 0; kz < 6; ++kz) {
1358         bratio[kz] = 0.;
1359         mode[kz] = 0;
1360     }
1361     ipa = 35;
1362     bratio[0] = 25.;
1363     bratio[1] = 25.;
1364     bratio[2] = 25.;
1365     bratio[3] = 25.;
1366     mode[0] = 80809;
1367     mode[1] = 120808;
1368     mode[2] = 111208;
1369     mode[3] = 110809;
1370     Gsdk(ipa, bratio, mode);
1371     */
1372 /* --- D- --- */
1373     /*
1374     for (kz = 0; kz < 6; ++kz) {
1375         bratio[kz] = 0.;
1376         mode[kz] = 0;
1377     }
1378     ipa = 36;
1379     bratio[0] = 25.;
1380     bratio[1] = 25.;
1381     bratio[2] = 25.;
1382     bratio[3] = 25.;
1383     mode[0] = 90908;
1384     mode[1] = 110909;
1385     mode[2] = 121109;
1386     mode[3] = 120908;
1387     Gsdk(ipa, bratio, mode);
1388     */
1389 /* --- D0 --- */
1390     /*
1391     for (kz = 0; kz < 6; ++kz) {
1392         bratio[kz] = 0.;
1393         mode[kz] = 0;
1394     }
1395     ipa = 37;
1396     bratio[0] = 33.;
1397     bratio[1] = 33.;
1398     bratio[2] = 33.;
1399     mode[0] = 809;
1400     mode[1] = 1208;
1401     mode[2] = 1112;
1402     Gsdk(ipa, bratio, mode);
1403     */
1404 /* --- Anti D0 --- */
1405     /*
1406     for (kz = 0; kz < 6; ++kz) {
1407         bratio[kz] = 0.;
1408         mode[kz] = 0;
1409     }
1410     ipa = 38;
1411     bratio[0] = 33.;
1412     bratio[1] = 33.;
1413     bratio[2] = 33.;
1414     mode[0] = 809;
1415     mode[1] = 1109;
1416     mode[2] = 1112;
1417     Gsdk(ipa, bratio, mode);
1418     */
1419 /* --- rho+ --- */
1420     for (kz = 0; kz < 6; ++kz) {
1421         bratio[kz] = 0.;
1422         mode[kz] = 0;
1423     }
1424     ipa = 42;
1425     bratio[0] = 100.;
1426     mode[0] = 807;
1427     Gsdk(ipa, bratio, mode);
1428 /* --- rho- --- */
1429     for (kz = 0; kz < 6; ++kz) {
1430         bratio[kz] = 0.;
1431         mode[kz] = 0;
1432     }
1433     ipa = 43;
1434     bratio[0] = 100.;
1435     mode[0] = 907;
1436     Gsdk(ipa, bratio, mode);
1437 /* --- rho0 --- */
1438     for (kz = 0; kz < 6; ++kz) {
1439         bratio[kz] = 0.;
1440         mode[kz] = 0;
1441     }
1442     ipa = 44;
1443     bratio[0] = 100.;
1444     mode[0] = 707;
1445     Gsdk(ipa, bratio, mode);
1446     /*
1447 // --- jpsi ---
1448     for (kz = 0; kz < 6; ++kz) {
1449         bratio[kz] = 0.;
1450         mode[kz] = 0;
1451     }
1452     ipa = 113;
1453     bratio[0] = 50.;
1454     bratio[1] = 50.;
1455     mode[0] = 506;
1456     mode[1] = 605;
1457     Gsdk(ipa, bratio, mode);
1458 // --- upsilon --- 
1459     ipa = 114;
1460     Gsdk(ipa, bratio, mode);
1461 // --- phi --- 
1462     ipa = 115;
1463     Gsdk(ipa, bratio, mode);
1464     */
1465
1466 }
1467
1468 //_____________________________________________________________________________
1469 Int_t TGeant3::VolId(const Text_t *name) const
1470 {
1471   //
1472   // Return the unique numeric identifier for volume name
1473   //
1474   Int_t gname, i;
1475   strncpy((char *) &gname, name, 4);
1476   for(i=1; i<=fGcnum->nvolum; i++)
1477     if(gname == fZiq[fGclink->jvolum+i]) return i;
1478   printf("VolId: Volume %s not found\n",name);
1479   return 0;
1480 }
1481
1482 //_____________________________________________________________________________
1483 Int_t TGeant3::NofVolumes() const 
1484 {
1485   //
1486   // Return total number of volumes in the geometry
1487   //
1488   return fGcnum->nvolum;
1489 }
1490
1491 //_____________________________________________________________________________
1492 Int_t TGeant3::VolId2Mate(Int_t id) const 
1493 {
1494   //
1495   // Return material number for a given volume id
1496   //
1497   if(id<1 || id > fGcnum->nvolum || fGclink->jvolum<=0) 
1498     return 0;
1499   else {
1500     Int_t jvo = fZlq[fGclink->jvolum-id];
1501     return Int_t(fZq[jvo+4]);
1502   }
1503 }
1504
1505 //_____________________________________________________________________________
1506 const char* TGeant3::VolName(Int_t id) const
1507 {
1508   //
1509   // Return the volume name given the volume identifier
1510   //
1511   if(id<1 || id > fGcnum->nvolum || fGclink->jvolum<=0) 
1512     return fVolNames[fGcnum->nvolum];
1513   else
1514     return fVolNames[id-1];
1515 }
1516
1517 //_____________________________________________________________________________
1518 void    TGeant3::SetCut(const char* cutName, Float_t cutValue)
1519 {
1520   //
1521   // Set transport cuts for particles
1522   //
1523   if(!strcmp(cutName,"CUTGAM")) 
1524     fGccuts->cutgam=cutValue; 
1525   else if(!strcmp(cutName,"CUTGAM")) 
1526     fGccuts->cutele=cutValue; 
1527   else if(!strcmp(cutName,"CUTELE")) 
1528     fGccuts->cutneu=cutValue; 
1529   else if(!strcmp(cutName,"CUTHAD")) 
1530     fGccuts->cuthad=cutValue; 
1531   else if(!strcmp(cutName,"CUTMUO")) 
1532     fGccuts->cutmuo=cutValue; 
1533   else if(!strcmp(cutName,"BCUTE")) 
1534     fGccuts->bcute=cutValue; 
1535   else if(!strcmp(cutName,"BCUTM")) 
1536     fGccuts->bcutm=cutValue; 
1537   else if(!strcmp(cutName,"DCUTE")) 
1538     fGccuts->dcute=cutValue; 
1539   else if(!strcmp(cutName,"DCUTM")) 
1540     fGccuts->dcutm=cutValue; 
1541   else if(!strcmp(cutName,"PPCUTM")) 
1542     fGccuts->ppcutm=cutValue; 
1543   else if(!strcmp(cutName,"TOFMAX")) 
1544     fGccuts->tofmax=cutValue; 
1545   else Warning("SetCut","Cut %s not implemented\n",cutName);
1546 }
1547
1548 //_____________________________________________________________________________
1549 void    TGeant3::SetProcess(const char* flagName, Int_t flagValue)
1550 {
1551   //
1552   // Set thresholds for different processes
1553   //
1554   if(!strcmp(flagName,"PAIR")) 
1555     fGcphys->ipair=flagValue;
1556   else if(!strcmp(flagName,"COMP")) 
1557     fGcphys->icomp=flagValue;
1558   else if(!strcmp(flagName,"PHOT")) 
1559     fGcphys->iphot=flagValue;
1560   else if(!strcmp(flagName,"PFIS")) 
1561     fGcphys->ipfis=flagValue;
1562   else if(!strcmp(flagName,"DRAY")) 
1563     fGcphys->idray=flagValue;
1564   else if(!strcmp(flagName,"ANNI")) 
1565     fGcphys->ianni=flagValue;
1566   else if(!strcmp(flagName,"BREM")) 
1567     fGcphys->ibrem=flagValue;
1568   else if(!strcmp(flagName,"HADR")) 
1569     fGcphys->ihadr=flagValue;
1570   else if(!strcmp(flagName,"MUNU")) 
1571     fGcphys->imunu=flagValue;
1572   else if(!strcmp(flagName,"DCAY")) 
1573     fGcphys->idcay=flagValue;
1574   else if(!strcmp(flagName,"LOSS")) 
1575     fGcphys->iloss=flagValue;
1576   else if(!strcmp(flagName,"MULS")) 
1577     fGcphys->imuls=flagValue;
1578   else if(!strcmp(flagName,"RAYL")) 
1579     fGcphys->irayl=flagValue;
1580   else if(!strcmp(flagName,"STRA")) 
1581     fGcphlt->istra=flagValue;
1582   else if(!strcmp(flagName,"SYNC")) 
1583     fGcphlt->isync=flagValue;
1584   else  Warning("SetFlag","Flag %s not implemented\n",flagName);
1585 }
1586
1587 //_____________________________________________________________________________
1588 Float_t TGeant3::Xsec(char* reac, Float_t /* energy */, 
1589                       Int_t part, Int_t /* mate */)
1590 {
1591   //
1592   // Calculate X-sections -- dummy for the moment
1593   //
1594   if(!strcmp(reac,"PHOT"))
1595   {
1596     if(part!=22) {
1597       Error("Xsec","Can calculate photoelectric only for photons\n");
1598     }
1599   }
1600   return 0;
1601 }
1602
1603 //_____________________________________________________________________________
1604 void TGeant3::TrackPosition(TLorentzVector &xyz) const
1605 {
1606   //
1607   // Return the current position in the master reference frame of the
1608   // track being transported
1609   //
1610   xyz[0]=fGctrak->vect[0];
1611   xyz[1]=fGctrak->vect[1];
1612   xyz[2]=fGctrak->vect[2];
1613   xyz[3]=fGctrak->tofg;
1614 }
1615
1616 //_____________________________________________________________________________
1617 Float_t TGeant3::TrackTime() const
1618 {
1619   //
1620   // Return the current time of flight of the track being transported
1621   //
1622   return fGctrak->tofg;
1623 }
1624
1625 //_____________________________________________________________________________
1626 void TGeant3::TrackMomentum(TLorentzVector &xyz) const
1627 {
1628   //
1629   // Return the direction and the momentum (GeV/c) of the track
1630   // currently being transported
1631   //
1632   Double_t ptot=fGctrak->vect[6];
1633   xyz[0]=fGctrak->vect[3]*ptot;
1634   xyz[1]=fGctrak->vect[4]*ptot;
1635   xyz[2]=fGctrak->vect[5]*ptot;
1636   xyz[3]=fGctrak->getot;
1637 }
1638
1639 //_____________________________________________________________________________
1640 Float_t TGeant3::TrackCharge() const
1641 {
1642   //
1643   // Return charge of the track currently transported
1644   //
1645   return fGckine->charge;
1646 }
1647
1648 //_____________________________________________________________________________
1649 Float_t TGeant3::TrackMass() const
1650 {
1651   //
1652   // Return the mass of the track currently transported
1653   //
1654   return fGckine->amass;
1655 }
1656
1657 //_____________________________________________________________________________
1658 Int_t TGeant3::TrackPid() const
1659 {
1660   //
1661   // Return the id of the particle transported
1662   //
1663   return PDGFromId(fGckine->ipart);
1664 }
1665
1666 //_____________________________________________________________________________
1667 Float_t TGeant3::TrackStep() const
1668 {
1669   //
1670   // Return the length in centimeters of the current step
1671   //
1672   return fGctrak->step;
1673 }
1674
1675 //_____________________________________________________________________________
1676 Float_t TGeant3::TrackLength() const
1677 {
1678   //
1679   // Return the length of the current track from its origin
1680   //
1681   return fGctrak->sleng;
1682 }
1683
1684 //_____________________________________________________________________________
1685 Bool_t TGeant3::IsNewTrack() const
1686 {
1687   //
1688   // True if the track is not at the boundary of the current volume
1689   //
1690   return (fGctrak->sleng==0);
1691 }
1692
1693 //_____________________________________________________________________________
1694 Bool_t TGeant3::IsTrackInside() const
1695 {
1696   //
1697   // True if the track is not at the boundary of the current volume
1698   //
1699   return (fGctrak->inwvol==0);
1700 }
1701
1702 //_____________________________________________________________________________
1703 Bool_t TGeant3::IsTrackEntering() const
1704 {
1705   //
1706   // True if this is the first step of the track in the current volume
1707   //
1708   return (fGctrak->inwvol==1);
1709 }
1710
1711 //_____________________________________________________________________________
1712 Bool_t TGeant3::IsTrackExiting() const
1713 {
1714   //
1715   // True if this is the last step of the track in the current volume
1716   //
1717   return (fGctrak->inwvol==2);
1718 }
1719
1720 //_____________________________________________________________________________
1721 Bool_t TGeant3::IsTrackOut() const
1722 {
1723   //
1724   // True if the track is out of the setup
1725   //
1726   return (fGctrak->inwvol==3);
1727 }
1728
1729 //_____________________________________________________________________________
1730 Bool_t TGeant3::IsTrackStop() const
1731 {
1732   //
1733   // True if the track energy has fallen below the threshold 
1734   //
1735   return (fGctrak->istop==2);
1736 }
1737
1738 //_____________________________________________________________________________
1739 Int_t   TGeant3::NSecondaries() const
1740 {
1741   //
1742   // Number of secondary particles generated in the current step
1743   //
1744   return fGcking->ngkine;
1745 }
1746
1747 //_____________________________________________________________________________
1748 Int_t   TGeant3::CurrentEvent() const
1749 {
1750   //
1751   // Number of the current event
1752   //
1753   return fGcflag->idevt;
1754 }
1755
1756 //_____________________________________________________________________________
1757 AliMCProcess TGeant3::ProdProcess() const
1758 {
1759   //
1760   // Name of the process that has produced the secondary particles
1761   // in the current step
1762   //
1763   const Int_t kIpMec[13] = { 5,6,7,8,9,10,11,12,21,23,25,105,108 };
1764   const Int_t kIpProc[13] = { kPDecay, kPPair, kPCompton, 
1765                               kPPhotoelectric, kPBrem, kPDeltaRay,
1766                               kPAnnihilation, kPHadronic, 
1767                               kPMuonNuclear, kPPhotoFission,
1768                               kPRayleigh, kPCerenkov, kPSynchrotron};
1769   Int_t km, im;
1770   //
1771   if(fGcking->ngkine>0) 
1772     for (km = 0; km < fGctrak->nmec; ++km) 
1773       for (im = 0; im < 13; ++im) 
1774         if (fGctrak->lmec[km] == kIpMec[im]) 
1775             return (AliMCProcess) kIpProc[im];
1776   //  
1777   return (AliMCProcess) kPNoProcess;
1778 }
1779
1780 //_____________________________________________________________________________
1781 void    TGeant3::GetSecondary(Int_t isec, Int_t& ipart, 
1782                               TLorentzVector &x, TLorentzVector &p)
1783 {
1784   //
1785   // Get the parameters of the secondary track number isec produced
1786   // in the current step
1787   //
1788   Int_t i;
1789   if(-1<isec && isec<fGcking->ngkine) {
1790     ipart=Int_t (fGcking->gkin[isec][4] +0.5);
1791     for(i=0;i<3;i++) {
1792       x[i]=fGckin3->gpos[isec][i];
1793       p[i]=fGcking->gkin[isec][i];
1794     }
1795     x[3]=fGcking->tofd[isec];
1796     p[3]=fGcking->gkin[isec][3];
1797   } else {
1798     printf(" * TGeant3::GetSecondary * Secondary %d does not exist\n",isec);
1799     x[0]=x[1]=x[2]=x[3]=p[0]=p[1]=p[2]=p[3]=0;
1800     ipart=0;
1801   }
1802 }
1803
1804 //_____________________________________________________________________________
1805 void TGeant3::InitLego()
1806 {
1807   //
1808   // Set switches for lego transport
1809   //
1810   SetSWIT(4,0);
1811   SetDEBU(0,0,0);  //do not print a message 
1812 }
1813
1814 //_____________________________________________________________________________
1815 Bool_t TGeant3::IsTrackDisappeared() const
1816 {
1817   //
1818   // True if the current particle has disappered
1819   // either because it decayed or because it underwent
1820   // an inelastic collision
1821   //
1822   return (fGctrak->istop==1);
1823 }
1824
1825 //_____________________________________________________________________________
1826 Bool_t TGeant3::IsTrackAlive() const
1827 {
1828   //
1829   // True if the current particle is alive and will continue to be
1830   // transported
1831   //
1832   return (fGctrak->istop==0);
1833 }
1834
1835 //_____________________________________________________________________________
1836 void TGeant3::StopTrack()
1837 {
1838   //
1839   // Stop the transport of the current particle and skip to the next
1840   //
1841   fGctrak->istop=1;
1842 }
1843
1844 //_____________________________________________________________________________
1845 void TGeant3::StopEvent()
1846 {
1847   //
1848   // Stop simulation of the current event and skip to the next
1849   //
1850   fGcflag->ieotri=1;
1851 }
1852
1853 //_____________________________________________________________________________
1854 Float_t TGeant3::MaxStep() const
1855 {
1856   //
1857   // Return the maximum step length in the current medium
1858   //
1859   return fGctmed->stemax;
1860 }
1861
1862 //_____________________________________________________________________________
1863 void TGeant3::SetMaxStep(Float_t maxstep)
1864 {
1865   //
1866   // Set the maximum step allowed till the particle is in the current medium
1867   //
1868   fGctmed->stemax=maxstep;
1869 }
1870
1871 //_____________________________________________________________________________
1872 void TGeant3::SetMaxNStep(Int_t maxnstp)
1873 {
1874   //
1875   // Set the maximum number of steps till the particle is in the current medium
1876   //
1877   fGctrak->maxnst=maxnstp;
1878 }
1879
1880 //_____________________________________________________________________________
1881 Int_t TGeant3::GetMaxNStep() const
1882 {
1883   //
1884   // Maximum number of steps allowed in current medium
1885   //
1886   return fGctrak->maxnst;
1887 }
1888
1889 //_____________________________________________________________________________
1890 void TGeant3::Material(Int_t& kmat, const char* name, Float_t a, Float_t z,
1891                        Float_t dens, Float_t radl, Float_t absl, Float_t* buf,
1892                        Int_t nwbuf)
1893 {
1894   //
1895   // Defines a Material
1896   // 
1897   //  kmat               number assigned to the material
1898   //  name               material name
1899   //  a                  atomic mass in au
1900   //  z                  atomic number
1901   //  dens               density in g/cm3
1902   //  absl               absorbtion length in cm
1903   //                     if >=0 it is ignored and the program 
1904   //                     calculates it, if <0. -absl is taken
1905   //  radl               radiation length in cm
1906   //                     if >=0 it is ignored and the program 
1907   //                     calculates it, if <0. -radl is taken
1908   //  buf                pointer to an array of user words
1909   //  nbuf               number of user words
1910   //
1911   Int_t jmate=fGclink->jmate;
1912   kmat=1;
1913   Int_t ns, i;
1914   if(jmate>0) {
1915     ns=fZiq[jmate-2];
1916     kmat=ns+1;
1917     for(i=1; i<=ns; i++) {
1918       if(fZlq[jmate-i]==0) {
1919         kmat=i;
1920         break;
1921       }
1922     }
1923   }
1924   gsmate(kmat,PASSCHARD(name), a, z, dens, radl, absl, buf,
1925          nwbuf PASSCHARL(name)); 
1926 }
1927
1928 //_____________________________________________________________________________
1929 void TGeant3::Mixture(Int_t& kmat, const char* name, Float_t* a, Float_t* z, 
1930                       Float_t dens, Int_t nlmat, Float_t* wmat)
1931 {
1932   //
1933   // Defines mixture OR COMPOUND IMAT as composed by 
1934   // THE BASIC NLMAT materials defined by arrays A,Z and WMAT
1935   // 
1936   // If NLMAT > 0 then wmat contains the proportion by
1937   // weights of each basic material in the mixture. 
1938   // 
1939   // If nlmat < 0 then WMAT contains the number of atoms 
1940   // of a given kind into the molecule of the COMPOUND
1941   // In this case, WMAT in output is changed to relative
1942   // weigths.
1943   //
1944   Int_t jmate=fGclink->jmate;
1945   kmat=1;
1946   Int_t ns, i;
1947   if(jmate>0) {
1948     ns=fZiq[jmate-2];
1949     kmat=ns+1;
1950     for(i=1; i<=ns; i++) {
1951       if(fZlq[jmate-i]==0) {
1952         kmat=i;
1953         break;
1954       }
1955     }
1956   }
1957   gsmixt(kmat,PASSCHARD(name), a, z,dens, nlmat,wmat PASSCHARL(name)); 
1958 }
1959
1960 //_____________________________________________________________________________
1961 void TGeant3::Medium(Int_t& kmed, const char* name, Int_t nmat, Int_t isvol,
1962                      Int_t ifield, Float_t fieldm, Float_t tmaxfd,
1963                      Float_t stemax, Float_t deemax, Float_t epsil,
1964                      Float_t stmin, Float_t* ubuf, Int_t nbuf)
1965 {
1966   //
1967   //  kmed      tracking medium number assigned
1968   //  name      tracking medium name
1969   //  nmat      material number
1970   //  isvol     sensitive volume flag
1971   //  ifield    magnetic field
1972   //  fieldm    max. field value (kilogauss)
1973   //  tmaxfd    max. angle due to field (deg/step)
1974   //  stemax    max. step allowed
1975   //  deemax    max. fraction of energy lost in a step
1976   //  epsil     tracking precision (cm)
1977   //  stmin     min. step due to continuos processes (cm)
1978   //
1979   //  ifield = 0 if no magnetic field; ifield = -1 if user decision in guswim;
1980   //  ifield = 1 if tracking performed with grkuta; ifield = 2 if tracking
1981   //  performed with ghelix; ifield = 3 if tracking performed with ghelx3.
1982   //  
1983   Int_t jtmed=fGclink->jtmed;
1984   kmed=1;
1985   Int_t ns, i;
1986   if(jtmed>0) {
1987     ns=fZiq[jtmed-2];
1988     kmed=ns+1;
1989     for(i=1; i<=ns; i++) {
1990       if(fZlq[jtmed-i]==0) {
1991         kmed=i;
1992         break;
1993       }
1994     }
1995   }
1996   gstmed(kmed, PASSCHARD(name), nmat, isvol, ifield, fieldm, tmaxfd, stemax,
1997          deemax, epsil, stmin, ubuf, nbuf PASSCHARL(name)); 
1998 }
1999
2000 //_____________________________________________________________________________
2001 void TGeant3::Matrix(Int_t& krot, Float_t thex, Float_t phix, Float_t they,
2002                      Float_t phiy, Float_t thez, Float_t phiz)
2003 {
2004   //
2005   //  krot     rotation matrix number assigned
2006   //  theta1   polar angle for axis i
2007   //  phi1     azimuthal angle for axis i
2008   //  theta2   polar angle for axis ii
2009   //  phi2     azimuthal angle for axis ii
2010   //  theta3   polar angle for axis iii
2011   //  phi3     azimuthal angle for axis iii
2012   //
2013   //  it defines the rotation matrix number irot.
2014   //  
2015   Int_t jrotm=fGclink->jrotm;
2016   krot=1;
2017   Int_t ns, i;
2018   if(jrotm>0) {
2019     ns=fZiq[jrotm-2];
2020     krot=ns+1;
2021     for(i=1; i<=ns; i++) {
2022       if(fZlq[jrotm-i]==0) {
2023         krot=i;
2024         break;
2025       }
2026     }
2027   }
2028   gsrotm(krot, thex, phix, they, phiy, thez, phiz);
2029 }
2030
2031 //_____________________________________________________________________________
2032 Int_t TGeant3::GetMedium() const
2033 {
2034   //
2035   // Return the number of the current medium
2036   //
2037   return fGctmed->numed;
2038 }
2039
2040 //_____________________________________________________________________________
2041 Float_t TGeant3::Edep() const
2042 {
2043   //
2044   // Return the energy lost in the current step
2045   //
2046   return fGctrak->destep;
2047 }
2048
2049 //_____________________________________________________________________________
2050 Float_t TGeant3::Etot() const
2051 {
2052   //
2053   // Return the total energy of the current track
2054   //
2055   return fGctrak->getot;
2056 }
2057
2058 //*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
2059 //
2060 //                        Functions from GBASE
2061 //
2062 //*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
2063
2064 //____________________________________________________________________________ 
2065 void  TGeant3::Gfile(const char *filename, const char *option) 
2066
2067   //
2068   //    Routine to open a GEANT/RZ data base. 
2069   //
2070   //    LUN logical unit number associated to the file 
2071   //
2072   //    CHFILE RZ file name   
2073   //  
2074   //    CHOPT is a character string which may be  
2075   //        N  To create a new file 
2076   //        U  to open an existing file for update 
2077   //       " " to open an existing file for read only
2078   //        Q  The initial allocation (default 1000 records) 
2079   //           is given in IQUEST(10)
2080   //        X  Open the file in exchange format
2081   //        I  Read all data structures from file to memory 
2082   //        O  Write all data structures from memory to file 
2083   // 
2084   // Note:
2085   //      If options "I"  or "O" all data structures are read or
2086   //         written from/to file and the file is closed. 
2087   //      See routine GRMDIR to create subdirectories  
2088   //      See routines GROUT,GRIN to write,read objects 
2089   //  
2090   grfile(21, PASSCHARD(filename), PASSCHARD(option) PASSCHARL(filename)
2091          PASSCHARL(option)); 
2092
2093  
2094 //____________________________________________________________________________ 
2095 void  TGeant3::Gpcxyz() 
2096
2097   //
2098   //    Print track and volume parameters at current point
2099   //
2100     
2101     gpcxyz(); 
2102
2103 //_____________________________________________________________________________
2104 void  TGeant3::Ggclos() 
2105
2106   //
2107   //   Closes off the geometry setting.
2108   //   Initializes the search list for the contents of each
2109   //   volume following the order they have been positioned, and
2110   //   inserting the content '0' when a call to GSNEXT (-1) has
2111   //   been required by the user.
2112   //   Performs the development of the JVOLUM structure for all 
2113   //   volumes with variable parameters, by calling GGDVLP. 
2114   //   Interprets the user calls to GSORD, through GGORD.
2115   //   Computes and stores in a bank (next to JVOLUM mother bank)
2116   //   the number of levels in the geometrical tree and the
2117   //   maximum number of contents per level, by calling GGNLEV.
2118   //   Sets status bit for CONCAVE volumes, through GGCAVE.
2119   //   Completes the JSET structure with the list of volume names 
2120   //   which identify uniquely a given physical detector, the
2121   //   list of bit numbers to pack the corresponding volume copy 
2122   //   numbers, and the generic path(s) in the JVOLUM tree, 
2123   //   through the routine GHCLOS. 
2124   //
2125   ggclos(); 
2126   // Create internal list of volumes
2127   fVolNames = new char[fGcnum->nvolum+1][5];
2128   Int_t i;
2129   for(i=0; i<fGcnum->nvolum; ++i) {
2130     strncpy(fVolNames[i], (char *) &fZiq[fGclink->jvolum+i+1], 4);
2131     fVolNames[i][4]='\0';
2132   }
2133   strcpy(fVolNames[fGcnum->nvolum],"NULL");
2134
2135  
2136 //_____________________________________________________________________________
2137 void  TGeant3::Glast() 
2138
2139   //
2140   // Finish a Geant run
2141   //
2142   glast(); 
2143
2144  
2145 //_____________________________________________________________________________
2146 void  TGeant3::Gprint(const char *name) 
2147
2148   //
2149   // Routine to print data structures
2150   // CHNAME   name of a data structure
2151   // 
2152   char vname[5];
2153   Vname(name,vname);
2154   gprint(PASSCHARD(vname),0 PASSCHARL(vname)); 
2155
2156
2157 //_____________________________________________________________________________
2158 void  TGeant3::Grun() 
2159
2160   //
2161   // Steering function to process one run
2162   //
2163   grun(); 
2164
2165  
2166 //_____________________________________________________________________________
2167 void  TGeant3::Gtrig() 
2168
2169   //
2170   // Steering function to process one event
2171   //  
2172   gtrig(); 
2173
2174  
2175 //_____________________________________________________________________________
2176 void  TGeant3::Gtrigc() 
2177
2178   //
2179   // Clear event partition
2180   //
2181   gtrigc(); 
2182
2183  
2184 //_____________________________________________________________________________
2185 void  TGeant3::Gtrigi() 
2186
2187   //
2188   // Initialises event partition
2189   //
2190   gtrigi(); 
2191
2192  
2193 //_____________________________________________________________________________
2194 void  TGeant3::Gwork(Int_t nwork) 
2195
2196   //
2197   // Allocates workspace in ZEBRA memory
2198   //
2199   gwork(nwork); 
2200
2201  
2202 //_____________________________________________________________________________
2203 void  TGeant3::Gzinit() 
2204
2205   //
2206   // To initialise GEANT/ZEBRA data structures
2207   //
2208   gzinit(); 
2209
2210  
2211 //*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
2212 //
2213 //                        Functions from GCONS
2214 //
2215 //*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
2216  
2217 //_____________________________________________________________________________
2218 void  TGeant3::Gfmate(Int_t imat, char *name, Float_t &a, Float_t &z,  
2219                       Float_t &dens, Float_t &radl, Float_t &absl,
2220                       Float_t* ubuf, Int_t& nbuf) 
2221
2222   //
2223   // Return parameters for material IMAT 
2224   //
2225   gfmate(imat, PASSCHARD(name), a, z, dens, radl, absl, ubuf, nbuf
2226          PASSCHARL(name)); 
2227
2228  
2229 //_____________________________________________________________________________
2230 void  TGeant3::Gfpart(Int_t ipart, char *name, Int_t &itrtyp,  
2231                    Float_t &amass, Float_t &charge, Float_t &tlife) 
2232
2233   //
2234   // Return parameters for particle of type IPART
2235   //
2236   Float_t *ubuf=0; 
2237   Int_t   nbuf; 
2238   Int_t igpart = IdFromPDG(ipart);
2239   gfpart(igpart, PASSCHARD(name), itrtyp, amass, charge, tlife, ubuf, nbuf
2240          PASSCHARL(name)); 
2241
2242  
2243 //_____________________________________________________________________________
2244 void  TGeant3::Gftmed(Int_t numed, char *name, Int_t &nmat, Int_t &isvol,  
2245                    Int_t &ifield, Float_t &fieldm, Float_t &tmaxfd, 
2246                     Float_t &stemax, Float_t &deemax, Float_t &epsil, 
2247                     Float_t &stmin, Float_t *ubuf, Int_t *nbuf) 
2248
2249   //
2250   // Return parameters for tracking medium NUMED
2251   //
2252   gftmed(numed, PASSCHARD(name), nmat, isvol, ifield, fieldm, tmaxfd, stemax,  
2253          deemax, epsil, stmin, ubuf, nbuf PASSCHARL(name)); 
2254 }
2255
2256  
2257  void  TGeant3::Gftmat(Int_t imate, Int_t ipart, char *chmeca, Int_t kdim,
2258                       Float_t* tkin, Float_t* value, Float_t* pcut,
2259                       Int_t &ixst)
2260
2261   //
2262   // Return parameters for tracking medium NUMED
2263   //
2264   gftmat(imate, ipart, PASSCHARD(chmeca), kdim,
2265          tkin, value, pcut, ixst PASSCHARL(chmeca));
2266
2267
2268
2269 //_____________________________________________________________________________
2270 Float_t TGeant3::Gbrelm(Float_t z, Float_t t, Float_t bcut)
2271 {
2272   //
2273   // To calculate energy loss due to soft muon BREMSSTRAHLUNG
2274   //
2275   return gbrelm(z,t,bcut);
2276 }
2277
2278 //_____________________________________________________________________________
2279 Float_t TGeant3::Gprelm(Float_t z, Float_t t, Float_t bcut)
2280 {
2281   //
2282   // To calculate DE/DX in GeV*barn/atom for direct pair production by muons
2283   //
2284   return gprelm(z,t,bcut);
2285 }
2286  
2287 //_____________________________________________________________________________
2288 void  TGeant3::Gmate() 
2289
2290   //
2291   // Define standard GEANT materials
2292   //
2293   gmate(); 
2294
2295  
2296 //_____________________________________________________________________________
2297 void  TGeant3::Gpart() 
2298
2299   //
2300   //  Define standard GEANT particles plus selected decay modes
2301   //  and branching ratios.
2302   //
2303   gpart(); 
2304
2305  
2306 //_____________________________________________________________________________
2307 void  TGeant3::Gsdk(Int_t ipart, Float_t *bratio, Int_t *mode) 
2308
2309 //  Defines branching ratios and decay modes for standard
2310 //  GEANT particles.
2311    gsdk(ipart,bratio,mode); 
2312
2313  
2314 //_____________________________________________________________________________
2315 void  TGeant3::Gsmate(Int_t imat, const char *name, Float_t a, Float_t z,  
2316                    Float_t dens, Float_t radl, Float_t absl) 
2317
2318   //
2319   // Defines a Material
2320   // 
2321   //  kmat               number assigned to the material
2322   //  name               material name
2323   //  a                  atomic mass in au
2324   //  z                  atomic number
2325   //  dens               density in g/cm3
2326   //  absl               absorbtion length in cm
2327   //                     if >=0 it is ignored and the program 
2328   //                     calculates it, if <0. -absl is taken
2329   //  radl               radiation length in cm
2330   //                     if >=0 it is ignored and the program 
2331   //                     calculates it, if <0. -radl is taken
2332   //  buf                pointer to an array of user words
2333   //  nbuf               number of user words
2334   //
2335   Float_t *ubuf=0; 
2336   Int_t   nbuf=0; 
2337   gsmate(imat,PASSCHARD(name), a, z, dens, radl, absl, ubuf, nbuf
2338          PASSCHARL(name)); 
2339
2340  
2341 //_____________________________________________________________________________
2342 void  TGeant3::Gsmixt(Int_t imat, const char *name, Float_t *a, Float_t *z,  
2343                    Float_t dens, Int_t nlmat, Float_t *wmat) 
2344
2345   //
2346   //       Defines mixture OR COMPOUND IMAT as composed by 
2347   //       THE BASIC NLMAT materials defined by arrays A,Z and WMAT
2348   // 
2349   //       If NLMAT.GT.0 then WMAT contains the PROPORTION BY
2350   //       WEIGTHS OF EACH BASIC MATERIAL IN THE MIXTURE. 
2351   // 
2352   //       If NLMAT.LT.0 then WMAT contains the number of atoms 
2353   //       of a given kind into the molecule of the COMPOUND
2354   //       In this case, WMAT in output is changed to relative
2355   //       weigths.
2356   //
2357   gsmixt(imat,PASSCHARD(name), a, z,dens, nlmat,wmat PASSCHARL(name)); 
2358
2359  
2360 //_____________________________________________________________________________
2361 void  TGeant3::Gspart(Int_t ipart, const char *name, Int_t itrtyp,  
2362                    Float_t amass, Float_t charge, Float_t tlife) 
2363
2364   //
2365   // Store particle parameters
2366   //
2367   // ipart           particle code
2368   // name            particle name
2369   // itrtyp          transport method (see GEANT manual)
2370   // amass           mass in GeV/c2
2371   // charge          charge in electron units
2372   // tlife           lifetime in seconds
2373   //
2374   Float_t *ubuf=0; 
2375   Int_t   nbuf=0; 
2376   gspart(ipart,PASSCHARD(name), itrtyp, amass, charge, tlife, ubuf, nbuf
2377          PASSCHARL(name)); 
2378
2379  
2380 //_____________________________________________________________________________
2381 void  TGeant3::Gstmed(Int_t numed, const char *name, Int_t nmat, Int_t isvol,  
2382                       Int_t ifield, Float_t fieldm, Float_t tmaxfd,
2383                       Float_t stemax, Float_t deemax, Float_t epsil,
2384                       Float_t stmin) 
2385
2386   //
2387   //  NTMED  Tracking medium number
2388   //  NAME   Tracking medium name
2389   //  NMAT   Material number
2390   //  ISVOL  Sensitive volume flag
2391   //  IFIELD Magnetic field
2392   //  FIELDM Max. field value (Kilogauss)
2393   //  TMAXFD Max. angle due to field (deg/step)
2394   //  STEMAX Max. step allowed
2395   //  DEEMAX Max. fraction of energy lost in a step
2396   //  EPSIL  Tracking precision (cm)
2397   //  STMIN  Min. step due to continuos processes (cm)
2398   //
2399   //  IFIELD = 0 if no magnetic field; IFIELD = -1 if user decision in GUSWIM;
2400   //  IFIELD = 1 if tracking performed with GRKUTA; IFIELD = 2 if tracking
2401   //  performed with GHELIX; IFIELD = 3 if tracking performed with GHELX3.
2402   //  
2403   Float_t *ubuf=0; 
2404   Int_t   nbuf=0; 
2405   gstmed(numed,PASSCHARD(name), nmat, isvol, ifield, fieldm, tmaxfd, stemax,
2406          deemax, epsil, stmin, ubuf, nbuf PASSCHARL(name)); 
2407
2408  
2409 //_____________________________________________________________________________
2410 void  TGeant3::Gsckov(Int_t itmed, Int_t npckov, Float_t *ppckov,
2411                       Float_t *absco, Float_t *effic, Float_t *rindex)
2412
2413   //
2414   //    Stores the tables for UV photon tracking in medium ITMED 
2415   //    Please note that it is the user's responsability to 
2416   //    provide all the coefficients:
2417   //
2418   //
2419   //       ITMED       Tracking medium number
2420   //       NPCKOV      Number of bins of each table
2421   //       PPCKOV      Value of photon momentum (in GeV)
2422   //       ABSCO       Absorbtion coefficients 
2423   //                   dielectric: absorbtion length in cm
2424   //                   metals    : absorbtion fraction (0<=x<=1)
2425   //       EFFIC       Detection efficiency for UV photons 
2426   //       RINDEX      Refraction index (if=0 metal)
2427   //
2428   gsckov(itmed,npckov,ppckov,absco,effic,rindex);
2429 }
2430
2431 //_____________________________________________________________________________
2432 void  TGeant3::Gstpar(Int_t itmed, const char *param, Float_t parval) 
2433
2434   //
2435   //  To change the value of cut  or mechanism "CHPAR"
2436   //      to a new value PARVAL  for tracking medium ITMED
2437   //    The  data   structure  JTMED   contains  the   standard  tracking
2438   //  parameters (CUTS and flags to control the physics processes)  which
2439   //  are used  by default  for all  tracking media.   It is  possible to
2440   //  redefine individually  with GSTPAR  any of  these parameters  for a
2441   //  given tracking medium. 
2442   //  ITMED     tracking medium number 
2443   //  CHPAR     is a character string (variable name) 
2444   //  PARVAL    must be given as a floating point.
2445   //
2446   gstpar(itmed,PASSCHARD(param), parval PASSCHARL(param)); 
2447
2448  
2449 //*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
2450 //
2451 //                        Functions from GCONS
2452 //
2453 //*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
2454  
2455 //_____________________________________________________________________________
2456 void  TGeant3::Gfkine(Int_t itra, Float_t *vert, Float_t *pvert, Int_t &ipart,
2457                       Int_t &nvert) 
2458
2459   //           Storing/Retrieving Vertex and Track parameters
2460   //           ---------------------------------------------- 
2461   //
2462   //  Stores vertex parameters. 
2463   //  VERT      array of (x,y,z) position of the vertex 
2464   //  NTBEAM    beam track number origin of the vertex 
2465   //            =0 if none exists  
2466   //  NTTARG    target track number origin of the vertex
2467   //  UBUF      user array of NUBUF floating point numbers
2468   //  NUBUF       
2469   //  NVTX      new vertex number (=0 in case of error). 
2470   //  Prints vertex parameters.
2471   //  IVTX      for vertex IVTX.
2472   //            (For all vertices if IVTX=0) 
2473   //  Stores long life track parameters.
2474   //  PLAB      components of momentum 
2475   //  IPART     type of particle (see GSPART)
2476   //  NV        vertex number origin of track
2477   //  UBUF      array of NUBUF floating point user parameters 
2478   //  NUBUF
2479   //  NT        track number (if=0 error).
2480   //  Retrieves long life track parameters.
2481   //  ITRA      track number for which parameters are requested
2482   //  VERT      vector origin of the track  
2483   //  PVERT     4 momentum components at the track origin 
2484   //  IPART     particle type (=0 if track ITRA does not exist)
2485   //  NVERT     vertex number origin of the track 
2486   //  UBUF      user words stored in GSKINE. 
2487   //  Prints initial track parameters. 
2488   //  ITRA      for track ITRA 
2489   //            (For all tracks if ITRA=0) 
2490   //
2491   Float_t *ubuf=0; 
2492   Int_t   nbuf; 
2493   gfkine(itra,vert,pvert,ipart,nvert,ubuf,nbuf); 
2494
2495
2496 //_____________________________________________________________________________
2497 void  TGeant3::Gfvert(Int_t nvtx, Float_t *v, Int_t &ntbeam, Int_t &nttarg,
2498                       Float_t &tofg) 
2499
2500   //
2501   //       Retrieves the parameter of a vertex bank
2502   //       Vertex is generated from tracks NTBEAM NTTARG
2503   //       NVTX is the new vertex number 
2504   //
2505   Float_t *ubuf=0; 
2506   Int_t   nbuf; 
2507   gfvert(nvtx,v,ntbeam,nttarg,tofg,ubuf,nbuf); 
2508
2509  
2510 //_____________________________________________________________________________
2511 Int_t TGeant3::Gskine(Float_t *plab, Int_t ipart, Int_t nv, Float_t *buf,
2512                       Int_t nwbuf) 
2513
2514   //
2515   //       Store kinematics of track NT into data structure
2516   //       Track is coming from vertex NV
2517   //
2518   Int_t nt = 0; 
2519   gskine(plab, ipart, nv, buf, nwbuf, nt); 
2520   return nt; 
2521
2522  
2523 //_____________________________________________________________________________
2524 Int_t TGeant3::Gsvert(Float_t *v, Int_t ntbeam, Int_t nttarg, Float_t *ubuf,
2525                       Int_t nwbuf) 
2526
2527   //
2528   //       Creates a new vertex bank 
2529   //       Vertex is generated from tracks NTBEAM NTTARG 
2530   //       NVTX is the new vertex number
2531   //
2532   Int_t nwtx = 0; 
2533   gsvert(v, ntbeam, nttarg, ubuf, nwbuf, nwtx); 
2534   return nwtx; 
2535
2536  
2537 //*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
2538 //
2539 //                        Functions from GPHYS
2540 //
2541 //*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
2542
2543 //_____________________________________________________________________________
2544 void  TGeant3::Gphysi() 
2545
2546   //
2547   //       Initialise material constants for all the physics
2548   //       mechanisms used by GEANT
2549   //
2550   gphysi(); 
2551
2552  
2553 //*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
2554 //
2555 //                        Functions from GTRAK
2556 //
2557 //*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
2558  
2559 //_____________________________________________________________________________
2560 void  TGeant3::Gdebug() 
2561
2562   //
2563   // Debug the current step
2564   //
2565   gdebug(); 
2566
2567  
2568 //_____________________________________________________________________________
2569 void  TGeant3::Gekbin() 
2570
2571   //
2572   //       To find bin number in kinetic energy table
2573   //       stored in ELOW(NEKBIN)
2574   //
2575   gekbin(); 
2576
2577  
2578 //_____________________________________________________________________________
2579 void  TGeant3::Gfinds() 
2580
2581   //
2582   //       Returns the set/volume parameters corresponding to 
2583   //       the current space point in /GCTRAK/
2584   //       and fill common /GCSETS/
2585   // 
2586   //       IHSET  user set identifier 
2587   //       IHDET  user detector identifier 
2588   //       ISET set number in JSET  
2589   //       IDET   detector number in JS=LQ(JSET-ISET) 
2590   //       IDTYPE detector type (1,2)  
2591   //       NUMBV  detector volume numbers (array of length NVNAME)
2592   //       NVNAME number of volume levels
2593   //
2594   gfinds(); 
2595
2596  
2597 //_____________________________________________________________________________
2598 void  TGeant3::Gsking(Int_t igk) 
2599
2600   //
2601   //   Stores in stack JSTAK either the IGKth track of /GCKING/,
2602   //    or the NGKINE tracks when IGK is 0.
2603   //
2604   gsking(igk); 
2605
2606  
2607 //_____________________________________________________________________________
2608 void  TGeant3::Gskpho(Int_t igk) 
2609
2610   //
2611   //  Stores in stack JSTAK either the IGKth Cherenkov photon of  
2612   //  /GCKIN2/, or the NPHOT tracks when IGK is 0.                
2613   //
2614   gskpho(igk); 
2615
2616  
2617 //_____________________________________________________________________________
2618 void  TGeant3::Gsstak(Int_t iflag) 
2619
2620   //
2621   //   Stores in auxiliary stack JSTAK the particle currently 
2622   //    described in common /GCKINE/. 
2623   // 
2624   //   On request, creates also an entry in structure JKINE :
2625   //    IFLAG =
2626   //     0 : No entry in JKINE structure required (user) 
2627   //     1 : New entry in JVERTX / JKINE structures required (user)
2628   //    <0 : New entry in JKINE structure at vertex -IFLAG (user)
2629   //     2 : Entry in JKINE structure exists already (from GTREVE)
2630   //
2631   gsstak(iflag); 
2632
2633  
2634 //_____________________________________________________________________________
2635 void  TGeant3::Gsxyz() 
2636
2637   //
2638   //   Store space point VECT in banks JXYZ 
2639   //
2640   gsxyz(); 
2641
2642  
2643 //_____________________________________________________________________________
2644 void  TGeant3::Gtrack() 
2645
2646   //
2647   //   Controls tracking of current particle 
2648   //
2649   gtrack(); 
2650
2651  
2652 //_____________________________________________________________________________
2653 void  TGeant3::Gtreve() 
2654
2655   //
2656   //   Controls tracking of all particles belonging to the current event
2657   //
2658   gtreve(); 
2659
2660
2661 //_____________________________________________________________________________
2662 void  TGeant3::GtreveRoot() 
2663
2664   //
2665   //   Controls tracking of all particles belonging to the current event
2666   //
2667   gtreveroot(); 
2668
2669
2670 //_____________________________________________________________________________
2671 void  TGeant3::Grndm(Float_t *rvec, const Int_t len) const
2672 {
2673   //
2674   //   To generate a vector RVECV of LEN random numbers 
2675   //   Copy of the CERN Library routine RANECU 
2676   Rndm(rvec,len);
2677 }
2678
2679 //_____________________________________________________________________________
2680 void  TGeant3::Grndmq(Int_t &/*is1*/, Int_t &/*is2*/, const Int_t /*iseq*/,
2681                       const Text_t */*chopt*/)
2682 {
2683   //
2684   //  To set/retrieve the seed of the random number generator
2685   //
2686   /*printf("Dummy grndmq called\n");*/
2687 }
2688
2689 //*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
2690 //
2691 //                        Functions from GDRAW
2692 //
2693 //*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
2694
2695 //_____________________________________________________________________________
2696 void  TGeant3::Gdxyz(Int_t it)
2697 {
2698   //
2699   // Draw the points stored with Gsxyz relative to track it
2700   //
2701   gdxyz(it);
2702 }
2703
2704 //_____________________________________________________________________________
2705 void  TGeant3::Gdcxyz()
2706 {
2707   //
2708   // Draw the position of the current track
2709   //
2710   gdcxyz();
2711 }
2712
2713 //*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
2714 //
2715 //                        Functions from GGEOM
2716 //
2717 //*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
2718
2719 //_____________________________________________________________________________
2720 void  TGeant3::Gdtom(Float_t *xd, Float_t *xm, Int_t iflag) 
2721
2722   //
2723   //  Computes coordinates XM (Master Reference System
2724   //  knowing the coordinates XD (Detector Ref System)
2725   //  The local reference system can be initialized by
2726   //    - the tracking routines and GDTOM used in GUSTEP
2727   //    - a call to GSCMED(NLEVEL,NAMES,NUMBER)
2728   //        (inverse routine is GMTOD)
2729   // 
2730   //   If IFLAG=1  convert coordinates
2731   //      IFLAG=2  convert direction cosinus
2732   //
2733   gdtom(xd, xm, iflag); 
2734
2735  
2736 //_____________________________________________________________________________
2737 void  TGeant3::Glmoth(const char* iudet, Int_t iunum, Int_t &nlev, Int_t *lvols,
2738                       Int_t *lindx) 
2739
2740   //
2741   //   Loads the top part of the Volume tree in LVOLS (IVO's),
2742   //   LINDX (IN indices) for a given volume defined through
2743   //   its name IUDET and number IUNUM.
2744   // 
2745   //   The routine stores only upto the last level where JVOLUM
2746   //   data structure is developed. If there is no development
2747   //   above the current level, it returns NLEV zero.
2748   Int_t *idum=0; 
2749   glmoth(PASSCHARD(iudet), iunum, nlev, lvols, lindx, idum PASSCHARL(iudet)); 
2750
2751
2752 //_____________________________________________________________________________
2753 void  TGeant3::Gmedia(Float_t *x, Int_t &numed) 
2754
2755   //
2756   //   Finds in which volume/medium the point X is, and updates the
2757   //    common /GCVOLU/ and the structure JGPAR accordingly. 
2758   // 
2759   //   NUMED returns the tracking medium number, or 0 if point is
2760   //         outside the experimental setup.
2761   //
2762   gmedia(x,numed); 
2763
2764  
2765 //_____________________________________________________________________________
2766 void  TGeant3::Gmtod(Float_t *xm, Float_t *xd, Int_t iflag) 
2767
2768   //
2769   //       Computes coordinates XD (in DRS) 
2770   //       from known coordinates XM in MRS 
2771   //       The local reference system can be initialized by
2772   //         - the tracking routines and GMTOD used in GUSTEP
2773   //         - a call to GMEDIA(XM,NUMED)
2774   //         - a call to GLVOLU(NLEVEL,NAMES,NUMBER,IER) 
2775   //             (inverse routine is GDTOM) 
2776   //
2777   //        If IFLAG=1  convert coordinates 
2778   //           IFLAG=2  convert direction cosinus
2779   //
2780   gmtod(xm, xd, iflag); 
2781
2782  
2783 //_____________________________________________________________________________
2784 void  TGeant3::Gsdvn(const char *name, const char *mother, Int_t ndiv,
2785                      Int_t iaxis) 
2786
2787   //
2788   // Create a new volume by dividing an existing one
2789   // 
2790   //  NAME   Volume name
2791   //  MOTHER Mother volume name
2792   //  NDIV   Number of divisions
2793   //  IAXIS  Axis value
2794   //
2795   //  X,Y,Z of CAXIS will be translated to 1,2,3 for IAXIS.
2796   //  It divides a previously defined volume.
2797   //  
2798   char vname[5];
2799   Vname(name,vname);
2800   char vmother[5];
2801   Vname(mother,vmother);
2802   gsdvn(PASSCHARD(vname), PASSCHARD(vmother), ndiv, iaxis PASSCHARL(vname)
2803         PASSCHARL(vmother)); 
2804
2805  
2806 //_____________________________________________________________________________
2807 void  TGeant3::Gsdvn2(const char *name, const char *mother, Int_t ndiv,
2808                       Int_t iaxis, Float_t c0i, Int_t numed) 
2809
2810   //
2811   // Create a new volume by dividing an existing one
2812   // 
2813   // Divides mother into ndiv divisions called name
2814   // along axis iaxis starting at coordinate value c0.
2815   // the new volume created will be medium number numed.
2816   //
2817   char vname[5];
2818   Vname(name,vname);
2819   char vmother[5];
2820   Vname(mother,vmother);
2821   gsdvn2(PASSCHARD(vname), PASSCHARD(vmother), ndiv, iaxis, c0i, numed
2822          PASSCHARL(vname) PASSCHARL(vmother)); 
2823
2824  
2825 //_____________________________________________________________________________
2826 void  TGeant3::Gsdvs(const char *name, const char *mother, Float_t step,
2827                      Int_t iaxis, Int_t numed) 
2828
2829   //
2830   // Create a new volume by dividing an existing one
2831   // 
2832   char vname[5];
2833   Vname(name,vname);
2834   char vmother[5];
2835   Vname(mother,vmother);
2836   gsdvs(PASSCHARD(vname), PASSCHARD(vmother), step, iaxis, numed
2837         PASSCHARL(vname) PASSCHARL(vmother)); 
2838
2839  
2840 //_____________________________________________________________________________
2841 void  TGeant3::Gsdvs2(const char *name, const char *mother, Float_t step,
2842                       Int_t iaxis, Float_t c0, Int_t numed) 
2843
2844   //
2845   // Create a new volume by dividing an existing one
2846   // 
2847   char vname[5];
2848   Vname(name,vname);
2849   char vmother[5];
2850   Vname(mother,vmother);
2851   gsdvs2(PASSCHARD(vname), PASSCHARD(vmother), step, iaxis, c0, numed
2852          PASSCHARL(vname) PASSCHARL(vmother)); 
2853
2854  
2855 //_____________________________________________________________________________
2856 void  TGeant3::Gsdvt(const char *name, const char *mother, Float_t step,
2857                      Int_t iaxis, Int_t numed, Int_t ndvmx) 
2858
2859   //
2860   // Create a new volume by dividing an existing one
2861   // 
2862   //       Divides MOTHER into divisions called NAME along
2863   //       axis IAXIS in steps of STEP. If not exactly divisible 
2864   //       will make as many as possible and will centre them 
2865   //       with respect to the mother. Divisions will have medium 
2866   //       number NUMED. If NUMED is 0, NUMED of MOTHER is taken.
2867   //       NDVMX is the expected maximum number of divisions
2868   //          (If 0, no protection tests are performed) 
2869   //
2870   char vname[5];
2871   Vname(name,vname);
2872   char vmother[5];
2873   Vname(mother,vmother);
2874   gsdvt(PASSCHARD(vname), PASSCHARD(vmother), step, iaxis, numed, ndvmx
2875         PASSCHARL(vname) PASSCHARL(vmother)); 
2876
2877
2878 //_____________________________________________________________________________
2879 void  TGeant3::Gsdvt2(const char *name, const char *mother, Float_t step,
2880                       Int_t iaxis, Float_t c0, Int_t numed, Int_t ndvmx) 
2881
2882   //
2883   // Create a new volume by dividing an existing one
2884   //                                                                    
2885   //           Divides MOTHER into divisions called NAME along          
2886   //            axis IAXIS starting at coordinate value C0 with step    
2887   //            size STEP.                                              
2888   //           The new volume created will have medium number NUMED.    
2889   //           If NUMED is 0, NUMED of mother is taken.                 
2890   //           NDVMX is the expected maximum number of divisions        
2891   //             (If 0, no protection tests are performed)              
2892   //
2893   char vname[5];
2894   Vname(name,vname);
2895   char vmother[5];
2896   Vname(mother,vmother);
2897   gsdvt2(PASSCHARD(vname), PASSCHARD(vmother), step, iaxis, c0,
2898          numed, ndvmx PASSCHARL(vname) PASSCHARL(vmother)); 
2899
2900
2901 //_____________________________________________________________________________
2902 void  TGeant3::Gsord(const char *name, Int_t iax) 
2903
2904   //
2905   //    Flags volume CHNAME whose contents will have to be ordered 
2906   //    along axis IAX, by setting the search flag to -IAX
2907   //           IAX = 1    X axis 
2908   //           IAX = 2    Y axis 
2909   //           IAX = 3    Z axis 
2910   //           IAX = 4    Rxy (static ordering only  -> GTMEDI)
2911   //           IAX = 14   Rxy (also dynamic ordering -> GTNEXT)
2912   //           IAX = 5    Rxyz (static ordering only -> GTMEDI)
2913   //           IAX = 15   Rxyz (also dynamic ordering -> GTNEXT)
2914   //           IAX = 6    PHI   (PHI=0 => X axis)
2915   //           IAX = 7    THETA (THETA=0 => Z axis)
2916   //
2917   char vname[5];
2918   Vname(name,vname);
2919   gsord(PASSCHARD(vname), iax PASSCHARL(vname)); 
2920
2921  
2922 //_____________________________________________________________________________
2923 void  TGeant3::Gspos(const char *name, Int_t nr, const char *mother, Float_t x,
2924                      Float_t y, Float_t z, Int_t irot, const char *konly) 
2925
2926   //
2927   // Position a volume into an existing one
2928   //
2929   //  NAME   Volume name
2930   //  NUMBER Copy number of the volume
2931   //  MOTHER Mother volume name
2932   //  X      X coord. of the volume in mother ref. sys.
2933   //  Y      Y coord. of the volume in mother ref. sys.
2934   //  Z      Z coord. of the volume in mother ref. sys.
2935   //  IROT   Rotation matrix number w.r.t. mother ref. sys.
2936   //  ONLY   ONLY/MANY flag
2937   //
2938   //  It positions a previously defined volume in the mother.
2939   //  
2940     
2941   char vname[5];
2942   Vname(name,vname);
2943   char vmother[5];
2944   Vname(mother,vmother);
2945   gspos(PASSCHARD(vname), nr, PASSCHARD(vmother), x, y, z, irot,
2946         PASSCHARD(konly) PASSCHARL(vname) PASSCHARL(vmother)
2947         PASSCHARL(konly)); 
2948
2949  
2950 //_____________________________________________________________________________
2951 void  TGeant3::Gsposp(const char *name, Int_t nr, const char *mother,  
2952                    Float_t x, Float_t y, Float_t z, Int_t irot,
2953                       const char *konly, Float_t *upar, Int_t np ) 
2954
2955   //
2956   //      Place a copy of generic volume NAME with user number
2957   //      NR inside MOTHER, with its parameters UPAR(1..NP)
2958   //
2959   char vname[5];
2960   Vname(name,vname);
2961   char vmother[5];
2962   Vname(mother,vmother);
2963   gsposp(PASSCHARD(vname), nr, PASSCHARD(vmother), x, y, z, irot,
2964          PASSCHARD(konly), upar, np PASSCHARL(vname) PASSCHARL(vmother)
2965          PASSCHARL(konly)); 
2966
2967  
2968 //_____________________________________________________________________________
2969 void  TGeant3::Gsrotm(Int_t nmat, Float_t theta1, Float_t phi1, Float_t theta2,
2970                       Float_t phi2, Float_t theta3, Float_t phi3) 
2971
2972   //
2973   //  nmat   Rotation matrix number
2974   //  THETA1 Polar angle for axis I
2975   //  PHI1   Azimuthal angle for axis I
2976   //  THETA2 Polar angle for axis II
2977   //  PHI2   Azimuthal angle for axis II
2978   //  THETA3 Polar angle for axis III
2979   //  PHI3   Azimuthal angle for axis III
2980   //
2981   //  It defines the rotation matrix number IROT.
2982   //  
2983   gsrotm(nmat, theta1, phi1, theta2, phi2, theta3, phi3); 
2984
2985  
2986 //_____________________________________________________________________________
2987 void  TGeant3::Gprotm(Int_t nmat) 
2988
2989   //
2990   //    To print rotation matrices structure JROTM
2991   //     nmat     Rotation matrix number
2992   //
2993   gprotm(nmat); 
2994
2995  
2996 //_____________________________________________________________________________
2997 Int_t TGeant3::Gsvolu(const char *name, const char *shape, Int_t nmed,  
2998                       Float_t *upar, Int_t npar) 
2999
3000   //
3001   //  NAME   Volume name
3002   //  SHAPE  Volume type
3003   //  NUMED  Tracking medium number
3004   //  NPAR   Number of shape parameters
3005   //  UPAR   Vector containing shape parameters
3006   //
3007   //  It creates a new volume in the JVOLUM data structure.
3008   //  
3009   Int_t ivolu = 0; 
3010   char vname[5];
3011   Vname(name,vname);
3012   char vshape[5];
3013   Vname(shape,vshape);
3014   gsvolu(PASSCHARD(vname), PASSCHARD(vshape), nmed, upar, npar, ivolu
3015          PASSCHARL(vname) PASSCHARL(vshape)); 
3016   return ivolu; 
3017
3018  
3019 //*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
3020 //
3021 //           T H E    D R A W I N G   P A C K A G E
3022 //           ======================================
3023 //  Drawing functions. These functions allow the visualization in several ways
3024 //  of the volumes defined in the geometrical data structure. It is possible
3025 //  to draw the logical tree of volumes belonging to the detector (DTREE),
3026 //  to show their geometrical specification (DSPEC,DFSPC), to draw them
3027 //  and their cut views (DRAW, DCUT). Moreover, it is possible to execute
3028 //  these commands when the hidden line removal option is activated; in
3029 //  this case, the volumes can be also either translated in the space
3030 //  (SHIFT), or clipped by boolean operation (CVOL). In addition, it is
3031 //  possible to fill the surfaces of the volumes
3032 //  with solid colours when the shading option (SHAD) is activated.
3033 //  Several tools (ZOOM, LENS) have been developed to zoom detailed parts
3034 //  of the detectors or to scan physical events as well.
3035 //  Finally, the command MOVE will allow the rotation, translation and zooming
3036 //  on real time parts of the detectors or tracks and hits of a simulated event.
3037 //  Ray-tracing commands. In case the command (DOPT RAYT ON) is executed,
3038 //  the drawing is performed by the Geant ray-tracing;
3039 //  automatically, the color is assigned according to the tracking medium of each
3040 //  volume and the volumes with a density lower/equal than the air are considered
3041 //  transparent; if the option (USER) is set (ON) (again via the command (DOPT)),
3042 //  the user can set color and visibility for the desired volumes via the command
3043 //  (SATT), as usual, relatively to the attributes (COLO) and (SEEN).
3044 //  The resolution can be set via the command (SATT * FILL VALUE), where (VALUE)
3045 //  is the ratio between the number of pixels drawn and 20 (user coordinates).
3046 //  Parallel view and perspective view are possible (DOPT PROJ PARA/PERS); in the
3047 //  first case, we assume that the first mother volume of the tree is a box with
3048 //  dimensions 10000 X 10000 X 10000 cm and the view point (infinetely far) is
3049 //  5000 cm far from the origin along the Z axis of the user coordinates; in the
3050 //  second case, the distance between the observer and the origin of the world
3051 //  reference system is set in cm by the command (PERSP NAME VALUE); grand-angle
3052 //  or telescopic effects can be achieved changing the scale factors in the command
3053 //  (DRAW). When the final picture does not occupy the full window,
3054 //  mapping the space before tracing can speed up the drawing, but can also
3055 //  produce less precise results; values from 1 to 4 are allowed in the command
3056 //  (DOPT MAPP VALUE), the mapping being more precise for increasing (VALUE); for
3057 //  (VALUE = 0) no mapping is performed (therefore max precision and lowest speed).
3058 //  The command (VALCUT) allows the cutting of the detector by three planes
3059 //  ortogonal to the x,y,z axis. The attribute (LSTY) can be set by the command
3060 //  SATT for any desired volume and can assume values from 0 to 7; it determines
3061 //  the different light processing to be performed for different materials:
3062 //  0 = dark-matt, 1 = bright-matt, 2 = plastic, 3 = ceramic, 4 = rough-metals,
3063 //  5 = shiny-metals, 6 = glass, 7 = mirror. The detector is assumed to be in the
3064 //  dark, the ambient light luminosity is 0.2 for each basic hue (the saturation
3065 //  is 0.9) and the observer is assumed to have a light source (therefore he will
3066 //  produce parallel light in the case of parallel view and point-like-source
3067 //  light in the case of perspective view).
3068 //
3069 //*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
3070
3071 //_____________________________________________________________________________
3072 void TGeant3::Gsatt(const char *name, const char *att, Int_t val)
3073
3074   //
3075   //  NAME   Volume name
3076   //  IOPT   Name of the attribute to be set
3077   //  IVAL   Value to which the attribute is to be set
3078   //
3079   //  name= "*" stands for all the volumes.
3080   //  iopt can be chosen among the following :
3081   //  
3082   //     WORK   0=volume name is inactive for the tracking
3083   //            1=volume name is active for the tracking (default)
3084   //  
3085   //     SEEN   0=volume name is invisible
3086   //            1=volume name is visible (default)
3087   //           -1=volume invisible with all its descendants in the tree
3088   //           -2=volume visible but not its descendants in the tree
3089   //  
3090   //     LSTY   line style 1,2,3,... (default=1)
3091   //            LSTY=7 will produce a very precise approximation for
3092   //            revolution bodies.
3093   //  
3094   //     LWID   line width -7,...,1,2,3,..7 (default=1)
3095   //            LWID<0 will act as abs(LWID) was set for the volume
3096   //            and for all the levels below it. When SHAD is 'ON', LWID
3097   //            represent the linewidth of the scan lines filling the surfaces
3098   //            (whereas the FILL value represent their number). Therefore
3099   //            tuning this parameter will help to obtain the desired
3100   //            quality/performance ratio.
3101   //  
3102   //     COLO   colour code -166,...,1,2,..166 (default=1)
3103   //            n=1=black
3104   //            n=2=red;    n=17+m, m=0,25, increasing luminosity according to 'm';
3105   //            n=3=green;  n=67+m, m=0,25, increasing luminosity according to 'm';
3106   //            n=4=blue;   n=117+m, m=0,25, increasing luminosity according to 'm';
3107   //            n=5=yellow; n=42+m, m=0,25, increasing luminosity according to 'm';
3108   //            n=6=violet; n=142+m, m=0,25, increasing luminosity according to 'm';
3109   //            n=7=lightblue; n=92+m, m=0,25, increasing luminosity according to 'm';
3110   //            colour=n*10+m, m=1,2,...9, will produce the same colour
3111   //            as 'n', but with increasing luminosity according to 'm';
3112   //            COLO<0 will act as if abs(COLO) was set for the volume
3113   //            and for all the levels below it.
3114   //            When for a volume the attribute FILL is > 1 (and the
3115   //            option SHAD is on), the ABS of its colour code must be < 8
3116   //            because an automatic shading of its faces will be
3117   //            performed.
3118   //  
3119   //     FILL  (1992) fill area  -7,...,0,1,...7 (default=0)
3120   //            when option SHAD is "on" the FILL attribute of any
3121   //            volume can be set different from 0 (normal drawing);
3122   //            if it is set to 1, the faces of such volume will be filled
3123   //            with solid colours; if ABS(FILL) is > 1, then a light
3124   //            source is placed along the observer line, and the faces of
3125   //            such volumes will be painted by colours whose luminosity
3126   //            will depend on the amount of light reflected;
3127   //            if ABS(FILL) = 1, then it is possible to use all the 166
3128   //            colours of the colour table, becouse the automatic shading
3129   //            is not performed;
3130   //            for increasing values of FILL the drawing will be performed
3131   //            with higher and higher resolution improving the quality (the
3132   //            number of scan lines used to fill the faces increases with FILL);
3133   //            it is possible to set different values of FILL
3134   //            for different volumes, in order to optimize at the same time
3135   //            the performance and the quality of the picture;
3136   //            FILL<0 will act as if abs(FILL) was set for the volume
3137   //            and for all the levels below it.
3138   //            This kind of drawing can be saved in 'picture files'
3139   //            or in view banks.
3140   //            0=drawing without fill area
3141   //            1=faces filled with solid colours and resolution = 6
3142   //            2=lowest resolution (very fast)
3143   //            3=default resolution
3144   //            4=.................
3145   //            5=.................
3146   //            6=.................
3147   //            7=max resolution
3148   //            Finally, if a coloured background is desired, the FILL
3149   //            attribute for the first volume of the tree must be set
3150   //            equal to -abs(colo), colo being >0 and <166.
3151   //  
3152   //     SET   set number associated to volume name
3153   //     DET   detector number associated to volume name
3154   //     DTYP  detector type (1,2)
3155   //  
3156   InitHIGZ();
3157   char vname[5];
3158   Vname(name,vname);
3159   char vatt[5];
3160   Vname(att,vatt);
3161   gsatt(PASSCHARD(vname), PASSCHARD(vatt), val PASSCHARL(vname)
3162         PASSCHARL(vatt)); 
3163
3164
3165 //_____________________________________________________________________________
3166 void TGeant3::Gfpara(const char *name, Int_t number, Int_t intext, Int_t& npar,
3167                          Int_t& natt, Float_t* par, Float_t* att)
3168 {
3169   //
3170   // Find the parameters of a volume
3171   //
3172   gfpara(PASSCHARD(name), number, intext, npar, natt, par, att
3173          PASSCHARL(name));
3174 }
3175
3176 //_____________________________________________________________________________
3177 void TGeant3::Gckpar(Int_t ish, Int_t npar, Float_t* par)
3178 {
3179   //
3180   // Check the parameters of a shape
3181   //
3182   gckpar(ish,npar,par);
3183 }
3184
3185 //_____________________________________________________________________________
3186 void TGeant3::Gckmat(Int_t itmed, char* natmed)
3187 {
3188   //
3189   // Check the parameters of a tracking medium
3190   //
3191   gckmat(itmed, PASSCHARD(natmed) PASSCHARL(natmed));
3192 }
3193
3194 //_____________________________________________________________________________
3195 Int_t TGeant3::Glvolu(Int_t nlev, Int_t *lnam,Int_t *lnum) 
3196
3197   //
3198   //  nlev   number of leveles deap into the volume tree
3199   //         size of the arrays lnam and lnum
3200   //  lnam   an integer array whos 4 bytes contain the askii code for the
3201   //         volume names
3202   //  lnum   an integer array containing the copy numbers for that specific
3203   //         volume
3204   //
3205   //  This routine fills the volulme paramters in common /gcvolu/ for a
3206   //  physical tree, specified by the list lnam and lnum of volume names
3207   //  and numbers, and for all its ascendants up to level 1. This routine
3208   //  is optimsed and does not re-compute the part of the history already
3209   //  available in GCVOLU. This means that if it is used in user programs
3210   //  outside the usual framwork of the tracking, the user has to initilise
3211   //  to zero NLEVEL in the common GCVOLU. It return 0 if there were no
3212   //  problems in make the call.
3213   //
3214   Int_t ier;
3215   glvolu(nlev, lnam, lnum, ier); 
3216   return ier;
3217 }
3218
3219 //_____________________________________________________________________________
3220 void TGeant3::Gdelete(Int_t iview)
3221
3222   //
3223   //  IVIEW  View number
3224   //
3225   //  It deletes a view bank from memory.
3226   //
3227   gdelet(iview);
3228 }
3229  
3230 //_____________________________________________________________________________
3231 void TGeant3::Gdopen(Int_t iview)
3232
3233   //
3234   //  IVIEW  View number
3235   //
3236   //  When a drawing is very complex and requires a long time to be
3237   //  executed, it can be useful to store it in a view bank: after a
3238   //  call to DOPEN and the execution of the drawing (nothing will
3239   //  appear on the screen), and after a necessary call to DCLOSE,
3240   //  the contents of the bank can be displayed in a very fast way
3241   //  through a call to DSHOW; therefore, the detector can be easily
3242   //  zoomed many times in different ways. Please note that the pictures
3243   //  with solid colours can now be stored in a view bank or in 'PICTURE FILES'
3244   //
3245   InitHIGZ();
3246   gHigz->Clear();
3247   gdopen(iview);
3248 }
3249  
3250 //_____________________________________________________________________________
3251 void TGeant3::Gdclose()
3252
3253   //
3254   //  It closes the currently open view bank; it must be called after the
3255   //  end of the drawing to be stored.
3256   //
3257   gdclos();
3258 }
3259  
3260 //_____________________________________________________________________________
3261 void TGeant3::Gdshow(Int_t iview)
3262
3263   //
3264   //  IVIEW  View number
3265   //
3266   //  It shows on the screen the contents of a view bank. It
3267   //  can be called after a view bank has been closed.
3268   //
3269   gdshow(iview);
3270
3271
3272 //_____________________________________________________________________________
3273 void TGeant3::Gdopt(const char *name,const char *value)
3274
3275   //
3276   //  NAME   Option name
3277   //  VALUE  Option value
3278   //
3279   //  To set/modify the drawing options.
3280   //     IOPT   IVAL      Action
3281   //  
3282   //     THRZ    ON       Draw tracks in R vs Z
3283   //             OFF (D)  Draw tracks in X,Y,Z
3284   //             180
3285   //             360
3286   //     PROJ    PARA (D) Parallel projection
3287   //             PERS     Perspective
3288   //     TRAK    LINE (D) Trajectory drawn with lines
3289   //             POIN       " " with markers
3290   //     HIDE    ON       Hidden line removal using the CG package
3291   //             OFF (D)  No hidden line removal
3292   //     SHAD    ON       Fill area and shading of surfaces.
3293   //             OFF (D)  Normal hidden line removal.
3294   //     RAYT    ON       Ray-tracing on.
3295   //             OFF (D)  Ray-tracing off.
3296   //     EDGE    OFF      Does not draw contours when shad is on.
3297   //             ON  (D)  Normal shading.
3298   //     MAPP    1,2,3,4  Mapping before ray-tracing.
3299   //             0   (D)  No mapping.
3300   //     USER    ON       User graphics options in the raytracing.
3301   //             OFF (D)  Automatic graphics options.
3302   //  
3303   InitHIGZ();
3304   char vname[5];
3305   Vname(name,vname);
3306   char vvalue[5];
3307   Vname(value,vvalue);
3308   gdopt(PASSCHARD(vname), PASSCHARD(vvalue) PASSCHARL(vname)
3309         PASSCHARL(vvalue)); 
3310
3311  
3312 //_____________________________________________________________________________
3313 void TGeant3::Gdraw(const char *name,Float_t theta, Float_t phi, Float_t psi,
3314                     Float_t u0,Float_t v0,Float_t ul,Float_t vl)
3315
3316   //
3317   //  NAME   Volume name
3318   //  +
3319   //  THETA  Viewing angle theta (for 3D projection)
3320   //  PHI    Viewing angle phi (for 3D projection)
3321   //  PSI    Viewing angle psi (for 2D rotation)
3322   //  U0     U-coord. (horizontal) of volume origin
3323   //  V0     V-coord. (vertical) of volume origin
3324   //  SU     Scale factor for U-coord.
3325   //  SV     Scale factor for V-coord.
3326   //
3327   //  This function will draw the volumes,
3328   //  selected with their graphical attributes, set by the Gsatt
3329   //  facility. The drawing may be performed with hidden line removal
3330   //  and with shading effects according to the value of the options HIDE
3331   //  and SHAD; if the option SHAD is ON, the contour's edges can be
3332   //  drawn or not. If the option HIDE is ON, the detector can be
3333   //  exploded (BOMB), clipped with different shapes (CVOL), and some
3334   //  of its parts can be shifted from their original
3335   //  position (SHIFT). When HIDE is ON, if
3336   //  the drawing requires more than the available memory, the program
3337   //  will evaluate and display the number of missing words
3338   //  (so that the user can increase the
3339   //  size of its ZEBRA store). Finally, at the end of each drawing (with HIDE on),
3340   //  the program will print messages about the memory used and
3341   //  statistics on the volumes' visibility.
3342   //  The following commands will produce the drawing of a green
3343   //  volume, specified by NAME, without using the hidden line removal
3344   //  technique, using the hidden line removal technique,
3345   //  with different linewidth and colour (red), with
3346   //  solid colour, with shading of surfaces, and without edges.
3347   //  Finally, some examples are given for the ray-tracing. (A possible
3348   //  string for the NAME of the volume can be found using the command DTREE).
3349   //
3350   InitHIGZ();
3351   gHigz->Clear();
3352   char vname[5];
3353   Vname(name,vname);
3354   if (fGcvdma->raytra != 1) {
3355     gdraw(PASSCHARD(vname), theta,phi,psi,u0,v0,ul,vl PASSCHARL(vname)); 
3356   } else {
3357     gdrayt(PASSCHARD(vname), theta,phi,psi,u0,v0,ul,vl PASSCHARL(vname)); 
3358   }
3359
3360  
3361 //_____________________________________________________________________________
3362 void TGeant3::Gdrawc(const char *name,Int_t axis, Float_t cut,Float_t u0,
3363                      Float_t v0,Float_t ul,Float_t vl)
3364
3365   //
3366   //  NAME   Volume name
3367   //  CAXIS  Axis value
3368   //  CUTVAL Cut plane distance from the origin along the axis
3369   //  +
3370   //  U0     U-coord. (horizontal) of volume origin
3371   //  V0     V-coord. (vertical) of volume origin
3372   //  SU     Scale factor for U-coord.
3373   //  SV     Scale factor for V-coord.
3374   //
3375   //  The cut plane is normal to caxis (X,Y,Z), corresponding to iaxis (1,2,3),
3376   //  and placed at the distance cutval from the origin.
3377   //  The resulting picture is seen from the the same axis.
3378   //  When HIDE Mode is ON, it is possible to get the same effect with
3379   //  the CVOL/BOX function.
3380   //  
3381   InitHIGZ();
3382   gHigz->Clear();
3383   char vname[5];
3384   Vname(name,vname);
3385   gdrawc(PASSCHARD(vname), axis,cut,u0,v0,ul,vl PASSCHARL(vname)); 
3386
3387  
3388 //_____________________________________________________________________________
3389 void TGeant3::Gdrawx(const char *name,Float_t cutthe, Float_t cutphi,
3390                      Float_t cutval, Float_t theta, Float_t phi, Float_t u0,
3391                      Float_t v0,Float_t ul,Float_t vl)
3392
3393   //
3394   //  NAME   Volume name
3395   //  CUTTHE Theta angle of the line normal to cut plane
3396   //  CUTPHI Phi angle of the line normal to cut plane
3397   //  CUTVAL Cut plane distance from the origin along the axis
3398   //  +
3399   //  THETA  Viewing angle theta (for 3D projection)
3400   //  PHI    Viewing angle phi (for 3D projection)
3401   //  U0     U-coord. (horizontal) of volume origin
3402   //  V0     V-coord. (vertical) of volume origin
3403   //  SU     Scale factor for U-coord.
3404   //  SV     Scale factor for V-coord.
3405   //
3406   //  The cut plane is normal to the line given by the cut angles
3407   //  cutthe and cutphi and placed at the distance cutval from the origin.
3408   //  The resulting picture is seen from the viewing angles theta,phi.
3409   //
3410   InitHIGZ();
3411   gHigz->Clear();
3412   char vname[5];
3413   Vname(name,vname);
3414   gdrawx(PASSCHARD(vname), cutthe,cutphi,cutval,theta,phi,u0,v0,ul,vl
3415          PASSCHARL(vname)); 
3416 }
3417  
3418 //_____________________________________________________________________________
3419 void TGeant3::Gdhead(Int_t isel, const char *name, Float_t chrsiz)
3420
3421   //
3422   //  Parameters
3423   //  +
3424   //  ISEL   Option flag  D=111110
3425   //  NAME   Title
3426   //  CHRSIZ Character size (cm) of title NAME D=0.6
3427   //
3428   //  ISEL =
3429   //   0      to have only the header lines
3430   //   xxxxx1 to add the text name centered on top of header
3431   //   xxxx1x to add global detector name (first volume) on left
3432   //   xxx1xx to add date on right
3433   //   xx1xxx to select thick characters for text on top of header
3434   //   x1xxxx to add the text 'EVENT NR x' on top of header
3435   //   1xxxxx to add the text 'RUN NR x' on top of header
3436   //  NOTE that ISEL=x1xxx1 or ISEL=1xxxx1 are illegal choices,
3437   //  i.e. they generate overwritten text.
3438   //
3439   gdhead(isel,PASSCHARD(name),chrsiz PASSCHARL(name));
3440 }
3441
3442 //_____________________________________________________________________________
3443 void TGeant3::Gdman(Float_t u, Float_t v, const char *type)
3444
3445   //
3446   //  Draw a 2D-man at position (U0,V0)
3447   //  Parameters
3448   //  U      U-coord. (horizontal) of the centre of man' R
3449   //  V      V-coord. (vertical) of the centre of man' R
3450   //  TYPE   D='MAN' possible values: 'MAN,WM1,WM2,WM3'
3451   // 
3452   //   CALL GDMAN(u,v),CALL GDWMN1(u,v),CALL GDWMN2(u,v),CALL GDWMN2(u,v)
3453   //  It superimposes the picure of a man or of a woman, chosen among
3454   //  three different ones, with the same scale factors as the detector
3455   //  in the current drawing.
3456   //
3457   TString opt = type;
3458    if (opt.Contains("WM1")) {
3459      gdwmn1(u,v);
3460    } else if (opt.Contains("WM3")) {
3461      gdwmn3(u,v);
3462    } else if (opt.Contains("WM2")) {
3463      gdwmn2(u,v);
3464    } else {
3465      gdman(u,v);
3466    }
3467 }
3468  
3469 //_____________________________________________________________________________
3470 void TGeant3::Gdspec(const char *name)
3471
3472   //
3473   //  NAME   Volume name
3474   //
3475   //  Shows 3 views of the volume (two cut-views and a 3D view), together with
3476   //  its geometrical specifications. The 3D drawing will
3477   //  be performed according the current values of the options HIDE and
3478   //  SHAD and according the current SetClipBox clipping parameters for that
3479   //  volume.
3480   //  
3481   InitHIGZ();
3482   gHigz->Clear();
3483   char vname[5];
3484   Vname(name,vname);
3485   gdspec(PASSCHARD(vname) PASSCHARL(vname)); 
3486
3487  
3488 //_____________________________________________________________________________
3489 void TGeant3::DrawOneSpec(const char *name)
3490
3491   //
3492   //  Function called when one double-clicks on a volume name
3493   //  in a TPavelabel drawn by Gdtree.
3494   //
3495   THIGZ *higzSave = gHigz;
3496   higzSave->SetName("higzSave");
3497   THIGZ *higzSpec = (THIGZ*)gROOT->FindObject("higzSpec");
3498   //printf("DrawOneSpec, gHigz=%x, higzSpec=%x\n",gHigz,higzSpec);
3499   if (higzSpec) gHigz     = higzSpec;
3500   else          higzSpec = new THIGZ(kDefSize);
3501   higzSpec->SetName("higzSpec");
3502   higzSpec->cd();
3503   higzSpec->Clear();
3504   char vname[5];
3505   Vname(name,vname);
3506   gdspec(PASSCHARD(vname) PASSCHARL(vname)); 
3507   higzSpec->Update();
3508   higzSave->cd();
3509   higzSave->SetName("higz");
3510   gHigz = higzSave;
3511
3512
3513 //_____________________________________________________________________________
3514 void TGeant3::Gdtree(const char *name,Int_t levmax, Int_t isel)
3515
3516   //
3517   //  NAME   Volume name
3518   //  LEVMAX Depth level
3519   //  ISELT  Options
3520   //
3521   //  This function draws the logical tree,
3522   //  Each volume in the tree is represented by a TPaveTree object.
3523   //  Double-clicking on a TPaveTree draws the specs of the corresponding volume.
3524   //  Use TPaveTree pop-up menu to select:
3525   //    - drawing specs
3526   //    - drawing tree
3527   //    - drawing tree of parent
3528   //  
3529   InitHIGZ();
3530   gHigz->Clear();
3531   char vname[5];
3532   Vname(name,vname);
3533   gdtree(PASSCHARD(vname), levmax, isel PASSCHARL(vname)); 
3534   gHigz->SetPname("");
3535
3536
3537 //_____________________________________________________________________________
3538 void TGeant3::GdtreeParent(const char *name,Int_t levmax, Int_t isel)
3539
3540   //
3541   //  NAME   Volume name
3542   //  LEVMAX Depth level
3543   //  ISELT  Options
3544   //
3545   //  This function draws the logical tree of the parent of name.
3546   //  
3547   InitHIGZ();
3548   gHigz->Clear();
3549   // Scan list of volumes in JVOLUM
3550   char vname[5];
3551   Int_t gname, i, jvo, in, nin, jin, num;
3552   strncpy((char *) &gname, name, 4);
3553   for(i=1; i<=fGcnum->nvolum; i++) {
3554     jvo = fZlq[fGclink->jvolum-i];
3555     nin = Int_t(fZq[jvo+3]);
3556     if (nin == -1) nin = 1;
3557     for (in=1;in<=nin;in++) {
3558       jin = fZlq[jvo-in];
3559       num = Int_t(fZq[jin+2]);
3560       if(gname == fZiq[fGclink->jvolum+num]) {
3561         strncpy(vname,(char*)&fZiq[fGclink->jvolum+i],4);
3562         vname[4] = 0;           
3563         gdtree(PASSCHARD(vname), levmax, isel PASSCHARL(vname)); 
3564         gHigz->SetPname("");
3565         return;
3566       }
3567     }
3568   }
3569
3570  
3571 //_____________________________________________________________________________
3572 void TGeant3::SetABAN(Int_t par)
3573 {
3574   //
3575   // par = 1 particles will be stopped according to their residual
3576   //         range if they are not in a sensitive material and are
3577   //         far enough from the boundary
3578   //       0 particles are transported normally
3579   //
3580   fGcphys->dphys1 = par;
3581 }
3582  
3583  
3584 //_____________________________________________________________________________
3585 void TGeant3::SetANNI(Int_t par)
3586 {
3587   //
3588   //   To control positron annihilation.
3589   //    par =0 no annihilation
3590   //        =1 annihilation. Decays processed.
3591   //        =2 annihilation. No decay products stored.
3592   //
3593   fGcphys->ianni = par;
3594 }
3595  
3596  
3597 //_____________________________________________________________________________
3598 void TGeant3::SetAUTO(Int_t par)
3599 {
3600   //
3601   //  To control automatic calculation of tracking medium parameters:
3602   //   par =0 no automatic calculation;
3603   //       =1 automati calculation.
3604   //  
3605   fGctrak->igauto = par;
3606 }
3607  
3608  
3609 //_____________________________________________________________________________
3610 void TGeant3::SetBOMB(Float_t boom)
3611 {
3612   //
3613   //  BOOM  : Exploding factor for volumes position 
3614   // 
3615   //  To 'explode' the detector. If BOOM is positive (values smaller
3616   //  than 1. are suggested, but any value is possible)
3617   //  all the volumes are shifted by a distance
3618   //  proportional to BOOM along the direction between their centre
3619   //  and the origin of the MARS; the volumes which are symmetric
3620   //  with respect to this origin are simply not shown.
3621   //  BOOM equal to 0 resets the normal mode.
3622   //  A negative (greater than -1.) value of
3623   //  BOOM will cause an 'implosion'; for even lower values of BOOM
3624   //  the volumes' positions will be reflected respect to the origin.
3625   //  This command can be useful to improve the 3D effect for very
3626   //  complex detectors. The following commands will make explode the
3627   //  detector:
3628   //
3629   InitHIGZ();
3630   setbomb(boom);
3631 }
3632  
3633 //_____________________________________________________________________________
3634 void TGeant3::SetBREM(Int_t par)
3635 {
3636   //
3637   //  To control bremstrahlung.
3638   //   par =0 no bremstrahlung
3639   //       =1 bremstrahlung. Photon processed.
3640   //       =2 bremstrahlung. No photon stored.
3641   //  
3642   fGcphys->ibrem = par;
3643 }
3644  
3645  
3646 //_____________________________________________________________________________
3647 void TGeant3::SetCKOV(Int_t par)
3648 {
3649   //
3650   //  To control Cerenkov production
3651   //   par =0 no Cerenkov;
3652   //       =1 Cerenkov;
3653   //       =2 Cerenkov with primary stopped at each step.
3654   //  
3655   fGctlit->itckov = par;
3656 }
3657  
3658  
3659 //_____________________________________________________________________________
3660 void  TGeant3::SetClipBox(const char *name,Float_t xmin,Float_t xmax,
3661                           Float_t ymin,Float_t ymax,Float_t zmin,Float_t zmax)
3662 {
3663   //
3664   //  The hidden line removal technique is necessary to visualize properly
3665   //  very complex detectors. At the same time, it can be useful to visualize
3666   //  the inner elements of a detector in detail. This function allows
3667   //  subtractions (via boolean operation) of BOX shape from any part of
3668   //  the detector, therefore showing its inner contents.
3669   //  If "*" is given as the name of the
3670   //  volume to be clipped, all volumes are clipped by the given box.
3671   //  A volume can be clipped at most twice.
3672   //  if a volume is explicitely clipped twice,
3673   //  the "*" will not act on it anymore. Giving "." as the name
3674   //  of the volume to be clipped will reset the clipping.
3675   //  Parameters
3676   //  NAME   Name of volume to be clipped 
3677   //  +
3678   //  XMIN   Lower limit of the Shape X coordinate
3679   //  XMAX   Upper limit of the Shape X coordinate
3680   //  YMIN   Lower limit of the Shape Y coordinate
3681   //  YMAX   Upper limit of the Shape Y coordinate
3682   //  ZMIN   Lower limit of the Shape Z coordinate
3683   //  ZMAX   Upper limit of the Shape Z coordinate
3684   //
3685   //  This function performs a boolean subtraction between the volume
3686   //  NAME and a box placed in the MARS according the values of the given
3687   //  coordinates.
3688   
3689   InitHIGZ();
3690   char vname[5];
3691   Vname(name,vname);
3692   setclip(PASSCHARD(vname),xmin,xmax,ymin,ymax,zmin,zmax PASSCHARL(vname));   
3693
3694
3695 //_____________________________________________________________________________
3696 void TGeant3::SetCOMP(Int_t par)
3697 {
3698   //
3699   //  To control Compton scattering
3700   //   par =0 no Compton
3701   //       =1 Compton. Electron processed.
3702   //       =2 Compton. No electron stored.
3703   //  
3704   //
3705   fGcphys->icomp = par;
3706 }
3707   
3708 //_____________________________________________________________________________
3709 void TGeant3::SetCUTS(Float_t cutgam,Float_t cutele,Float_t cutneu,
3710                       Float_t cuthad,Float_t cutmuo ,Float_t bcute ,
3711                       Float_t bcutm ,Float_t dcute ,Float_t dcutm ,
3712                       Float_t ppcutm, Float_t tofmax)
3713 {
3714   //
3715   //  CUTGAM   Cut for gammas              D=0.001
3716   //  CUTELE   Cut for electrons           D=0.001
3717   //  CUTHAD   Cut for charged hadrons     D=0.01
3718   //  CUTNEU   Cut for neutral hadrons     D=0.01
3719   //  CUTMUO   Cut for muons               D=0.01
3720   //  BCUTE    Cut for electron brems.     D=-1.
3721   //  BCUTM    Cut for muon brems.         D=-1.
3722   //  DCUTE    Cut for electron delta-rays D=-1.
3723   //  DCUTM    Cut for muon delta-rays     D=-1.
3724   //  PPCUTM   Cut for e+e- pairs by muons D=0.01
3725   //  TOFMAX   Time of flight cut          D=1.E+10
3726   //
3727   //   If the default values (-1.) for       BCUTE ,BCUTM ,DCUTE ,DCUTM
3728   //   are not modified, they will be set to CUTGAM,CUTGAM,CUTELE,CUTELE
3729   //   respectively.
3730   //  If one of the parameters from CUTGAM to PPCUTM included
3731   //  is modified, cross-sections and energy loss tables must be
3732   //  recomputed via the function Gphysi.
3733   //
3734   fGccuts->cutgam = cutgam;
3735   fGccuts->cutele = cutele;
3736   fGccuts->cutneu = cutneu;
3737   fGccuts->cuthad = cuthad;
3738   fGccuts->cutmuo = cutmuo;
3739   fGccuts->bcute  = bcute;
3740   fGccuts->bcutm  = bcutm;
3741   fGccuts->dcute  = dcute;
3742   fGccuts->dcutm  = dcutm;
3743   fGccuts->ppcutm = ppcutm;
3744   fGccuts->tofmax = tofmax;   
3745 }
3746
3747 //_____________________________________________________________________________
3748 void TGeant3::SetDCAY(Int_t par)
3749 {
3750   //
3751   //  To control Decay mechanism.
3752   //   par =0 no decays.
3753   //       =1 Decays. secondaries processed.
3754   //       =2 Decays. No secondaries stored.
3755   //  
3756   fGcphys->idcay = par;
3757 }
3758  
3759  
3760 //_____________________________________________________________________________
3761 void TGeant3::SetDEBU(Int_t emin, Int_t emax, Int_t emod)
3762 {
3763   //
3764   // Set the debug flag and frequency
3765   // Selected debug output will be printed from
3766   // event emin to even emax each emod event
3767   //
3768   fGcflag->idemin = emin;
3769   fGcflag->idemax = emax;
3770   fGcflag->itest  = emod;
3771 }
3772  
3773  
3774 //_____________________________________________________________________________
3775 void TGeant3::SetDRAY(Int_t par)
3776 {
3777   //
3778   //  To control delta rays mechanism.
3779   //   par =0 no delta rays.
3780   //       =1 Delta rays. secondaries processed.
3781   //       =2 Delta rays. No secondaries stored.
3782   //  
3783   fGcphys->idray = par;
3784 }
3785  
3786 //_____________________________________________________________________________
3787 void TGeant3::SetERAN(Float_t ekmin, Float_t ekmax, Int_t nekbin)
3788 {
3789   //
3790   //  To control cross section tabulations
3791   //   ekmin = minimum kinetic energy in GeV
3792   //   ekmax = maximum kinetic energy in GeV
3793   //   nekbin = number of logatithmic bins (<200)
3794   //  
3795   fGcmulo->ekmin = ekmin;
3796   fGcmulo->ekmax = ekmax;
3797   fGcmulo->nekbin = nekbin;
3798 }
3799  
3800 //_____________________________________________________________________________
3801 void TGeant3::SetHADR(Int_t par)
3802 {
3803   //
3804   //  To control hadronic interactions.
3805   //   par =0 no hadronic interactions.
3806   //       =1 Hadronic interactions. secondaries processed.
3807   //       =2 Hadronic interactions. No secondaries stored.
3808   //  
3809   fGcphys->ihadr = par;
3810 }
3811  
3812 //_____________________________________________________________________________
3813 void TGeant3::SetKINE(Int_t kine, Float_t xk1, Float_t xk2, Float_t xk3,
3814                       Float_t xk4, Float_t xk5, Float_t xk6, Float_t xk7,
3815                       Float_t xk8, Float_t xk9, Float_t xk10)
3816 {
3817   //
3818   // Set the variables in /GCFLAG/ IKINE, PKINE(10)
3819   // Their meaning is user defined
3820   //
3821   fGckine->ikine    = kine;
3822   fGckine->pkine[0] = xk1;
3823   fGckine->pkine[1] = xk2;
3824   fGckine->pkine[2] = xk3;
3825   fGckine->pkine[3] = xk4;
3826   fGckine->pkine[4] = xk5;
3827   fGckine->pkine[5] = xk6;
3828   fGckine->pkine[6] = xk7;
3829   fGckine->pkine[7] = xk8;
3830   fGckine->pkine[8] = xk9;
3831   fGckine->pkine[9] = xk10;
3832 }
3833  
3834 //_____________________________________________________________________________
3835 void TGeant3::SetLOSS(Int_t par)
3836 {
3837   //
3838   //  To control energy loss.
3839   //   par =0 no energy loss;
3840   //       =1 restricted energy loss fluctuations;
3841   //       =2 complete energy loss fluctuations;
3842   //       =3 same as 1;
3843   //       =4 no energy loss fluctuations.
3844   //  If the value ILOSS is changed, then cross-sections and energy loss
3845   //  tables must be recomputed via the command 'PHYSI'.
3846   //  
3847   fGcphys->iloss = par;
3848 }
3849  
3850  
3851 //_____________________________________________________________________________
3852 void TGeant3::SetMULS(Int_t par)
3853 {
3854   //
3855   //  To control multiple scattering.
3856   //   par =0 no multiple scattering.
3857   //       =1 Moliere or Coulomb scattering.
3858   //       =2 Moliere or Coulomb scattering.
3859   //       =3 Gaussian scattering.
3860   //  
3861   fGcphys->imuls = par;
3862 }
3863  
3864  
3865 //_____________________________________________________________________________
3866 void TGeant3::SetMUNU(Int_t par)
3867 {
3868   //
3869   //  To control muon nuclear interactions.
3870   //   par =0 no muon-nuclear interactions.
3871   //       =1 Nuclear interactions. Secondaries processed.
3872   //       =2 Nuclear interactions. Secondaries not processed.
3873   //  
3874   fGcphys->imunu = par;
3875 }
3876  
3877 //_____________________________________________________________________________
3878 void TGeant3::SetOPTI(Int_t par)
3879 {
3880   //
3881   //  This flag controls the tracking optimisation performed via the
3882   //  GSORD routine:
3883   //      1 no optimisation at all; GSORD calls disabled;
3884   //      0 no optimisation; only user calls to GSORD kept;
3885   //      1 all non-GSORDered volumes are ordered along the best axis;
3886   //      2 all volumes are ordered along the best axis.
3887   //  
3888   fGcopti->ioptim = par;
3889 }
3890  
3891 //_____________________________________________________________________________
3892 void TGeant3::SetPAIR(Int_t par)
3893 {
3894   //
3895   //  To control pair production mechanism.
3896   //   par =0 no pair production.
3897   //       =1 Pair production. secondaries processed.
3898   //       =2 Pair production. No secondaries stored.
3899   //  
3900   fGcphys->ipair = par;
3901 }
3902  
3903  
3904 //_____________________________________________________________________________
3905 void TGeant3::SetPFIS(Int_t par)
3906 {
3907   //
3908   //  To control photo fission mechanism.
3909   //   par =0 no photo fission.
3910   //       =1 Photo fission. secondaries processed.
3911   //       =2 Photo fission. No secondaries stored.
3912   //  
3913   fGcphys->ipfis = par;
3914 }
3915   
3916 //_____________________________________________________________________________
3917 void TGeant3::SetPHOT(Int_t par)
3918 {
3919   //
3920   //  To control Photo effect.
3921   //   par =0 no photo electric effect.
3922   //       =1 Photo effect. Electron processed.
3923   //       =2 Photo effect. No electron stored.
3924   //  
3925   fGcphys->iphot = par;
3926 }
3927  
3928 //_____________________________________________________________________________
3929 void TGeant3::SetRAYL(Int_t par)
3930 {
3931   //
3932   //  To control Rayleigh scattering.
3933   //   par =0 no Rayleigh scattering.
3934   //       =1 Rayleigh.
3935   //  
3936   fGcphys->irayl = par;
3937 }
3938  
3939 //_____________________________________________________________________________
3940 void TGeant3::SetSTRA(Int_t par)
3941 {
3942   //
3943   //  To control energy loss fluctuations
3944   //  with the PhotoAbsorption Ionisation model.
3945   //   par =0 no Straggling.
3946   //       =1 Straggling yes => no Delta rays.
3947   //  
3948   fGcphlt->istra = par;
3949 }
3950  
3951 //_____________________________________________________________________________
3952 void TGeant3::SetSWIT(Int_t sw, Int_t val)
3953 {
3954   //
3955   //  sw    Switch number
3956   //  val   New switch value
3957   //
3958   //  Change one element of array ISWIT(10) in /GCFLAG/
3959   //  
3960   if (sw <= 0 || sw > 10) return;
3961   fGcflag->iswit[sw-1] = val;
3962 }
3963  
3964  
3965 //_____________________________________________________________________________
3966 void TGeant3::SetTRIG(Int_t nevents)
3967 {
3968   //
3969   // Set number of events to be run
3970   //
3971   fGcflag->nevent = nevents;
3972 }
3973  
3974 //_____________________________________________________________________________
3975 void TGeant3::SetUserDecay(Int_t pdg)
3976 {
3977   //
3978   // Force the decays of particles to be done with Pythia
3979   // and not with the Geant routines. 
3980   // just kill pointers doing mzdrop
3981   //
3982   Int_t ipart = IdFromPDG(pdg);
3983   if(ipart<0) {
3984     printf("Particle %d not in geant\n",pdg);
3985     return;
3986   }
3987   Int_t jpart=fGclink->jpart;
3988   Int_t jpa=fZlq[jpart-ipart];
3989   //
3990   if(jpart && jpa) {
3991     Int_t jpa1=fZlq[jpa-1];
3992     if(jpa1)
3993       mzdrop(fGcbank->ixcons,jpa1,PASSCHARD(" ") PASSCHARL(" "));
3994     Int_t jpa2=fZlq[jpa-2];
3995     if(jpa2)
3996       mzdrop(fGcbank->ixcons,jpa2,PASSCHARD(" ") PASSCHARL(" "));
3997   }
3998 }
3999
4000 //______________________________________________________________________________
4001 void TGeant3::Vname(const char *name, char *vname)
4002 {
4003   //
4004   //  convert name to upper case. Make vname at least 4 chars
4005   //
4006   Int_t l = strlen(name);
4007   Int_t i;
4008   l = l < 4 ? l : 4;
4009   for (i=0;i<l;i++) vname[i] = toupper(name[i]);
4010   for (i=l;i<4;i++) vname[i] = ' ';
4011   vname[4] = 0;      
4012 }
4013  
4014 //______________________________________________________________________________
4015 void TGeant3::Ertrgo()
4016 {
4017   //
4018   // Perform the tracking of the track Track parameters are in VECT
4019   //
4020   ertrgo();
4021 }
4022
4023 //______________________________________________________________________________
4024 void TGeant3::Ertrak(const Float_t *const x1, const Float_t *const p1, 
4025                         const Float_t *x2, const Float_t *p2,
4026                         Int_t ipa,  Option_t *chopt)
4027 {
4028   //************************************************************************
4029   //*                                                                      *
4030   //*          Perform the tracking of the track from point X1 to          *
4031   //*                    point X2                                          *
4032   //*          (Before calling this routine the user should also provide   *
4033   //*                    the input informations in /EROPTS/ and /ERTRIO/   *
4034   //*                    using subroutine EUFIL(L/P/V)                     *
4035   //*                 X1       - Starting coordinates (Cartesian)          *
4036   //*                 P1       - Starting 3-momentum  (Cartesian)          *
4037   //*                 X2       - Final coordinates    (Cartesian)          *
4038   //*                 P2       - Final 3-momentum     (Cartesian)          *
4039   //*                 IPA      - Particle code (a la GEANT) of the track   *
4040   //*                                                                      *
4041   //*                 CHOPT                                                *
4042   //*                     'B'   'Backward tracking' - i.e. energy loss     *
4043   //*                                        added to the current energy   *
4044   //*                     'E'   'Exact' calculation of errors assuming     *
4045   //*                                        helix (i.e. pathlength not    *
4046   //*                                        assumed as infinitesimal)     *
4047   //*                     'L'   Tracking upto prescribed Lengths reached   *
4048   //*                     'M'   'Mixed' prediction (not yet coded)         *
4049   //*                     'O'   Tracking 'Only' without calculating errors *
4050   //*                     'P'   Tracking upto prescribed Planes reached    *
4051   //*                     'V'   Tracking upto prescribed Volumes reached   *
4052   //*                     'X'   Tracking upto prescribed Point approached  *
4053   //*                                                                      *
4054   //*                Interface with GEANT :                                *
4055   //*             Track parameters are in /CGKINE/ and /GCTRAK/            *
4056   //*                                                                      *
4057   //*          ==>Called by : USER                                         *
4058   //*             Authors   M.Maire, E.Nagy  ********//*                     *
4059   //*                                                                      *
4060   //************************************************************************
4061   ertrak(x1,p1,x2,p2,ipa,PASSCHARD(chopt) PASSCHARL(chopt));
4062 }
4063         
4064 //_____________________________________________________________________________
4065 void TGeant3::WriteEuclid(const char* filnam, const char* topvol,
4066                           Int_t number, Int_t nlevel)
4067 {
4068   //
4069   //
4070   //     ******************************************************************
4071   //     *                                                                *
4072   //     *  Write out the geometry of the detector in EUCLID file format  *
4073   //     *                                                                *
4074   //     *       filnam : will be with the extension .euc                 *
4075   //     *       topvol : volume name of the starting node                *
4076   //     *       number : copy number of topvol (relevant for gsposp)     *
4077   //     *       nlevel : number of  levels in the tree structure         *
4078   //     *                to be written out, starting from topvol         *
4079   //     *                                                                *
4080   //     *       Author : M. Maire                                        *
4081   //     *                                                                *
4082   //     ******************************************************************
4083   //
4084   //     File filnam.tme is written out with the definitions of tracking
4085   //     medias and materials.
4086   //     As to restore original numbers for materials and medias, program
4087   //     searches in the file euc_medi.dat and comparing main parameters of
4088   //     the mat. defined inside geant and the one in file recognizes them
4089   //     and is able to take number from file. If for any material or medium,
4090   //     this procedure fails, ordering starts from 1.
4091   //     Arrays IOTMED and IOMATE are used for this procedure
4092   //
4093   const char kShape[][5]={"BOX ","TRD1","TRD2","TRAP","TUBE","TUBS","CONE",
4094                          "CONS","SPHE","PARA","PGON","PCON","ELTU","HYPE",
4095                          "GTRA","CTUB"};
4096   Int_t i, end, itm, irm, jrm, k, nmed;
4097   Int_t imxtmed=0;
4098   Int_t imxmate=0;
4099   FILE *lun;
4100   char *filext, *filetme;
4101   char natmed[21], namate[21];
4102   char natmedc[21], namatec[21];
4103   char key[5], name[5], mother[5], konly[5];
4104   char card[133];
4105   Int_t iadvol, iadtmd, iadrot, nwtot, iret;
4106   Int_t mlevel, numbr, natt, numed, nin, ndata;
4107   Int_t iname, ivo, ish, jvo, nvstak, ivstak;
4108   Int_t jdiv, ivin, in, jin, jvin, irot;
4109   Int_t jtm, imat, jma, flag=0, imatc;
4110   Float_t az, dens, radl, absl, a, step, x, y, z;
4111   Int_t npar, ndvmx, left;
4112   Float_t zc, densc, radlc, abslc, c0, tmaxfd;
4113   Int_t nparc, numb;
4114   Int_t iomate[100], iotmed[100];
4115   Float_t par[50], att[20], ubuf[50];
4116   Float_t *qws;
4117   Int_t   *iws;
4118   Int_t level, ndiv, iaxe;
4119   Int_t itmedc, nmatc, isvolc, ifieldc, nwbufc, isvol, nmat, ifield, nwbuf;
4120   Float_t fieldmc, tmaxfdc, stemaxc, deemaxc, epsilc, stminc, fieldm;
4121   Float_t tmaxf, stemax, deemax, epsil, stmin;
4122   const char *k10000="!\n%s\n!\n";
4123   //Open the input file
4124   end=strlen(filnam);
4125   for(i=0;i<end;i++) if(filnam[i]=='.') {
4126     end=i;
4127     break;
4128   }
4129   filext=new char[end+5];
4130   filetme=new char[end+5];
4131   strncpy(filext,filnam,end);
4132   strncpy(filetme,filnam,end);
4133   //
4134   // *** The output filnam name will be with extension '.euc'
4135   strcpy(&filext[end],".euc");
4136   strcpy(&filetme[end],".tme");
4137   lun=fopen(filext,"w");
4138   //
4139   // *** Initialisation of the working space
4140   iadvol=fGcnum->nvolum;
4141   iadtmd=iadvol+fGcnum->nvolum;
4142   iadrot=iadtmd+fGcnum->ntmed;
4143   if(fGclink->jrotm) {
4144     fGcnum->nrotm=fZiq[fGclink->jrotm-2];
4145   } else {
4146     fGcnum->nrotm=0;
4147   }
4148   nwtot=iadrot+fGcnum->nrotm;
4149   qws = new float[nwtot+1];
4150   for (i=0;i<nwtot+1;i++) qws[i]=0;
4151   iws = (Int_t*) qws;
4152   mlevel=nlevel;
4153   if(nlevel==0) mlevel=20;
4154   //
4155   // *** find the top volume and put it in the stak
4156   numbr = number>0 ? number : 1;
4157   Gfpara(topvol,numbr,1,npar,natt,par,att);
4158   if(npar <= 0) {
4159     printf(" *** GWEUCL *** top volume : %s number : %3d can not be a valid root\n",
4160            topvol, numbr);
4161     return;
4162   }
4163   //
4164   // ***  authorized shape ?
4165   strncpy((char *)&iname, topvol, 4);
4166   ivo=0;
4167   for(i=1; i<=fGcnum->nvolum; i++) if(fZiq[fGclink->jvolum+i]==iname) {
4168     ivo=i;
4169     break;
4170   }
4171   jvo = fZlq[fGclink->jvolum-ivo];
4172   ish = Int_t (fZq[jvo+2]);
4173   if(ish > 12) {
4174     printf(" *** GWEUCL *** top volume : %s number : %3d can not be a valid root\n",
4175            topvol, numbr);
4176   }
4177   //
4178   level = 1;
4179   nvstak = 1;
4180   iws[nvstak]     = ivo;
4181   iws[iadvol+ivo] = level;
4182   ivstak = 0;
4183   //
4184   //*** flag all volumes and fill the stak
4185   //
4186  L10:
4187   //
4188   //    pick the next volume in stak
4189   ivstak += 1;
4190   ivo   = TMath::Abs(iws[ivstak]);
4191   jvo   = fZlq[fGclink->jvolum - ivo];
4192   //
4193   //     flag the tracking medium
4194   numed =  Int_t (fZq[jvo + 4]);
4195   iws[iadtmd + numed] = 1;
4196   //
4197   //    get the daughters ...
4198   level = iws[iadvol+ivo];
4199   if (level < mlevel) {
4200     level +=  1;
4201     nin = Int_t (fZq[jvo + 3]);
4202     //
4203     //       from division ...
4204     if (nin < 0) {
4205       jdiv = fZlq[jvo  - 1];
4206       ivin =  Int_t (fZq[jdiv + 2]);
4207       nvstak += 1;
4208       iws[nvstak]      = -ivin;
4209       iws[iadvol+ivin] =  level;
4210       //
4211       //       from position ...
4212     } else if (nin > 0) {
4213       for(in=1; in<=nin; in++) {
4214         jin  = fZlq[jvo - in];
4215         ivin =  Int_t (fZq[jin + 2 ]);
4216         jvin = fZlq[fGclink->jvolum - ivin];
4217         ish  =  Int_t (fZq[jvin + 2]);
4218         //              authorized shape ?
4219         if (ish <= 12) {
4220           //                 not yet flagged ?
4221           if (iws[iadvol+ivin]==0) {
4222             nvstak += 1;
4223             iws[nvstak]      = ivin;
4224             iws[iadvol+ivin] = level;
4225           }
4226           //                 flag the rotation matrix
4227           irot = Int_t ( fZq[jin + 4 ]);
4228           if (irot > 0) iws[iadrot+irot] = 1;
4229         }
4230       }
4231     }
4232   }
4233   //
4234   //     next volume in stak ?
4235   if (ivstak < nvstak) goto L10;
4236   //
4237   // *** restore original material and media numbers