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