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