TGeant3/AliGeant3.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.6  2000/07/11 18:24:59  fca
  19 Coding convention corrections + few minor bug fixes
  20
  21 Revision 1.5  2000/05/20 14:49:48  fca
  22 Call gdebug at the end of gustep
  23
  24 Revision 1.4  2000/04/26 10:17:32  fca
  25 Changes in Lego for G4 compatibility
  26
  27 Revision 1.3  2000/04/07 11:12:35  fca
  28 G4 compatibility changes
  29
  30 Revision 1.2  2000/02/29 19:11:17  fca
  31 Move gucode into AliGeant3.cxx
  32
  33 Revision 1.1  2000/02/23 16:25:25  fca
  34 AliVMC and AliGeant3 classes introduced
  35 ReadEuclid moved from AliRun to AliModule
  36
  37 */
  38
  39 #include <TParticle.h>
  40
  41 #include "AliGeant3.h"
  42 #include "AliRun.h"
  43 #include "TGeant3.h"
  44 #include "AliCallf77.h"
  45
  46 #ifndef WIN32
  47
  48 # define rxgtrak rxgtrak_
  49 # define rxstrak rxstrak_
  50 # define rxkeep  rxkeep_
  51 # define rxouth  rxouth_
  52 #else
  53
  54 # define rxgtrak RXGTRAK
  55 # define rxstrak RXSTRAK
  56 # define rxkeep  RXKEEP
  57 # define rxouth  RXOUTH
  58 #endif
  59
  60 ClassImp(AliGeant3)
  61
  62 AliGeant3::AliGeant3(const char *title) :
  63   TGeant3(title) {}
  64
  65 //____________________________________________________________________________
  66 void AliGeant3::FinishGeometry()
  67 {
  68   //
  69   // Finalise geometry construction
  70   //
  71   TGeant3::FinishGeometry();
  72   //Create the color table
  73   SetColors();
  74 }
  75
  76 //____________________________________________________________________________
  77 void AliGeant3::Init()
  78 {
  79   //
  80   //=================Create Materials and geometry
  81   //
  82   TObjArray *modules = gAlice->Modules();
  83   TIter next(modules);
  84   AliModule *detector;
  85   while((detector = (AliModule*)next())) {
  86     // Initialise detector materials and geometry
  87     detector->CreateMaterials();
  88     detector->CreateGeometry();
  89     detector->BuildGeometry();
  90     detector->Init();
  91   }
  92
  93   //Terminate building of geometry
  94   FinishGeometry();
  95 }
  96
  97 //____________________________________________________________________________
  98 void AliGeant3::ProcessRun(Int_t nevent)
  99 {
 100   //
 101   // Process the run
 102   //
 103   Int_t todo = TMath::Abs(nevent);
 104   for (Int_t i=0; i<todo; i++) {
 105   // Process one run (one run = one event)
 106      gAlice->BeginEvent();
 107      ProcessEvent();
 108      gAlice->FinishEvent();
 109   }
 110 }
 111
 112 //_____________________________________________________________________________
 113 void AliGeant3::ProcessEvent()
 114 {
 115   //
 116   // Process one event
 117   //
 118   Gtrigi();
 119   Gtrigc();
 120   Gtrig();
 121 }
 122
 123 //_____________________________________________________________________________
 124 void AliGeant3::SetColors()
 125 {
 126   //
 127   // Set the colors for all the volumes
 128   // this is done sequentially for all volumes
 129   // based on the number of their medium
 130   //
 131   Int_t kv, icol;
 132   Int_t jvolum=fGclink->jvolum;
 133   //Int_t jtmed=fGclink->jtmed;
 134   //Int_t jmate=fGclink->jmate;
 135   Int_t nvolum=fGcnum->nvolum;
 136   char name[5];
 137   //
 138   //    Now for all the volumes
 139   for(kv=1;kv<=nvolum;kv++) {
 140     //     Get the tracking medium
 141     Int_t itm=Int_t (fZq[fZlq[jvolum-kv]+4]);
 142     //     Get the material
 143     //Int_t ima=Int_t (fZq[fZlq[jtmed-itm]+6]);
 144     //     Get z
 145     //Float_t z=fZq[fZlq[jmate-ima]+7];
 146     //     Find color number
 147     //icol = Int_t(z)%6+2;
 148     //icol = 17+Int_t(z*150./92.);
 149     //icol = kv%6+2;
 150     icol = itm%6+2;
 151     strncpy(name,(char*)&fZiq[jvolum+kv],4);
 152     name[4]='\0';
 153     Gsatt(name,"COLO",icol);
 154   }
 155 }
 156
 157 //_____________________________________________________________________________
 158 //
 159 //                 Interfaces to Fortran
 160 //
 161 //_____________________________________________________________________________
 162
 163 extern "C" void type_of_call  rxgtrak (Int_t &mtrack, Int_t &ipart, Float_t *pmom,
 164                                        Float_t &e, Float_t *vpos, Float_t *polar,
 165                                        Float_t &tof)
 166 {
 167   //
 168   //     Fetches next track from the ROOT stack for transport. Called by the
 169   //     modified version of GTREVE.
 170   //
 171   //              Track number in the ROOT stack. If MTRACK=0 no
 172   //      mtrack  more tracks are left in the stack to be
 173   //              transported.
 174   //      ipart   Particle code in the GEANT conventions.
 175   //      pmom[3] Particle momentum in GeV/c
 176   //      e       Particle energy in GeV
 177   //      vpos[3] Particle position
 178   //      tof     Particle time of flight in seconds
 179   //
 180   Int_t pdg;
 181   gAlice->GetNextTrack(mtrack, pdg, pmom, e, vpos, polar, tof);
 182   ipart = gMC->IdFromPDG(pdg);
 183   mtrack++;
 184 }
 185
 186 //_____________________________________________________________________________
 187 extern "C" void type_of_call
 188 #ifndef WIN32
 189 rxstrak (Int_t &keep, Int_t &parent, Int_t &ipart, Float_t *pmom,
 190                Float_t *vpos, Float_t &tof, const char* cmech, Int_t &ntr, const int cmlen)
 191 #else
 192 rxstrak (Int_t &keep, Int_t &parent, Int_t &ipart, Float_t *pmom,
 193          Float_t *vpos, Float_t &tof, const char* cmech, const int cmlen,
 194          Int_t &ntr)
 195 #endif
 196 {
 197   //
 198   //     Fetches next track from the ROOT stack for transport. Called by GUKINE
 199   //     and GUSTEP.
 200   //
 201   //              Status of the track. If keep=0 the track is put
 202   //      keep    on the ROOT stack but it is not fetched for
 203   //              transport.
 204   //      parent  Parent track. If parent=0 the track is a primary.
 205   //              In GUSTEP the routine is normally called to store
 206   //              secondaries generated by the current track whose
 207   //              ROOT stack number is MTRACK (common SCKINE.
 208   //      ipart   Particle code in the GEANT conventions.
 209   //      pmom[3] Particle momentum in GeV/c
 210   //      vpos[3] Particle position
 211   //      tof     Particle time of flight in seconds
 212   //
 213   //      cmech   (CHARACTER*10) Particle origin. This field is user
 214   //              defined and it is not used inside the GALICE code.
 215   //      ntr     Number assigned to the particle in the ROOT stack.
 216   //
 217   char mecha[11];
 218   Float_t polar[3]={0.,0.,0.};
 219   for(int i=0; i<10 && i<cmlen; i++) mecha[i]=cmech[i];
 220   mecha[10]=0;
 221   Int_t pdg=gMC->PDGFromId(ipart);
 222   gAlice->SetTrack(keep, parent-1, pdg, pmom, vpos, polar, tof, mecha, ntr);
 223   ntr++;
 224 }
 225
 226 //_____________________________________________________________________________
 227 extern "C" void type_of_call  rxkeep(const Int_t &n)
 228 {
 229   if( NULL==gAlice ) exit(1);
 230
 231   if( n<=0 || n>gAlice->Particles()->GetEntries() )
 232     {
 233       printf("  Bad index n=%d must be 0<n<=%d\n",
 234              n,gAlice->Particles()->GetEntries());
 235       exit(1);
 236     }
 237
 238   ((TParticle*)(gAlice->Particles()->UncheckedAt(n-1)))->SetBit(kKeepBit);
 239 }
 240
 241 //_____________________________________________________________________________
 242 extern "C" void type_of_call  rxouth ()
 243 {
 244   //
 245   // Called by Gtreve at the end of each primary track
 246   //
 247   gAlice->FinishPrimary();
 248 }
 249
 250
 251 #ifndef WIN32
 252 #  define gudigi gudigi_
 253 #  define guhadr guhadr_
 254 #  define guout  guout_
 255 #  define guphad guphad_
 256 #  define gudcay gudcay_
 257 #  define guiget guiget_
 258 #  define guinme guinme_
 259 #  define guinti guinti_
 260 #  define gunear gunear_
 261 #  define guskip guskip_
 262 #  define guview guview_
 263 #  define gupara gupara_
 264 #  define gudtim gudtim_
 265 #  define guplsh guplsh_
 266 #  define gutrev gutrev_
 267 #  define gutrak gutrak_
 268 #  define guswim guswim_
 269 #  define gufld  gufld_
 270 #  define gustep gustep_
 271 #  define gukine gukine_
 272 #  define uglast uglast_
 273
 274 #  define gheish gheish_
 275 #  define flufin flufin_
 276 #  define gfmfin gfmfin_
 277 #  define gpghei gpghei_
 278 #  define fldist fldist_
 279 #  define gfmdis gfmdis_
 280 #  define ghelx3 ghelx3_
 281 #  define ghelix ghelix_
 282 #  define grkuta grkuta_
 283 #  define gtrack gtrack_
 284 #  define gtreveroot gtreveroot_
 285 #  define glast  glast_
 286
 287 #else
 288 #  define gudigi GUDIGI
 289 #  define guhadr GUHADR
 290 #  define guout  GUOUT
 291 #  define guphad GUPHAD
 292 #  define gudcay GUDCAY
 293 #  define guiget GUIGET
 294 #  define guinme GUINME
 295 #  define guinti GUINTI
 296 #  define gunear GUNEAR
 297 #  define guskip GUSKIP
 298 #  define guview GUVIEW
 299 #  define gupara GUPARA
 300 #  define gudtim GUDTIM
 301 #  define guplsh GUPLSH
 302 #  define gutrev GUTREV
 303 #  define gutrak GUTRAK
 304 #  define guswim GUSWIM
 305 #  define gufld  GUFLD
 306 #  define gustep GUSTEP
 307 #  define gukine GUKINE
 308 #  define uglast UGLAST
 309
 310 #  define gheish GHEISH
 311 #  define flufin FLUFIN
 312 #  define gfmfin GFMFIN
 313 #  define gpghei GPGHEI
 314 #  define fldist FLDIST
 315 #  define gfmdis GFMDIS
 316 #  define ghelx3 GHELX3
 317 #  define ghelix GHELIX
 318 #  define grkuta GRKUTA
 319 #  define gtrack GTRACK
 320 #  define gtreveroot GTREVEROOT
 321 #  define glast  GLAST
 322
 323 #endif
 324
 325 extern "C" type_of_call void gheish();
 326 extern "C" type_of_call void flufin();
 327 extern "C" type_of_call void gfmfin();
 328 extern "C" type_of_call void gpghei();
 329 extern "C" type_of_call void fldist();
 330 extern "C" type_of_call void gfmdis();
 331 extern "C" type_of_call void ghelx3(Float_t&, Float_t&, Float_t*, Float_t*);
 332 extern "C" type_of_call void ghelix(Float_t&, Float_t&, Float_t*, Float_t*);
 333 extern "C" type_of_call void grkuta(Float_t&, Float_t&, Float_t*, Float_t*);
 334 extern "C" type_of_call void gtrack();
 335 extern "C" type_of_call void gtreveroot();
 336 extern "C" type_of_call void glast();
 337
 338 extern "C" type_of_call {
 339
 340 //______________________________________________________________________
 341 void gudigi()
 342 {
 343 //
 344 //    ******************************************************************
 345 //    *                                                                *
 346 //    *       User routine to digitize one event                       *
 347 //    *                                                                *
 348 //    *    ==>Called by : GTRIG                                        *
 349 //    *                                                                *
 350 //    ******************************************************************
 351
 352 }
 353
 354
 355 //______________________________________________________________________
 356 void guhadr()
 357 {
 358 //
 359 //    ******************************************************************
 360 //    *                                                                *
 361 //    *       User routine to generate one hadronic interaction        *
 362 //    *                                                                *
 363 //    *    ==>Called by : GTHADR,GTNEUT                                *
 364 //    *                                                                *
 365 //    ******************************************************************
 366 //
 367 //
 368 //    ------------------------------------------------------------------
 369 //
 370       TGeant3* geant3 = (TGeant3*) gMC;
 371       Int_t ihadr=geant3->Gcphys()->ihadr;
 372       if (ihadr<4)       gheish();
 373       else if (ihadr==4) flufin();
 374       else               gfmfin();
 375 }
 376
 377 //______________________________________________________________________
 378 void guout()
 379 {
 380 //
 381 //    ******************************************************************
 382 //    *                                                                *
 383 //    *       User routine called at the end of each event             *
 384 //    *                                                                *
 385 //    *    ==>Called by : GTRIG                                        *
 386 //    *                                                                *
 387 //    ******************************************************************
 388 //
 389 //
 390 //    ------------------------------------------------------------------
 391 //
 392 }
 393
 394 //______________________________________________________________________
 395 void guphad()
 396 {
 397 //
 398 //    ******************************************************************
 399 //    *                                                                *
 400 //    *       User routine to compute Hadron. inter. probabilities     *
 401 //    *                                                                *
 402 //    *    ==>Called by : GTHADR,GTNEUT                                *
 403 //    *                                                                *
 404 //    ******************************************************************
 405 //
 406 //
 407 //    ------------------------------------------------------------------
 408 //
 409       TGeant3* geant3 = (TGeant3*) gMC;
 410       Int_t ihadr=geant3->Gcphys()->ihadr;
 411       if (ihadr<4)       gpghei();
 412       else if (ihadr==4) fldist();
 413       else               gfmdis();
 414 }
 415
 416 //______________________________________________________________________
 417 void gudcay()
 418 {
 419 //
 420 //    ******************************************************************
 421 //    *                                                                *
 422 //    *       User routine to decay particles                          *
 423 //    *                                                                *
 424 //    *    ==>Called by : GDECAY                                       *
 425 //    *                                                                *
 426 //    ******************************************************************
 427 //
 428 //
 429 //    ------------------------------------------------------------------
 430 //
 431 }
 432
 433 //______________________________________________________________________
 434 void guiget(Int_t&, Int_t&, Int_t&)
 435 {
 436 //
 437 //    ******************************************************************
 438 //    *                                                                *
 439 //    *       User routine for interactive control of GEANT            *
 440 //    *                                                                *
 441 //    *    ==>Called by : <GXINT>, GINCOM                              *
 442 //    *                                                                *
 443 //    ******************************************************************
 444 //
 445 //
 446 //    ------------------------------------------------------------------
 447 //
 448 }
 449
 450 //______________________________________________________________________
 451 void guinme(Float_t*, Int_t&, Float_t*, Int_t& IYES)
 452 {
 453 //
 454 //    **********************************************
 455 //    *                                            *
 456 //    *    USER ROUTINE TO PROVIDE GINME FUNCTION  *
 457 //    *    FOR ALL USER SHAPES IDENTIFIED BY THE   *
 458 //    *    SHAPE NUMBER SH. POINT IS GIVEN IN X    *
 459 //    *    THE PARAMETERS ARE GIVEN IN P. IYES IS  *
 460 //    *    RETURNED 1 IF POINT IS IN, 0 IF POINT   *
 461 //    *    IS OUT AND LESS THAN ZERO IF SHAPE      *
 462 //    *    NUMBER IS NOT SUPPORTED.                *
 463 //    *                                            *
 464 //    *    ==>Called by : GINME                    *
 465 //    *                                            *
 466 //    **********************************************
 467 //
 468       IYES=-1;
 469 }
 470
 471 //______________________________________________________________________
 472 void guinti()
 473 {
 474 //
 475 //    ******************************************************************
 476 //    *                                                                *
 477 //    *       User routine for interactive version                     *
 478 //    *                                                                *
 479 //    *    ==>Called by : <GXINT>,  GINTRI                             *
 480 //    *                                                                *
 481 //    ******************************************************************
 482 //
 483 //
 484 //    ------------------------------------------------------------------
 485 //
 486 }
 487
 488 //______________________________________________________________________
 489 void gunear(Int_t&, Int_t&, Float_t*, Int_t&)
 490 {
 491 //
 492 //    ******************************************************************
 493 //    *                                                                *
 494 //    *    User search                                                 *
 495 //    *       ISEARC to identify the given volume                      *
 496 //    *       ICALL  to identify the calling routine                   *
 497 //    *              1 GMEDIA like                                     *
 498 //    *              2 GNEXT like                                      *
 499 //    *       X      coordinates (+direction for ICALL=2)              *
 500 //    *       JNEAR  address of default list of neighbours             *
 501 //    *              (list to be overwriten by user)                   *
 502 //    *                                                                *
 503 //    *    Called by : GFTRAC, GINVOL, GTMEDI, GTNEXT, GNEXT, GMEDIA   *
 504 //    *                                                                *
 505 //    ******************************************************************
 506 //
 507 //
 508 //    ------------------------------------------------------------------
 509 //
 510 }
 511
 512 //______________________________________________________________________
 513 void guskip(Int_t& ISKIP)
 514 {
 515 //
 516 //    ******************************************************************
 517 //    *                                                                *
 518 //    *   User routine to skip unwanted tracks                         *
 519 //    *                                                                *
 520 //    *   Called by : GSSTAK                                           *
 521 //    *   Author    : F.Bruyant                                        *
 522 //    *                                                                *
 523 //    ******************************************************************
 524 //
 525 //
 526 //    ------------------------------------------------------------------
 527 //
 528       ISKIP = 0;
 529 }
 530
 531 //______________________________________________________________________
 532 void guswim(Float_t& CHARGE, Float_t& STEP, Float_t* VECT, Float_t* VOUT)
 533 {
 534 //
 535 //    ******************************************************************
 536 //    *                                                                *
 537 //    *       User routine to control tracking of one track            *
 538 //    *       in a magnetic field                                      *
 539 //    *                                                                *
 540 //    *    ==>Called by : GTELEC,GTHADR,GTMUON                         *
 541 //    *                                                                *
 542 //    ******************************************************************
 543 //
 544 //
 545 //    ------------------------------------------------------------------
 546 //
 547   TGeant3* geant3 = (TGeant3*) gMC;
 548   Int_t ifield=geant3->Gctmed()->ifield;
 549   Float_t fieldm=geant3->Gctmed()->fieldm;
 550
 551   if (ifield==3) {
 552     Float_t fldcharge = fieldm*CHARGE;
 553     ghelx3(fldcharge,STEP,VECT,VOUT);
 554   }
 555   else if (ifield==2) ghelix(CHARGE,STEP,VECT,VOUT);
 556   else                grkuta(CHARGE,STEP,VECT,VOUT);
 557 }
 558
 559 //______________________________________________________________________
 560 void guview(Int_t&, Int_t&, DEFCHARD, Int_t& DEFCHARL)
 561 {
 562 //
 563 //    ******************************************************************
 564 //    *                                                                *
 565 //    *       User routine for interactive version                     *
 566 //    *                                                                *
 567 //    *    ==>Called by : <GXINT>, GINC1                               *
 568 //    *                                                                *
 569 //    ******************************************************************
 570 //
 571 //
 572 //    ------------------------------------------------------------------
 573 //
 574 }
 575
 576 //______________________________________________________________________
 577 void gupara()
 578 {
 579 //
 580 //    ******************************************************************
 581 //    *                                                                *
 582 //    *       User routine called every time a particle falls below    *
 583 //    *       parametrization threshold. This routine should create    *
 584 //    *       the parametrization stack, and, when this is full,       *
 585 //    *       parametrize the shower and track the geantinos.          *
 586 //    *                                                                *
 587 //    *    ==>Called by : GTRACK                                       *
 588 //    *                                                                *
 589 //    ******************************************************************
 590 //
 591 //
 592 //    ------------------------------------------------------------------
 593 //
 594 }
 595
 596 //______________________________________________________________________
 597 Float_t gudtim(Float_t&, Float_t&, Int_t&, Int_t&)
 598 {
 599 //
 600 //    ******************************************************************
 601 //    *                                                                *
 602 //    *       User function called by GCDRIF to return drift time      *
 603 //    *                                                                *
 604 //    *    ==>Called by : GCDRIF                                       *
 605 //    *                                                                *
 606 //    ******************************************************************
 607 //
 608 //
 609 //    ------------------------------------------------------------------
 610 //
 611       return 0;
 612 }
 613
 614
 615 //______________________________________________________________________
 616 Float_t guplsh(Int_t&, Int_t&)
 617 {
 618 //
 619 //    ******************************************************************
 620 //    *                                                                *
 621 //    *                                                                *
 622 //    *    ==>Called by : GLISUR                                       *
 623 //    *                                                                *
 624 //    ******************************************************************
 625 //
 626 //
 627 //    ------------------------------------------------------------------
 628 //
 629 //
 630 //*** By default this defines perfect smoothness
 631       return 1;
 632 }
 633
 634 //______________________________________________________________________
 635 void gutrak()
 636 {
 637 //
 638 //    ******************************************************************
 639 //    *                                                                *
 640 //    *       User routine to control tracking of one track            *
 641 //    *                                                                *
 642 //    *    ==>Called by : GTREVE                                       *
 643 //    *                                                                *
 644 //    ******************************************************************
 645 //
 646 //
 647 //    ------------------------------------------------------------------
 648 //
 649      Int_t ndet = gAlice->Modules()->GetLast();
 650      TObjArray &dets = *gAlice->Modules();
 651      AliModule *module;
 652      Int_t i;
 653
 654      for(i=0; i<=ndet; i++)
 655        if((module = (AliModule*)dets[i]))
 656          module->PreTrack();
 657
 658      gtrack();
 659
 660      for(i=0; i<=ndet; i++)
 661        if((module = (AliModule*)dets[i]))
 662          module->PostTrack();
 663 }
 664
 665 //______________________________________________________________________
 666 void gutrev()
 667 {
 668 //
 669 //    ******************************************************************
 670 //    *                                                                *
 671 //    *       User routine to control tracking of one event            *
 672 //    *                                                                *
 673 //    *    ==>Called by : GTRIG                                        *
 674 //    *                                                                *
 675 //    ******************************************************************
 676 //
 677 //
 678 //    ------------------------------------------------------------------
 679 //
 680   gtreveroot();
 681 }
 682
 683
 684 //______________________________________________________________________
 685 void gufld(Float_t *x, Float_t *b)
 686 {
 687       if(gAlice->Field()) {
 688          gAlice->Field()->Field(x,b);
 689       } else {
 690          printf("No mag field defined!\n");
 691          b[0]=b[1]=b[2]=0;
 692       }
 693 }
 694
 695 //______________________________________________________________________
 696 void gustep()
 697 {
 698 //
 699 //    ******************************************************************
 700 //    *                                                                *
 701 //    *       User routine called at the end of each tracking step     *
 702 //    *       INWVOL is different from 0 when the track has reached    *
 703 //    *              a volume boundary                                 *
 704 //    *       ISTOP is different from 0 if the track has stopped       *
 705 //    *                                                                *
 706 //    *    ==>Called by : GTRACK                                       *
 707 //    *                                                                *
 708 //    ******************************************************************
 709 //
 710
 711
 712   TLorentzVector x;
 713   Float_t r;
 714   Int_t ipp, jk, id, nt;
 715   Float_t polar[3]={0,0,0};
 716   Float_t mom[3];
 717   const char *kChproc;
 718
 719   TGeant3* geant3 = (TGeant3*) gMC;
 720
 721   //     Stop particle if outside user defined tracking region
 722   gMC->TrackPosition(x);
 723   r=TMath::Sqrt(x[0]*x[0]+x[1]*x[1]);
 724   if (r > gAlice->TrackingRmax() || TMath::Abs(x[2]) > gAlice->TrackingZmax()) {
 725         gMC->StopTrack();
 726   }
 727
 728   // --- Add new created particles
 729   if (gMC->NSecondaries() > 0) {
 730     kChproc=gMC->ProdProcess();
 731     for (jk = 0; jk < geant3->Gcking()->ngkine; ++jk) {
 732       ipp = Int_t (geant3->Gcking()->gkin[jk][4]+0.5);
 733       // --- Skip neutrinos!
 734       if (ipp != 4) {
 735         gAlice->SetTrack(1,gAlice->CurrentTrack(),gMC->PDGFromId(ipp), geant3->Gcking()->gkin[jk],
 736                          geant3->Gckin3()->gpos[jk], polar,geant3->Gctrak()->tofg, kChproc, nt);
 737       }
 738     }
 739   }
 740   // Cherenkov photons here
 741   if ( geant3->Gckin2()->ngphot ) {
 742     for (jk = 0; jk < geant3->Gckin2()->ngphot; ++jk) {
 743       mom[0]=geant3->Gckin2()->xphot[jk][3]*geant3->Gckin2()->xphot[jk][6];
 744       mom[1]=geant3->Gckin2()->xphot[jk][4]*geant3->Gckin2()->xphot[jk][6];
 745       mom[2]=geant3->Gckin2()->xphot[jk][5]*geant3->Gckin2()->xphot[jk][6];
 746       gAlice->SetTrack(1, gAlice->CurrentTrack(), gMC->PDGFromId(50),
 747                        mom,                             //momentum
 748                        geant3->Gckin2()->xphot[jk],     //position
 749                        &geant3->Gckin2()->xphot[jk][7], //polarisation
 750                        geant3->Gckin2()->xphot[jk][10], //time of flight
 751                        "Cherenkov", nt);
 752       }
 753   }
 754   // --- Particle leaving the setup ?
 755   if (!gMC->IsTrackOut())
 756     if ((id=gAlice->DetFromMate(geant3->Gctmed()->numed)) >= 0) gAlice->StepManager(id);
 757
 758   // --- Standard GEANT debug routine
 759   if(geant3->Gcflag()->idebug) geant3->Gdebug();
 760 }
 761
 762 //______________________________________________________________________
 763 void gukine ()
 764 {
 765 //
 766 //    ******************************************************************
 767 //    *                                                                *
 768 //    *       Read or Generates Kinematics for primary tracks          *
 769 //    *                                                                *
 770 //    *    ==>Called by : GTRIG                                        *
 771 //    *                                                                *
 772 //    ******************************************************************
 773 //
 774 //
 775 //    ------------------------------------------------------------------
 776 //
 777   gAlice->Generator()->Generate();
 778 }
 779
 780
 781 //______________________________________________________________________
 782 void uglast()
 783 {
 784 //
 785 //    ******************************************************************
 786 //    *                                                                *
 787 //    *       User routine called at the end of the run                *
 788 //    *                                                                *
 789 //    *    ==>Called by : GRUN                                         *
 790 //    *                                                                *
 791 //    ******************************************************************
 792 //
 793 //
 794 }
 795 }
 796