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