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