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