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