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