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

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/*
$Log$
Revision 1.9  1999/09/29 09:24:31  fca
Introduction of the Copyright and cvs Log

*/

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