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