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