TGeant3/TGeant3.cxx

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