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