[u/mrichter/AliRoot.git] / TGeant3 / gucode.cxx

#include "AliCallf77.h"
#include "TGeant3.h"
#include "AliRun.h"

#ifndef WIN32
#  define gudigi gudigi_
#  define guhadr guhadr_
#  define guout  guout_
#  define guphad guphad_
#  define gudcay gudcay_
#  define guiget guiget_
#  define guinme guinme_
#  define guinti guinti_
#  define gunear gunear_
#  define guskip guskip_
#  define guview guview_
#  define gupara gupara_
#  define gudtim gudtim_
#  define guplsh guplsh_
#  define gutrev gutrev_
#  define gutrak gutrak_
#  define guswim guswim_
#  define gufld  gufld_
#  define gustep gustep_
#  define gukine gukine_
#  define uglast uglast_

#  define gheish gheish_
#  define flufin flufin_
#  define gfmfin gfmfin_
#  define gpghei gpghei_
#  define fldist fldist_
#  define gfmdis gfmdis_
#  define ghelx3 ghelx3_
#  define ghelix ghelix_
#  define grkuta grkuta_
#  define gtrack gtrack_
#  define gtreve_root gtreve_root_
#  define glast  glast_

#else
#  define gudigi GUDIGI
#  define guhadr GUHADR
#  define guout  GUOUT
#  define guphad GUPHAD
#  define gudcay GUDCAY
#  define guiget GUIGET
#  define guinme GUINME
#  define guinti GUINTI
#  define gunear GUNEAR
#  define guskip GUSKIP
#  define guview GUVIEW
#  define gupara GUPARA
#  define gudtim GUDTIM
#  define guplsh GUPLSH
#  define gutrev GUTREV
#  define gutrak GUTRAK
#  define guswim GUSWIM
#  define gufld  GUFLD
#  define gustep GUSTEP
#  define gukine GUKINE
#  define uglast UGLAST

#  define gheish GHEISH
#  define flufin FLUFIN
#  define gfmfin GFMFIN
#  define gpghei GPGHEI
#  define fldist FLDIST
#  define gfmdis GFMDIS
#  define ghelx3 GHELX3
#  define ghelix GHELIX
#  define grkuta GRKUTA
#  define gtrack GTRACK
#  define gtreve_root GTREVE_ROOT
#  define glast  GLAST

#endif

extern "C" type_of_call void gheish();
extern "C" type_of_call void flufin();
extern "C" type_of_call void gfmfin();
extern "C" type_of_call void gpghei();
extern "C" type_of_call void fldist();
extern "C" type_of_call void gfmdis();
extern "C" type_of_call void ghelx3(Float_t&, Float_t&, Float_t*, Float_t*);
extern "C" type_of_call void ghelix(Float_t&, Float_t&, Float_t*, Float_t*);
extern "C" type_of_call void grkuta(Float_t&, Float_t&, Float_t*, Float_t*);
extern "C" type_of_call void gtrack();
extern "C" type_of_call void gtreve_root();
extern "C" type_of_call void glast();

extern "C" type_of_call {

//______________________________________________________________________
void gudigi() 
{
//
//    ******************************************************************
//    *                                                                *
//    *       User routine to digitize one event                       *
//    *                                                                *
//    *    ==>Called by : GTRIG                                        *
//    *                                                                *
//    ******************************************************************

}


//______________________________________________________________________
void guhadr()
{
//
//    ******************************************************************
//    *                                                                *
//    *       User routine to generate one hadronic interaction        *
//    *                                                                *
//    *    ==>Called by : GTHADR,GTNEUT                                *
//    *                                                                *
//    ******************************************************************
//
//
//    ------------------------------------------------------------------
//
      TGeant3* geant3 = (TGeant3*) gMC;
      Int_t ihadr=geant3->Gcphys()->ihadr;
      if (ihadr<4)       gheish();
      else if (ihadr==4) flufin();
      else               gfmfin();
}

//______________________________________________________________________
void guout()
{
//
//    ******************************************************************
//    *                                                                *
//    *       User routine called at the end of each event             *
//    *                                                                *
//    *    ==>Called by : GTRIG                                        *
//    *                                                                *
//    ******************************************************************
//
//
//    ------------------------------------------------------------------
//
}

//______________________________________________________________________
void guphad()
{
//
//    ******************************************************************
//    *                                                                *
//    *       User routine to compute Hadron. inter. probabilities     *
//    *                                                                *
//    *    ==>Called by : GTHADR,GTNEUT                                *
//    *                                                                *
//    ******************************************************************
//
//
//    ------------------------------------------------------------------
//
      TGeant3* geant3 = (TGeant3*) gMC;
      Int_t ihadr=geant3->Gcphys()->ihadr;
      if (ihadr<4)       gpghei();
      else if (ihadr==4) fldist();
      else               gfmdis();
}

//______________________________________________________________________
void gudcay()
{
//
//    ******************************************************************
//    *                                                                *
//    *       User routine to decay particles                          *
//    *                                                                *
//    *    ==>Called by : GDECAY                                       *
//    *                                                                *
//    ******************************************************************
//
//
//    ------------------------------------------------------------------
//
}

//______________________________________________________________________
void guiget(Int_t&, Int_t&, Int_t&)
{
//
//    ******************************************************************
//    *                                                                *
//    *       User routine for interactive control of GEANT            *
//    *                                                                *
//    *    ==>Called by : <GXINT>, GINCOM                              *
//    *                                                                *
//    ******************************************************************
//
//
//    ------------------------------------------------------------------
//
}

//______________________________________________________________________
void guinme(Float_t*, Int_t&, Float_t*, Int_t& IYES)
{
//
//    **********************************************
//    *                                            *
//    *    USER ROUTINE TO PROVIDE GINME FUNCTION  *
//    *    FOR ALL USER SHAPES IDENTIFIED BY THE   *
//    *    SHAPE NUMBER SH. POINT IS GIVEN IN X    *
//    *    THE PARAMETERS ARE GIVEN IN P. IYES IS  *
//    *    RETURNED 1 IF POINT IS IN, 0 IF POINT   *
//    *    IS OUT AND LESS THAN ZERO IF SHAPE      *
//    *    NUMBER IS NOT SUPPORTED.                *
//    *                                            *
//    *    ==>Called by : GINME                    *
//    *                                            *
//    **********************************************
//
      IYES=-1;
}

//______________________________________________________________________
void guinti()
{
//
//    ******************************************************************
//    *                                                                *
//    *       User routine for interactive version                     *
//    *                                                                *
//    *    ==>Called by : <GXINT>,  GINTRI                             *
//    *                                                                *
//    ******************************************************************
//
//
//    ------------------------------------------------------------------
//
}

//______________________________________________________________________
void gunear(Int_t&, Int_t&, Float_t*, Int_t&)
{
//
//    ******************************************************************
//    *                                                                *
//    *    User search                                                 *
//    *       ISEARC to identify the given volume                      *
//    *       ICALL  to identify the calling routine                   *
//    *              1 GMEDIA like                                     *
//    *              2 GNEXT like                                      *
//    *       X      coordinates (+direction for ICALL=2)              *
//    *       JNEAR  address of default list of neighbours             *
//    *              (list to be overwriten by user)                   *
//    *                                                                *
//    *    Called by : GFTRAC, GINVOL, GTMEDI, GTNEXT, GNEXT, GMEDIA   *
//    *                                                                *
//    ******************************************************************
//
//
//    ------------------------------------------------------------------
//
}

//______________________________________________________________________
void guskip(Int_t& ISKIP)
{
//
//    ******************************************************************
//    *                                                                *
//    *   User routine to skip unwanted tracks                         *
//    *                                                                *
//    *   Called by : GSSTAK                                           *
//    *   Author    : F.Bruyant                                        *
//    *                                                                *
//    ******************************************************************
//
//
//    ------------------------------------------------------------------
//
      ISKIP = 0;
}

//______________________________________________________________________
void guswim(Float_t& CHARGE, Float_t& STEP, Float_t* VECT, Float_t* VOUT)
{
//
//    ******************************************************************
//    *                                                                *
//    *       User routine to control tracking of one track            *
//    *       in a magnetic field                                      *
//    *                                                                *
//    *    ==>Called by : GTELEC,GTHADR,GTMUON                         *
//    *                                                                *
//    ******************************************************************
//
//
//    ------------------------------------------------------------------
//
  TGeant3* geant3 = (TGeant3*) gMC;
  Int_t ifield=geant3->Gctmed()->ifield;
  Float_t fieldm=geant3->Gctmed()->fieldm;

  if (ifield==3) {
    Float_t fldcharge = fieldm*CHARGE;
    ghelx3(fldcharge,STEP,VECT,VOUT);
  }
  else if (ifield==2) ghelix(CHARGE,STEP,VECT,VOUT);
  else                grkuta(CHARGE,STEP,VECT,VOUT);
}

//______________________________________________________________________
void guview(Int_t&, Int_t&, DEFCHARD, Int_t& DEFCHARL)
{
//
//    ******************************************************************
//    *                                                                *
//    *       User routine for interactive version                     *
//    *                                                                *
//    *    ==>Called by : <GXINT>, GINC1                               *
//    *                                                                *
//    ******************************************************************
//
//
//    ------------------------------------------------------------------
//
}

//______________________________________________________________________
void gupara()
{
//
//    ******************************************************************
//    *                                                                *
//    *       User routine called every time a particle falls below    *
//    *       parametrization threshold. This routine should create    *
//    *       the parametrization stack, and, when this is full,       *
//    *       parametrize the shower and track the geantinos.          *
//    *                                                                *
//    *    ==>Called by : GTRACK                                       *
//    *                                                                *
//    ******************************************************************
//
//
//    ------------------------------------------------------------------
//
}

//______________________________________________________________________
Float_t gudtim(Float_t&, Float_t&, Int_t&, Int_t&)
{
//
//    ******************************************************************
//    *                                                                *
//    *       User function called by GCDRIF to return drift time      *
//    *                                                                *
//    *    ==>Called by : GCDRIF                                       *
//    *                                                                *
//    ******************************************************************
//
//
//    ------------------------------------------------------------------
//
      return 0;
}


//______________________________________________________________________
Float_t guplsh(Int_t&, Int_t&)
{
//
//    ******************************************************************
//    *                                                                *
//    *                                                                *
//    *    ==>Called by : GLISUR                                       *
//    *                                                                *
//    ******************************************************************
//
//
//    ------------------------------------------------------------------
//
//
//*** By default this defines perfect smoothness
      return 1;
}

//______________________________________________________________________
void gutrak()
{
//
//    ******************************************************************
//    *                                                                *
//    *       User routine to control tracking of one track            *
//    *                                                                *
//    *    ==>Called by : GTREVE                                       *
//    *                                                                *
//    ******************************************************************
//
//
//    ------------------------------------------------------------------
//
     Int_t ndet = gAlice->Modules()->GetLast();
     TObjArray &dets = *gAlice->Modules();
     AliModule *module;
     Int_t i;

     for(i=0; i<=ndet; i++)
       if((module = (AliModule*)dets[i]))
	 module->PreTrack();

     gtrack();

     for(i=0; i<=ndet; i++)
       if((module = (AliModule*)dets[i]))
	 module->PostTrack();
}

//______________________________________________________________________
void gutrev()
{
//
//    ******************************************************************
//    *                                                                *
//    *       User routine to control tracking of one event            *
//    *                                                                *
//    *    ==>Called by : GTRIG                                        *
//    *                                                                *
//    ******************************************************************
//
//
//    ------------------------------------------------------------------
//
  gtreve_root();
}


//______________________________________________________________________
void gufld(Float_t *x, Float_t *b)
{
      if(gAlice->Field()) {
         gAlice->Field()->Field(x,b);
      } else {
         printf("No mag field defined!\n");
         b[0]=b[1]=b[2]=0;
      }
}

//______________________________________________________________________
void gustep()
{
//
//    ******************************************************************
//    *                                                                *
//    *       User routine called at the end of each tracking step     *
//    *       INWVOL is different from 0 when the track has reached    *
//    *              a volume boundary                                 *
//    *       ISTOP is different from 0 if the track has stopped       *
//    *                                                                *
//    *    ==>Called by : GTRACK                                       *
//    *                                                                *
//    ******************************************************************
//


  TLorentzVector x;
  Float_t r;
  Int_t ipp, jk, id, nt;
  Float_t polar[3]={0,0,0};
  Float_t mom[3];
  char chproc[11];
  
  // --- Standard GEANT debug routine 
  TGeant3* geant3 = (TGeant3*) gMC;
  if(geant3->Gcflag()->idebug) geant3->Gdebug();

  //     Stop particle if outside user defined tracking region 
  gMC->TrackPosition(x);
  r=TMath::Sqrt(x[0]*x[0]+x[1]*x[1]);
  if (r > gAlice->TrackingRmax() || TMath::Abs(x[2]) > gAlice->TrackingZmax()) {
	gMC->StopTrack();
  }
  // --- Add new created particles 
  if (gMC->NSecondaries() > 0) {
    gMC->ProdProcess(chproc);
    for (jk = 0; jk < geant3->Gcking()->ngkine; ++jk) {
      ipp = Int_t (geant3->Gcking()->gkin[jk][4]+0.5);
      // --- Skip neutrinos! 
      if (ipp != 4) {
	gAlice->SetTrack(1,gAlice->CurrentTrack(),gMC->PDGFromId(ipp), geant3->Gcking()->gkin[jk], 
			 geant3->Gckin3()->gpos[jk], polar,geant3->Gctrak()->tofg, chproc, nt);
      }
    }
  }
  // Cherenkov photons here
  if ( geant3->Gckin2()->ngphot ) {
    for (jk = 0; jk < geant3->Gckin2()->ngphot; ++jk) {
      mom[0]=geant3->Gckin2()->xphot[jk][3]*geant3->Gckin2()->xphot[jk][6];
      mom[1]=geant3->Gckin2()->xphot[jk][4]*geant3->Gckin2()->xphot[jk][6];
      mom[2]=geant3->Gckin2()->xphot[jk][5]*geant3->Gckin2()->xphot[jk][6];
      gAlice->SetTrack(1, gAlice->CurrentTrack(), gMC->PDGFromId(50),
		       mom,                             //momentum
		       geant3->Gckin2()->xphot[jk],     //position
		       &geant3->Gckin2()->xphot[jk][7], //polarisation
		       geant3->Gckin2()->xphot[jk][10], //time of flight
		       "Cherenkov", nt);
      }
  }
  // --- Particle leaving the setup ?
  if (!gMC->IsTrackOut()) 
    if ((id=gAlice->DetFromMate(geant3->Gctmed()->numed)) >= 0) gAlice->StepManager(id);
}

//______________________________________________________________________
void gukine ()
{
//
//    ******************************************************************
//    *                                                                *
//    *       Read or Generates Kinematics for primary tracks          *
//    *                                                                *
//    *    ==>Called by : GTRIG                                        *
//    *                                                                *
//    ******************************************************************
//
//
//    ------------------------------------------------------------------
//
  gAlice->Generator()->Generate();
}


//______________________________________________________________________
void uglast()
{
//
//    ******************************************************************
//    *                                                                *
//    *       User routine called at the end of the run                *
//    *                                                                *
//    *    ==>Called by : GRUN                                         *
//    *                                                                *
//    ******************************************************************
//
//
}
}
Commit	Line	Data
fe4da5cc	1	#include "AliCallf77.h"
	2	#include "TGeant3.h"
	3	#include "AliRun.h"
	4
	5	#ifndef WIN32
	6	# define gudigi gudigi_
	7	# define guhadr guhadr_
	8	# define guout guout_
	9	# define guphad guphad_
	10	# define gudcay gudcay_
	11	# define guiget guiget_
	12	# define guinme guinme_
	13	# define guinti guinti_
	14	# define gunear gunear_
	15	# define guskip guskip_
	16	# define guview guview_
	17	# define gupara gupara_
	18	# define gudtim gudtim_
	19	# define guplsh guplsh_
	20	# define gutrev gutrev_
	21	# define gutrak gutrak_
	22	# define guswim guswim_
	23	# define gufld gufld_
	24	# define gustep gustep_
	25	# define gukine gukine_
	26	# define uglast uglast_
	27
	28	# define gheish gheish_
	29	# define flufin flufin_
	30	# define gfmfin gfmfin_
	31	# define gpghei gpghei_
	32	# define fldist fldist_
	33	# define gfmdis gfmdis_
	34	# define ghelx3 ghelx3_
	35	# define ghelix ghelix_
	36	# define grkuta grkuta_
	37	# define gtrack gtrack_
a7e5a30e	38	# define gtreve_root gtreve_root_
fe4da5cc	39	# define glast glast_
	40
	41	#else
	42	# define gudigi GUDIGI
	43	# define guhadr GUHADR
	44	# define guout GUOUT
	45	# define guphad GUPHAD
	46	# define gudcay GUDCAY
	47	# define guiget GUIGET
	48	# define guinme GUINME
	49	# define guinti GUINTI
	50	# define gunear GUNEAR
	51	# define guskip GUSKIP
	52	# define guview GUVIEW
	53	# define gupara GUPARA
	54	# define gudtim GUDTIM
	55	# define guplsh GUPLSH
	56	# define gutrev GUTREV
	57	# define gutrak GUTRAK
	58	# define guswim GUSWIM
	59	# define gufld GUFLD
	60	# define gustep GUSTEP
	61	# define gukine GUKINE
	62	# define uglast UGLAST
	63
	64	# define gheish GHEISH
	65	# define flufin FLUFIN
	66	# define gfmfin GFMFIN
	67	# define gpghei GPGHEI
	68	# define fldist FLDIST
	69	# define gfmdis GFMDIS
	70	# define ghelx3 GHELX3
	71	# define ghelix GHELIX
	72	# define grkuta GRKUTA
	73	# define gtrack GTRACK
a7e5a30e	74	# define gtreve_root GTREVE_ROOT
fe4da5cc	75	# define glast GLAST
	76
	77	#endif
	78
	79	extern "C" type_of_call void gheish();
	80	extern "C" type_of_call void flufin();
	81	extern "C" type_of_call void gfmfin();
	82	extern "C" type_of_call void gpghei();
	83	extern "C" type_of_call void fldist();
	84	extern "C" type_of_call void gfmdis();
	85	extern "C" type_of_call void ghelx3(Float_t&, Float_t&, Float_t, Float_t);
	86	extern "C" type_of_call void ghelix(Float_t&, Float_t&, Float_t, Float_t);
	87	extern "C" type_of_call void grkuta(Float_t&, Float_t&, Float_t, Float_t);
	88	extern "C" type_of_call void gtrack();
a7e5a30e	89	extern "C" type_of_call void gtreve_root();
fe4da5cc	90	extern "C" type_of_call void glast();
fe4da5cc	91
fe4da5cc	92	extern "C" type_of_call {
	93
	94	//______________________________________________________________________
	95	void gudigi()
	96	{
	97	//
	98	// ******************************************************************
	99	// * *
	100	// * User routine to digitize one event *
	101	// * *
	102	// * ==>Called by : GTRIG *
	103	// * *
	104	// ******************************************************************
	105
	106	}
	107
	108
	109	//______________________________________________________________________
	110	void guhadr()
	111	{
	112	//
	113	// ******************************************************************
	114	// * *
	115	// * User routine to generate one hadronic interaction *
	116	// * *
	117	// * ==>Called by : GTHADR,GTNEUT *
	118	// * *
	119	// ******************************************************************
	120	//
	121	//
	122	// ------------------------------------------------------------------
	123	//
cfce8870	124	TGeant3* geant3 = (TGeant3*) gMC;
fe4da5cc	125	Int_t ihadr=geant3->Gcphys()->ihadr;
	126	if (ihadr<4) gheish();
	127	else if (ihadr==4) flufin();
	128	else gfmfin();
	129	}
	130
	131	//______________________________________________________________________
	132	void guout()
	133	{
	134	//
	135	// ******************************************************************
	136	// * *
	137	// * User routine called at the end of each event *
	138	// * *
	139	// * ==>Called by : GTRIG *
	140	// * *
	141	// ******************************************************************
	142	//
	143	//
	144	// ------------------------------------------------------------------
	145	//
fe4da5cc	146	}
	147
	148	//______________________________________________________________________
	149	void guphad()
	150	{
	151	//
	152	// ******************************************************************
	153	// * *
	154	// * User routine to compute Hadron. inter. probabilities *
	155	// * *
	156	// * ==>Called by : GTHADR,GTNEUT *
	157	// * *
	158	// ******************************************************************
	159	//
	160	//
	161	// ------------------------------------------------------------------
	162	//
cfce8870	163	TGeant3* geant3 = (TGeant3*) gMC;
fe4da5cc	164	Int_t ihadr=geant3->Gcphys()->ihadr;
	165	if (ihadr<4) gpghei();
	166	else if (ihadr==4) fldist();
	167	else gfmdis();
	168	}
	169
	170	//______________________________________________________________________
	171	void gudcay()
	172	{
	173	//
	174	// ******************************************************************
	175	// * *
	176	// * User routine to decay particles *
	177	// * *
	178	// * ==>Called by : GDECAY *
	179	// * *
	180	// ******************************************************************
	181	//
	182	//
	183	// ------------------------------------------------------------------
	184	//
	185	}
	186
	187	//______________________________________________________________________
	188	void guiget(Int_t&, Int_t&, Int_t&)
	189	{
	190	//
	191	// ******************************************************************
	192	// * *
	193	// * User routine for interactive control of GEANT *
	194	// * *
	195	// * ==>Called by : <GXINT>, GINCOM *
	196	// * *
	197	// ******************************************************************
	198	//
	199	//
	200	// ------------------------------------------------------------------
	201	//
	202	}
	203
	204	//______________________________________________________________________
	205	void guinme(Float_t, Int_t&, Float_t, Int_t& IYES)
	206	{
	207	//
	208	// **********************************************
	209	// * *
	210	// * USER ROUTINE TO PROVIDE GINME FUNCTION *
	211	// * FOR ALL USER SHAPES IDENTIFIED BY THE *
	212	// * SHAPE NUMBER SH. POINT IS GIVEN IN X *
	213	// * THE PARAMETERS ARE GIVEN IN P. IYES IS *
	214	// * RETURNED 1 IF POINT IS IN, 0 IF POINT *
	215	// * IS OUT AND LESS THAN ZERO IF SHAPE *
	216	// * NUMBER IS NOT SUPPORTED. *
	217	// * *
	218	// * ==>Called by : GINME *
	219	// * *
	220	// **********************************************
	221	//
	222	IYES=-1;
	223	}
	224
	225	//______________________________________________________________________
	226	void guinti()
	227	{
228	//
229	// ******************************************************************
230	// * *
231	// * User routine for interactive version *
232	// * *
233	// * ==>Called by : <GXINT>, GINTRI *
234	// * *
235	// ******************************************************************
236	//
237	//
238	// ------------------------------------------------------------------
239	//
240	}
241
242	//______________________________________________________________________
243	void gunear(Int_t&, Int_t&, Float_t*, Int_t&)
244	{
245	//
246	// ******************************************************************
247	// * *
248	// * User search *
249	// * ISEARC to identify the given volume *
250	// * ICALL to identify the calling routine *
251	// * 1 GMEDIA like *
252	// * 2 GNEXT like *
253	// * X coordinates (+direction for ICALL=2) *
254	// * JNEAR address of default list of neighbours *
255	// * (list to be overwriten by user) *
256	// * *
257	// * Called by : GFTRAC, GINVOL, GTMEDI, GTNEXT, GNEXT, GMEDIA *
258	// * *
259	// ******************************************************************
260	//
261	//
262	// ------------------------------------------------------------------
263	//
264	}
265
266	//______________________________________________________________________
267	void guskip(Int_t& ISKIP)
268	{
269	//
270	// ******************************************************************
271	// * *
272	// * User routine to skip unwanted tracks *
273	// * *
274	// * Called by : GSSTAK *
275	// * Author : F.Bruyant *
276	// * *
277	// ******************************************************************
278	//
279	//
280	// ------------------------------------------------------------------
281	//
282	ISKIP = 0;
283	}
284
285	//______________________________________________________________________
286	void guswim(Float_t& CHARGE, Float_t& STEP, Float_t* VECT, Float_t* VOUT)
287	{
288	//
289	// ******************************************************************
290	// * *
291	// * User routine to control tracking of one track *
292	// * in a magnetic field *
293	// * *
294	// * ==>Called by : GTELEC,GTHADR,GTMUON *
295	// * *
296	// ******************************************************************
297	//
298	//
299	// ------------------------------------------------------------------
300	//
cfce8870	301	TGeant3* geant3 = (TGeant3*) gMC;
fe4da5cc	302	Int_t ifield=geant3->Gctmed()->ifield;
	303	Float_t fieldm=geant3->Gctmed()->fieldm;
	304
	305	if (ifield==3) {
	306	Float_t fldcharge = fieldm*CHARGE;
	307	ghelx3(fldcharge,STEP,VECT,VOUT);
	308	}
	309	else if (ifield==2) ghelix(CHARGE,STEP,VECT,VOUT);
	310	else grkuta(CHARGE,STEP,VECT,VOUT);
	311	}
	312
	313	//______________________________________________________________________
	314	void guview(Int_t&, Int_t&, DEFCHARD, Int_t& DEFCHARL)
	315	{
	316	//
	317	// ******************************************************************
	318	// * *
	319	// * User routine for interactive version *
	320	// * *
	321	// * ==>Called by : <GXINT>, GINC1 *
	322	// * *
	323	// ******************************************************************
	324	//
	325	//
	326	// ------------------------------------------------------------------
	327	//
	328	}
	329
	330	//______________________________________________________________________
	331	void gupara()
	332	{
	333	//
	334	// ******************************************************************
	335	// * *
	336	// * User routine called every time a particle falls below *
	337	// * parametrization threshold. This routine should create *
	338	// * the parametrization stack, and, when this is full, *
	339	// * parametrize the shower and track the geantinos. *
	340	// * *
	341	// * ==>Called by : GTRACK *
	342	// * *
	343	// ******************************************************************
	344	//
	345	//
	346	// ------------------------------------------------------------------
	347	//
	348	}
	349
	350	//______________________________________________________________________
	351	Float_t gudtim(Float_t&, Float_t&, Int_t&, Int_t&)
	352	{
	353	//
	354	// ******************************************************************
	355	// * *
	356	// * User function called by GCDRIF to return drift time *
	357	// * *
	358	// * ==>Called by : GCDRIF *
	359	// * *
	360	// ******************************************************************
	361	//
	362	//
	363	// ------------------------------------------------------------------
	364	//
	365	return 0;
366	}
367
368
369	//______________________________________________________________________
370	Float_t guplsh(Int_t&, Int_t&)
371	{
372	//
373	// ******************************************************************
374	// * *
375	// * *
376	// * ==>Called by : GLISUR *
377	// * *
378	// ******************************************************************
379	//
380	//
381	// ------------------------------------------------------------------
382	//
383	//
384	//*** By default this defines perfect smoothness
385	return 1;
386	}
387
388	//______________________________________________________________________
389	void gutrak()
390	{
391	//
392	// ******************************************************************
393	// * *
394	// * User routine to control tracking of one track *
395	// * *
396	// * ==>Called by : GTREVE *
397	// * *
398	// ******************************************************************
399	//
400	//
401	// ------------------------------------------------------------------
402	//
24380615	403	Int_t ndet = gAlice->Modules()->GetLast();
	404	TObjArray &dets = *gAlice->Modules();
	405	AliModule *module;
fe4da5cc	406	Int_t i;
	407
	408	for(i=0; i<=ndet; i++)
24380615	409	if((module = (AliModule*)dets[i]))
24380615	410	module->PreTrack();
fe4da5cc	411
	412	gtrack();
	413
	414	for(i=0; i<=ndet; i++)
24380615	415	if((module = (AliModule*)dets[i]))
24380615	416	module->PostTrack();
fe4da5cc	417	}
	418
	419	//______________________________________________________________________
	420	void gutrev()
	421	{
	422	//
	423	// ******************************************************************
	424	// * *
	425	// * User routine to control tracking of one event *
	426	// * *
	427	// * ==>Called by : GTRIG *
	428	// * *
	429	// ******************************************************************
	430	//
	431	//
	432	// ------------------------------------------------------------------
	433	//
a7e5a30e	434	gtreve_root();
fe4da5cc	435	}
	436
	437
	438	//______________________________________________________________________
	439	void gufld(Float_t x, Float_t b)
	440	{
	441	if(gAlice->Field()) {
	442	gAlice->Field()->Field(x,b);
	443	} else {
	444	printf("No mag field defined!\n");
	445	b[0]=b[1]=b[2]=0;
	446	}
	447	}
	448
	449	//______________________________________________________________________
	450	void gustep()
	451	{
	452	//
	453	// ******************************************************************
	454	// * *
	455	// * User routine called at the end of each tracking step *
	456	// * INWVOL is different from 0 when the track has reached *
	457	// * a volume boundary *
	458	// * ISTOP is different from 0 if the track has stopped *
	459	// * *
	460	// * ==>Called by : GTRACK *
	461	// * *
	462	// ******************************************************************
	463	//
	464
fe4da5cc	465
0a6d8768	466	TLorentzVector x;
fe4da5cc	467	Float_t r;
	468	Int_t ipp, jk, id, nt;
	469	Float_t polar[3]={0,0,0};
ad265d61	470	Float_t mom[3];
fe4da5cc	471	char chproc[11];
	472
	473	// --- Standard GEANT debug routine
cfce8870	474	TGeant3* geant3 = (TGeant3*) gMC;
fe4da5cc	475	if(geant3->Gcflag()->idebug) geant3->Gdebug();
	476
	477	// Stop particle if outside user defined tracking region
cfce8870	478	gMC->TrackPosition(x);
fe4da5cc	479	r=TMath::Sqrt(x[0]x[0]+x[1]x[1]);
fe4da5cc	480	if (r > gAlice->TrackingRmax() \|\| TMath::Abs(x[2]) > gAlice->TrackingZmax()) {
cfce8870	481	gMC->StopTrack();
fe4da5cc	482	}
fe4da5cc	483	// --- Add new created particles
cfce8870	484	if (gMC->NSecondaries() > 0) {
cfce8870	485	gMC->ProdProcess(chproc);
fe4da5cc	486	for (jk = 0; jk < geant3->Gcking()->ngkine; ++jk) {
	487	ipp = Int_t (geant3->Gcking()->gkin[jk][4]+0.5);
	488	// --- Skip neutrinos!
	489	if (ipp != 4) {
1578254f	490	gAlice->SetTrack(1,gAlice->CurrentTrack(),gMC->PDGFromId(ipp), geant3->Gcking()->gkin[jk],
fe4da5cc	491	geant3->Gckin3()->gpos[jk], polar,geant3->Gctrak()->tofg, chproc, nt);
	492	}
	493	}
	494	}
ad265d61	495	// Cherenkov photons here
	496	if ( geant3->Gckin2()->ngphot ) {
	497	for (jk = 0; jk < geant3->Gckin2()->ngphot; ++jk) {
	498	mom[0]=geant3->Gckin2()->xphot[jk][3]*geant3->Gckin2()->xphot[jk][6];
	499	mom[1]=geant3->Gckin2()->xphot[jk][4]*geant3->Gckin2()->xphot[jk][6];
	500	mom[2]=geant3->Gckin2()->xphot[jk][5]*geant3->Gckin2()->xphot[jk][6];
	501	gAlice->SetTrack(1, gAlice->CurrentTrack(), gMC->PDGFromId(50),
	502	mom, //momentum
	503	geant3->Gckin2()->xphot[jk], //position
	504	&geant3->Gckin2()->xphot[jk][7], //polarisation
	505	geant3->Gckin2()->xphot[jk][10], //time of flight
	506	"Cherenkov", nt);
	507	}
	508	}
fe4da5cc	509	// --- Particle leaving the setup ?
0a6d8768	510	if (!gMC->IsTrackOut())
fe4da5cc	511	if ((id=gAlice->DetFromMate(geant3->Gctmed()->numed)) >= 0) gAlice->StepManager(id);
	512	}
	513
	514	//______________________________________________________________________
	515	void gukine ()
	516	{
	517	//
	518	// ******************************************************************
	519	// * *
	520	// * Read or Generates Kinematics for primary tracks *
	521	// * *
	522	// * ==>Called by : GTRIG *
	523	// * *
	524	// ******************************************************************
	525	//
	526	//
	527	// ------------------------------------------------------------------
	528	//
	529	gAlice->Generator()->Generate();
	530	}
	531
	532
	533	//______________________________________________________________________
	534	void uglast()
	535	{
	536	//
	537	// ******************************************************************
	538	// * *
	539	// * User routine called at the end of the run *
	540	// * *
	541	// * ==>Called by : GRUN *
	542	// * *
	543	// ******************************************************************
	544	//
	545	//
	546	}
	547	}