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