+/**************************************************************************
+ * 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.29 2000/07/11 18:24:59 fca
+Coding convention corrections + few minor bug fixes
+
+Revision 1.28 2000/06/29 10:51:55 morsch
+Add some charmed and bottom baryons to the particle list (TDatabasePDG). This
+is needed by Hijing. Should be part of a future review of TDatabasePDG.
+
+Revision 1.27 2000/06/21 17:40:15 fca
+Adding possibility to set ISTRA, PAI model
+
+Revision 1.26 2000/05/16 13:10:41 fca
+New method IsNewTrack and fix for a problem in Father-Daughter relations
+
+Revision 1.25 2000/04/07 11:12:35 fca
+G4 compatibility changes
+
+Revision 1.24 2000/02/28 21:03:57 fca
+Some additions to improve the compatibility with G4
+
+Revision 1.23 2000/02/23 16:25:25 fca
+AliVMC and AliGeant3 classes introduced
+ReadEuclid moved from AliRun to AliModule
+
+Revision 1.22 2000/01/18 15:40:13 morsch
+Interface to GEANT3 routines GFTMAT, GBRELM and GPRELM added
+Define geant particle type 51: Feedback Photon with Cherenkov photon properties.
+
+Revision 1.21 2000/01/17 19:41:17 fca
+Add SetERAN function
+
+Revision 1.20 2000/01/12 11:29:27 fca
+Close material file
+
+Revision 1.19 1999/12/17 09:03:12 fca
+Introduce a names array
+
+Revision 1.18 1999/11/26 16:55:39 fca
+Reimplement CurrentVolName() to avoid memory leaks
+
+Revision 1.17 1999/11/03 16:58:28 fca
+Correct source of address violation in creating character string
+
+Revision 1.16 1999/11/03 13:17:08 fca
+Have ProdProcess return const char*
+
+Revision 1.15 1999/10/26 06:04:50 fca
+Introduce TLorentzVector in AliMC::GetSecondary. Thanks to I.Hrivnacova
+
+Revision 1.14 1999/09/29 09:24:30 fca
+Introduction of the Copyright and cvs Log
+
+*/
+
///////////////////////////////////////////////////////////////////////////////
// //
// Interface Class to the Geant3.21 MonteCarlo //
#include "TROOT.h"
#include "THIGZ.h"
#include "ctype.h"
+#include <TDatabasePDG.h>
#include "AliCallf77.h"
#ifndef WIN32
# define gfmate gfmate_
# define gfpart gfpart_
# define gftmed gftmed_
+# define gftmat gftmat_
# define gmate gmate_
# define gpart gpart_
# define gsdk gsdk_
# define gsxyz gsxyz_
# define gtrack gtrack_
# define gtreve gtreve_
+# define gtreveroot gtreveroot_
# define grndm grndm_
# define grndmq grndmq_
# define gdtom gdtom_
# define gckmat gckmat_
# define geditv geditv_
# define mzdrop mzdrop_
+
+# define ertrak ertrak_
+# define ertrgo ertrgo_
# define setbomb setbomb_
# define setclip setclip_
# define gcomad gcomad_
+# define gbrelm gbrelm_
+# define gprelm gprelm_
#else
# define gzebra GZEBRA
# define grfile GRFILE
# define gfmate GFMATE
# define gfpart GFPART
# define gftmed GFTMED
+# define gftmat GFTMAT
# define gmate GMATE
# define gpart GPART
# define gsdk GSDK
# define gsxyz GSXYZ
# define gtrack GTRACK
# define gtreve GTREVE
+# define gtreveroot GTREVEROOT
# define grndm GRNDM
# define grndmq GRNDMQ
# define gdtom GDTOM
# define geditv GEDITV
# define mzdrop MZDROP
+# define ertrak ERTRAK
+# define ertrgo ERTRGO
+
# define setbomb SETBOMB
# define setclip SETCLIP
# define gcomad GCOMAD
+# define gbrelm GBRELM
+# define gprelm GPRELM
+
#endif
//____________________________________________________________________________
void type_of_call gtreve();
+ void type_of_call gtreveroot();
+
void type_of_call grndm(Float_t *, const Int_t &);
void type_of_call grndmq(Int_t &, Int_t &, const Int_t &,
Float_t &, Float_t &, Float_t &, Float_t &,
Float_t &, Float_t &, Float_t *, Int_t * DEFCHARL);
+ void type_of_call gftmat(const Int_t&, const Int_t&, DEFCHARD, const Int_t&,
+ Float_t*, Float_t*
+ ,Float_t *, Int_t & DEFCHARL);
+
void type_of_call gsmate(const Int_t&, DEFCHARD, Float_t &, Float_t &,
Float_t &, Float_t &, Float_t &, Float_t *,
Int_t & DEFCHARL);
void type_of_call setclip(DEFCHARD, Float_t &,Float_t &,Float_t &,Float_t &,
Float_t &, Float_t & DEFCHARL);
void type_of_call gcomad(DEFCHARD, Int_t*& DEFCHARL);
+
+ void type_of_call ertrak(const Float_t *const x1, const Float_t *const p1,
+ const Float_t *x2, const Float_t *p2,
+ const Int_t &ipa, DEFCHARD DEFCHARL);
+
+ void type_of_call ertrgo();
+
+ float type_of_call gbrelm(const Float_t &z, const Float_t& t, const Float_t& cut);
+ float type_of_call gprelm(const Float_t &z, const Float_t& t, const Float_t& cut);
}
//
ClassImp(TGeant3)
//____________________________________________________________________________
-TGeant3::TGeant3() : AliMC()
+TGeant3::TGeant3()
{
//
// Default constructor
//
// Load Address of Geant3 commons
LoadAddress();
+ //
+ // Zero number of particles
+ fNPDGCodes=0;
}
//____________________________________________________________________________
//
// Set range of current drawing pad to 20x20 cm
//
- if (!higz) {
+ if (!gHigz) {
new THIGZ(defSize);
gdinit();
}
- higz->Range(0,0,20,20);
+ gHigz->Range(0,0,20,20);
}
//____________________________________________________________________________
//
// Initialise HIGZ
//
- if (!higz) {
+ if (!gHigz) {
new THIGZ(defSize);
gdinit();
}
gcomad(PASSCHARD("GCBANK"),(int*&) fGcbank PASSCHARL("GCBANK"));
gcomad(PASSCHARD("GCLINK"),(int*&) fGclink PASSCHARL("GCLINK"));
gcomad(PASSCHARD("GCCUTS"),(int*&) fGccuts PASSCHARL("GCCUTS"));
+ gcomad(PASSCHARD("GCMULO"),(int*&) fGcmulo PASSCHARL("GCMULO"));
gcomad(PASSCHARD("GCFLAG"),(int*&) fGcflag PASSCHARL("GCFLAG"));
gcomad(PASSCHARD("GCKINE"),(int*&) fGckine PASSCHARL("GCKINE"));
gcomad(PASSCHARD("GCKING"),(int*&) fGcking PASSCHARL("GCKING"));
gcomad(PASSCHARD("GCNUM"), (int*&) fGcnum PASSCHARL("GCNUM"));
gcomad(PASSCHARD("GCSETS"),(int*&) fGcsets PASSCHARL("GCSETS"));
gcomad(PASSCHARD("GCPHYS"),(int*&) fGcphys PASSCHARL("GCPHYS"));
+ gcomad(PASSCHARD("GCPHLT"),(int*&) fGcphlt PASSCHARL("GCPHLT"));
gcomad(PASSCHARD("GCOPTI"),(int*&) fGcopti PASSCHARL("GCOPTI"));
gcomad(PASSCHARD("GCTLIT"),(int*&) fGctlit PASSCHARL("GCTLIT"));
gcomad(PASSCHARD("GCVDMA"),(int*&) fGcvdma PASSCHARL("GCVDMA"));
+ // Commons for GEANE
+ gcomad(PASSCHARD("ERTRIO"),(int*&) fErtrio PASSCHARL("ERTRIO"));
+ gcomad(PASSCHARD("EROPTS"),(int*&) fEropts PASSCHARL("EROPTS"));
+ gcomad(PASSCHARD("EROPTC"),(int*&) fEroptc PASSCHARL("EROPTC"));
+ gcomad(PASSCHARD("ERWORK"),(int*&) fErwork PASSCHARL("ERWORK"));
+
+ // Variables for ZEBRA store
gcomad(PASSCHARD("IQ"), addr PASSCHARL("IQ"));
fZiq = addr;
gcomad(PASSCHARD("LQ"), addr PASSCHARL("LQ"));
fNextVol=fGcvolu->nlevel;
}
+//____________________________________________________________________________
+void TGeant3::FinishGeometry()
+{
+ //Close the geometry structure
+ Ggclos();
+}
+
//____________________________________________________________________________
Int_t TGeant3::NextVolUp(Text_t *name, Int_t ©)
{
fNextVol--;
if(fNextVol>=0) {
gname=fGcvolu->names[fNextVol];
- strncpy(name,(char *) &gname, 4);
- name[4]='\0';
copy=fGcvolu->number[fNextVol];
i=fGcvolu->lvolum[fNextVol];
+ name = fVolNames[i-1];
if(gname == fZiq[fGclink->jvolum+i]) return i;
else printf("GeomTree: Volume %s not found in bank\n",name);
}
}
//_____________________________________________________________________________
-Int_t TGeant3::CurrentVol(Text_t *name, Int_t ©) const
+void TGeant3::BuildPhysics()
+{
+ Gphysi();
+}
+
+//_____________________________________________________________________________
+Int_t TGeant3::CurrentVolID(Int_t ©) const
{
//
- // Returns the current volume ID, name and copy number
- // if name=0 no name is returned
+ // Returns the current volume ID and copy number
//
Int_t i, gname;
if( (i=fGcvolu->nlevel-1) < 0 ) {
- printf("CurrentVol: stack depth %d\n",fGcvolu->nlevel);
+ Warning("CurrentVolID","Stack depth only %d\n",fGcvolu->nlevel);
} else {
gname=fGcvolu->names[i];
- if(name) {
- strncpy(name,(char *) &gname, 4);
- name[4]='\0';
- }
copy=fGcvolu->number[i];
i=fGcvolu->lvolum[i];
if(gname == fZiq[fGclink->jvolum+i]) return i;
- else printf("CurrentVol: Volume %s not found in bank\n",name);
+ else Warning("CurrentVolID","Volume %4s not found\n",(char*)&gname);
}
return 0;
}
//_____________________________________________________________________________
-Int_t TGeant3::CurrentVolOff(Int_t off, Text_t *name, Int_t ©) const
+Int_t TGeant3::CurrentVolOffID(Int_t off, Int_t ©) const
{
//
// Return the current volume "off" upward in the geometrical tree
- // ID, name and copy number
- // if name=0 no name is returned
+ // ID and copy number
//
Int_t i, gname;
if( (i=fGcvolu->nlevel-off-1) < 0 ) {
- printf("CurrentVolOff: Offset requested %d but stack depth %d\n",off,fGcvolu->nlevel);
+ Warning("CurrentVolOffID","Offset requested %d but stack depth %d\n",
+ off,fGcvolu->nlevel);
} else {
gname=fGcvolu->names[i];
- if(name) {
- strncpy(name,(char *) &gname, 4);
- name[4]='\0';
- }
copy=fGcvolu->number[i];
i=fGcvolu->lvolum[i];
if(gname == fZiq[fGclink->jvolum+i]) return i;
- else printf("CurrentVolOff: Volume %s not found in bank\n",name);
+ else Warning("CurrentVolOffID","Volume %4s not found\n",(char*)&gname);
}
return 0;
}
//_____________________________________________________________________________
-Int_t TGeant3::VolId(Text_t *name) const
+const char* TGeant3::CurrentVolName() const
+{
+ //
+ // Returns the current volume name
+ //
+ Int_t i, gname;
+ if( (i=fGcvolu->nlevel-1) < 0 ) {
+ Warning("CurrentVolName","Stack depth %d\n",fGcvolu->nlevel);
+ } else {
+ gname=fGcvolu->names[i];
+ i=fGcvolu->lvolum[i];
+ if(gname == fZiq[fGclink->jvolum+i]) return fVolNames[i-1];
+ else Warning("CurrentVolName","Volume %4s not found\n",(char*) &gname);
+ }
+ return 0;
+}
+
+//_____________________________________________________________________________
+const char* TGeant3::CurrentVolOffName(Int_t off) const
+{
+ //
+ // Return the current volume "off" upward in the geometrical tree
+ // ID, name and copy number
+ // if name=0 no name is returned
+ //
+ Int_t i, gname;
+ if( (i=fGcvolu->nlevel-off-1) < 0 ) {
+ Warning("CurrentVolOffName",
+ "Offset requested %d but stack depth %d\n",off,fGcvolu->nlevel);
+ } else {
+ gname=fGcvolu->names[i];
+ i=fGcvolu->lvolum[i];
+ if(gname == fZiq[fGclink->jvolum+i]) return fVolNames[i-1];
+ else Warning("CurrentVolOffName","Volume %4s not found\n",(char*)&gname);
+ }
+ return 0;
+}
+
+//_____________________________________________________________________________
+Int_t TGeant3::IdFromPDG(Int_t pdg) const
+{
+ //
+ // Return Geant3 code from PDG and pseudo ENDF code
+
+ for(Int_t i=0;i<fNPDGCodes;++i)
+ if(pdg==fPDGCode[i]) return i;
+ return -1;
+}
+
+//_____________________________________________________________________________
+Int_t TGeant3::PDGFromId(Int_t id) const
+{
+ if(id>0 && id<fNPDGCodes) return fPDGCode[id];
+ else return -1;
+}
+
+//_____________________________________________________________________________
+void TGeant3::DefineParticles()
+{
+ //
+ // Define standard Geant 3 particles
+ Gpart();
+ //
+ // Load standard numbers for GEANT particles and PDG conversion
+ fPDGCode[fNPDGCodes++]=-99; // 0 = unused location
+ fPDGCode[fNPDGCodes++]=22; // 1 = photon
+ fPDGCode[fNPDGCodes++]=-11; // 2 = positron
+ fPDGCode[fNPDGCodes++]=11; // 3 = electron
+ fPDGCode[fNPDGCodes++]=12; // 4 = neutrino e
+ fPDGCode[fNPDGCodes++]=-13; // 5 = muon +
+ fPDGCode[fNPDGCodes++]=13; // 6 = muon -
+ fPDGCode[fNPDGCodes++]=111; // 7 = pi0
+ fPDGCode[fNPDGCodes++]=211; // 8 = pi+
+ fPDGCode[fNPDGCodes++]=-211; // 9 = pi-
+ fPDGCode[fNPDGCodes++]=130; // 10 = Kaon Long
+ fPDGCode[fNPDGCodes++]=321; // 11 = Kaon +
+ fPDGCode[fNPDGCodes++]=-321; // 12 = Kaon -
+ fPDGCode[fNPDGCodes++]=2112; // 13 = Neutron
+ fPDGCode[fNPDGCodes++]=2212; // 14 = Proton
+ fPDGCode[fNPDGCodes++]=-2212; // 15 = Anti Proton
+ fPDGCode[fNPDGCodes++]=310; // 16 = Kaon Short
+ fPDGCode[fNPDGCodes++]=221; // 17 = Eta
+ fPDGCode[fNPDGCodes++]=3122; // 18 = Lambda
+ fPDGCode[fNPDGCodes++]=3222; // 19 = Sigma +
+ fPDGCode[fNPDGCodes++]=3212; // 20 = Sigma 0
+ fPDGCode[fNPDGCodes++]=3112; // 21 = Sigma -
+ fPDGCode[fNPDGCodes++]=3322; // 22 = Xi0
+ fPDGCode[fNPDGCodes++]=3312; // 23 = Xi-
+ fPDGCode[fNPDGCodes++]=3334; // 24 = Omega-
+ fPDGCode[fNPDGCodes++]=-2112; // 25 = Anti Proton
+ fPDGCode[fNPDGCodes++]=-3122; // 26 = Anti Proton
+ fPDGCode[fNPDGCodes++]=-3222; // 27 = Anti Sigma -
+ fPDGCode[fNPDGCodes++]=-3212; // 28 = Anti Sigma 0
+ fPDGCode[fNPDGCodes++]=-3112; // 29 = Anti Sigma 0
+ fPDGCode[fNPDGCodes++]=-3322; // 30 = Anti Xi 0
+ fPDGCode[fNPDGCodes++]=-3312; // 31 = Anti Xi +
+ fPDGCode[fNPDGCodes++]=-3334; // 32 = Anti Omega +
+
+
+ Int_t mode[6];
+ Int_t kz, ipa;
+ Float_t bratio[6];
+
+ /* --- Define additional particles */
+ Gspart(33, "OMEGA(782)", 3, 0.782, 0., 7.836e-23);
+ fPDGCode[fNPDGCodes++]=223; // 33 = Omega(782)
+
+ Gspart(34, "PHI(1020)", 3, 1.019, 0., 1.486e-22);
+ fPDGCode[fNPDGCodes++]=333; // 34 = PHI (1020)
+
+ Gspart(35, "D +", 4, 1.87, 1., 1.066e-12);
+ fPDGCode[fNPDGCodes++]=411; // 35 = D+
+
+ Gspart(36, "D -", 4, 1.87, -1., 1.066e-12);
+ fPDGCode[fNPDGCodes++]=-411; // 36 = D-
+
+ Gspart(37, "D 0", 3, 1.865, 0., 4.2e-13);
+ fPDGCode[fNPDGCodes++]=421; // 37 = D0
+
+ Gspart(38, "ANTI D 0", 3, 1.865, 0., 4.2e-13);
+ fPDGCode[fNPDGCodes++]=-421; // 38 = D0 bar
+
+ fPDGCode[fNPDGCodes++]=-99; // 39 = unassigned
+
+ fPDGCode[fNPDGCodes++]=-99; // 40 = unassigned
+
+ fPDGCode[fNPDGCodes++]=-99; // 41 = unassigned
+
+ Gspart(42, "RHO +", 4, 0.768, 1., 4.353e-24);
+ fPDGCode[fNPDGCodes++]=213; // 42 = RHO+
+
+ Gspart(43, "RHO -", 4, 0.768, -1., 4.353e-24);
+ fPDGCode[fNPDGCodes++]=-213; // 40 = RHO-
+
+ Gspart(44, "RHO 0", 3, 0.768, 0., 4.353e-24);
+ fPDGCode[fNPDGCodes++]=113; // 37 = D0
+
+ //
+ // Use ENDF-6 mapping for ions = 10000*z+10*a+iso
+ // and add 1 000 000
+ // and numbers above 5 000 000 for special applications
+ //
+
+ const Int_t kion=10000000;
+
+ const Int_t kspe=50000000;
+
+ TDatabasePDG *pdgDB = TDatabasePDG::Instance();
+
+ const Double_t autogev=0.9314943228;
+ const Double_t hslash = 1.0545726663e-27;
+ const Double_t erggev = 1/1.6021773349e-3;
+ const Double_t hshgev = hslash*erggev;
+ const Double_t yearstosec = 3600*24*365.25;
+//
+// Bottom mesons
+// mass and life-time from PDG
+ pdgDB->AddParticle("B(s)*0","B(s)*0",
+ 5.4163, kTRUE, 0.047, +0.,"Meson", 533);
+
+ pdgDB->AddParticle("B(s)*0 bar","B(s)*0 bar",
+ 5.4163, kTRUE, 0.047, -0.,"Meson", -533);
+
+// Charmed baryons
+//
+// value for mass used by Hijing
+ pdgDB->AddParticle("Sigma(c)*+","Sigma(c)*+",
+ 2.4536, kTRUE, -1., +1.,"Baryon", 4214);
+
+ pdgDB->AddParticle("Sigma(c)*-","Sigma(c)*-",
+ 2.4536, kTRUE, -1., -1.,"Baryon", -4214);
+// equivalent to 4312 ? Hijing uses m=2.55
+ pdgDB->AddParticle("Xsi(c)0","Xsi(c)0",
+ 2.4703, kTRUE, -1., +0.,"Baryon", 4132);
+
+ pdgDB->AddParticle("Xsi(c)0 bar","Xsi(c)0 bar",
+ 2.4703, kTRUE, -1., -0.,"Baryon", -4132);
+// equivalent to 4322 ? Hijing uses m=2.55
+ pdgDB->AddParticle("Xi(c)+","Xi(c)+",
+ 2.4656, kFALSE, -1., +1.,"Baryon", 4232);
+
+ pdgDB->AddParticle("Xi(c)-","Xi(c)-",
+ 2.4656, kFALSE, -1., -1.,"Baryon", -4232);
+// mass values from Hijing
+
+ pdgDB->AddParticle("Xsi(c)*0","Xsi(c)*0",
+ 2.63, kTRUE, -1., +0.,"Baryon", 4314);
+
+ pdgDB->AddParticle("Xsi(c)*0 bar","Xsi(c)*0 bar",
+ 2.63, kTRUE, -1., -0.,"Baryon", -4314);
+
+ pdgDB->AddParticle("Xsi(c)*+","Xsi(c)*+",
+ 2.63, kTRUE, -1., +1.,"Baryon", 4324);
+
+ pdgDB->AddParticle("Xsi(c)*-","Xsi(c)*-",
+ 2.63, kTRUE, -1., -1.,"Baryon", -4324);
+
+// pdg mass value, Hijing uses m=2.73.
+ pdgDB->AddParticle("Omega(c)0","Omega(c)0",
+ 2.7040, kFALSE, hshgev/0.064e-12, +0.,"Baryon", 4332);
+
+ pdgDB->AddParticle("Omega(c)0 bar","Omega(c)0 bar",
+ 2.7040, kFALSE, hshgev/0.064e-12, -0.,"Baryon", -4332);
+// mass value from Hijing
+ pdgDB->AddParticle("Omega(c)*0","Omega(c)*0",
+ 2.8000, kFALSE, -1., +0.,"Baryon", 4334);
+
+ pdgDB->AddParticle("Omega(c)*0 bar","Omega(c)*0",
+ 2.8000, kFALSE, -1., -0.,"Baryon", -4334);
+
+// Bottom baryons
+//
+// mass value from Hijing
+ pdgDB->AddParticle("Sigma(b)*+","Sigma(b)*+",
+ 5.8100, kFALSE, -1., +1.,"Baryon", 5224);
+
+ pdgDB->AddParticle("Sigma(b)*-","Sigma(b)*-",
+ 5.8100, kFALSE, -1., -1.,"Baryon", -5224);
+
+//
+//
+ pdgDB->AddParticle("Deuteron","Deuteron",2*autogev+8.071e-3,kTRUE,
+ 0,1,"Ion",kion+10020);
+ fPDGCode[fNPDGCodes++]=kion+10020; // 45 = Deuteron
+
+ pdgDB->AddParticle("Triton","Triton",3*autogev+14.931e-3,kFALSE,
+ hshgev/(12.33*yearstosec),1,"Ion",kion+10030);
+ fPDGCode[fNPDGCodes++]=kion+10030; // 46 = Triton
+
+ pdgDB->AddParticle("Alpha","Alpha",4*autogev+2.424e-3,kTRUE,
+ hshgev/(12.33*yearstosec),2,"Ion",kion+20040);
+ fPDGCode[fNPDGCodes++]=kion+20040; // 47 = Alpha
+
+ fPDGCode[fNPDGCodes++]=0; // 48 = geantino mapped to rootino
+
+ pdgDB->AddParticle("HE3","HE3",3*autogev+14.931e-3,kFALSE,
+ 0,2,"Ion",kion+20030);
+ fPDGCode[fNPDGCodes++]=kion+20030; // 49 = HE3
+
+ pdgDB->AddParticle("Cherenkov","Cherenkov",0,kFALSE,
+ 0,0,"Special",kspe+50);
+ fPDGCode[fNPDGCodes++]=kspe+50; // 50 = Cherenkov
+
+ Gspart(51, "FeedbackPhoton", 7, 0., 0.,1.e20 );
+ pdgDB->AddParticle("FeedbackPhoton","FeedbackPhoton",0,kFALSE,
+ 0,0,"Special",kspe+51);
+ fPDGCode[fNPDGCodes++]=kspe+51; // 51 = FeedbackPhoton
+
+/* --- Define additional decay modes --- */
+/* --- omega(783) --- */
+ for (kz = 0; kz < 6; ++kz) {
+ bratio[kz] = 0.;
+ mode[kz] = 0;
+ }
+ ipa = 33;
+ bratio[0] = 89.;
+ bratio[1] = 8.5;
+ bratio[2] = 2.5;
+ mode[0] = 70809;
+ mode[1] = 107;
+ mode[2] = 908;
+ Gsdk(ipa, bratio, mode);
+/* --- phi(1020) --- */
+ for (kz = 0; kz < 6; ++kz) {
+ bratio[kz] = 0.;
+ mode[kz] = 0;
+ }
+ ipa = 34;
+ bratio[0] = 49.;
+ bratio[1] = 34.4;
+ bratio[2] = 12.9;
+ bratio[3] = 2.4;
+ bratio[4] = 1.3;
+ mode[0] = 1112;
+ mode[1] = 1610;
+ mode[2] = 4407;
+ mode[3] = 90807;
+ mode[4] = 1701;
+ Gsdk(ipa, bratio, mode);
+/* --- D+ --- */
+ for (kz = 0; kz < 6; ++kz) {
+ bratio[kz] = 0.;
+ mode[kz] = 0;
+ }
+ ipa = 35;
+ bratio[0] = 25.;
+ bratio[1] = 25.;
+ bratio[2] = 25.;
+ bratio[3] = 25.;
+ mode[0] = 80809;
+ mode[1] = 120808;
+ mode[2] = 111208;
+ mode[3] = 110809;
+ Gsdk(ipa, bratio, mode);
+/* --- D- --- */
+ for (kz = 0; kz < 6; ++kz) {
+ bratio[kz] = 0.;
+ mode[kz] = 0;
+ }
+ ipa = 36;
+ bratio[0] = 25.;
+ bratio[1] = 25.;
+ bratio[2] = 25.;
+ bratio[3] = 25.;
+ mode[0] = 90908;
+ mode[1] = 110909;
+ mode[2] = 121109;
+ mode[3] = 120908;
+ Gsdk(ipa, bratio, mode);
+/* --- D0 --- */
+ for (kz = 0; kz < 6; ++kz) {
+ bratio[kz] = 0.;
+ mode[kz] = 0;
+ }
+ ipa = 37;
+ bratio[0] = 33.;
+ bratio[1] = 33.;
+ bratio[2] = 33.;
+ mode[0] = 809;
+ mode[1] = 1208;
+ mode[2] = 1112;
+ Gsdk(ipa, bratio, mode);
+/* --- Anti D0 --- */
+ for (kz = 0; kz < 6; ++kz) {
+ bratio[kz] = 0.;
+ mode[kz] = 0;
+ }
+ ipa = 38;
+ bratio[0] = 33.;
+ bratio[1] = 33.;
+ bratio[2] = 33.;
+ mode[0] = 809;
+ mode[1] = 1109;
+ mode[2] = 1112;
+ Gsdk(ipa, bratio, mode);
+/* --- rho+ --- */
+ for (kz = 0; kz < 6; ++kz) {
+ bratio[kz] = 0.;
+ mode[kz] = 0;
+ }
+ ipa = 42;
+ bratio[0] = 100.;
+ mode[0] = 807;
+ Gsdk(ipa, bratio, mode);
+/* --- rho- --- */
+ for (kz = 0; kz < 6; ++kz) {
+ bratio[kz] = 0.;
+ mode[kz] = 0;
+ }
+ ipa = 43;
+ bratio[0] = 100.;
+ mode[0] = 907;
+ Gsdk(ipa, bratio, mode);
+/* --- rho0 --- */
+ for (kz = 0; kz < 6; ++kz) {
+ bratio[kz] = 0.;
+ mode[kz] = 0;
+ }
+ ipa = 44;
+ bratio[0] = 100.;
+ mode[0] = 707;
+ Gsdk(ipa, bratio, mode);
+ /*
+// --- jpsi ---
+ for (kz = 0; kz < 6; ++kz) {
+ bratio[kz] = 0.;
+ mode[kz] = 0;
+ }
+ ipa = 113;
+ bratio[0] = 50.;
+ bratio[1] = 50.;
+ mode[0] = 506;
+ mode[1] = 605;
+ Gsdk(ipa, bratio, mode);
+// --- upsilon ---
+ ipa = 114;
+ Gsdk(ipa, bratio, mode);
+// --- phi ---
+ ipa = 115;
+ Gsdk(ipa, bratio, mode);
+ */
+
+}
+
+//_____________________________________________________________________________
+Int_t TGeant3::VolId(const Text_t *name) const
{
//
// Return the unique numeric identifier for volume name
//
// Return the volume name given the volume identifier
//
- static char name[5];
if(id<1 || id > fGcnum->nvolum || fGclink->jvolum<=0)
- strcpy(name,"NULL");
+ return fVolNames[fGcnum->nvolum];
else
- strncpy(name,(char *)&fZiq[fGclink->jvolum+id],4);
- name[4]='\0';
- return name;
+ return fVolNames[id-1];
+}
+
+//_____________________________________________________________________________
+void TGeant3::SetCut(const char* cutName, Float_t cutValue)
+{
+ if(!strcmp(cutName,"CUTGAM"))
+ fGccuts->cutgam=cutValue;
+ else if(!strcmp(cutName,"CUTGAM"))
+ fGccuts->cutele=cutValue;
+ else if(!strcmp(cutName,"CUTELE"))
+ fGccuts->cutneu=cutValue;
+ else if(!strcmp(cutName,"CUTHAD"))
+ fGccuts->cuthad=cutValue;
+ else if(!strcmp(cutName,"CUTMUO"))
+ fGccuts->cutmuo=cutValue;
+ else if(!strcmp(cutName,"BCUTE"))
+ fGccuts->bcute=cutValue;
+ else if(!strcmp(cutName,"BCUTM"))
+ fGccuts->bcutm=cutValue;
+ else if(!strcmp(cutName,"DCUTE"))
+ fGccuts->dcute=cutValue;
+ else if(!strcmp(cutName,"DCUTM"))
+ fGccuts->dcutm=cutValue;
+ else if(!strcmp(cutName,"PPCUTM"))
+ fGccuts->ppcutm=cutValue;
+ else if(!strcmp(cutName,"TOFMAX"))
+ fGccuts->tofmax=cutValue;
+ else Warning("SetCut","Cut %s not implemented\n",cutName);
+}
+
+//_____________________________________________________________________________
+void TGeant3::SetProcess(const char* flagName, Int_t flagValue)
+{
+ if(!strcmp(flagName,"PAIR"))
+ fGcphys->ipair=flagValue;
+ else if(!strcmp(flagName,"COMP"))
+ fGcphys->icomp=flagValue;
+ else if(!strcmp(flagName,"PHOT"))
+ fGcphys->iphot=flagValue;
+ else if(!strcmp(flagName,"PFIS"))
+ fGcphys->ipfis=flagValue;
+ else if(!strcmp(flagName,"DRAY"))
+ fGcphys->idray=flagValue;
+ else if(!strcmp(flagName,"ANNI"))
+ fGcphys->ianni=flagValue;
+ else if(!strcmp(flagName,"BREM"))
+ fGcphys->ibrem=flagValue;
+ else if(!strcmp(flagName,"HADR"))
+ fGcphys->ihadr=flagValue;
+ else if(!strcmp(flagName,"MUNU"))
+ fGcphys->imunu=flagValue;
+ else if(!strcmp(flagName,"DCAY"))
+ fGcphys->idcay=flagValue;
+ else if(!strcmp(flagName,"LOSS"))
+ fGcphys->iloss=flagValue;
+ else if(!strcmp(flagName,"MULS"))
+ fGcphys->imuls=flagValue;
+ else if(!strcmp(flagName,"RAYL"))
+ fGcphys->irayl=flagValue;
+ else if(!strcmp(flagName,"STRA"))
+ fGcphlt->istra=flagValue;
+ else if(!strcmp(flagName,"SYNC"))
+ fGcphlt->isync=flagValue;
+ else Warning("SetFlag","Flag %s not implemented\n",flagName);
+}
+
+//_____________________________________________________________________________
+Float_t TGeant3::Xsec(char* reac, Float_t /* energy */,
+ Int_t part, Int_t /* mate */)
+{
+ if(!strcmp(reac,"PHOT"))
+ {
+ if(part!=22) {
+ Error("Xsec","Can calculate photoelectric only for photons\n");
+ }
+ }
+ return 0;
}
//_____________________________________________________________________________
-void TGeant3::TrackPosition(Float_t *xyz) const
+void TGeant3::TrackPosition(TLorentzVector &xyz) const
{
//
// Return the current position in the master reference frame of the
xyz[0]=fGctrak->vect[0];
xyz[1]=fGctrak->vect[1];
xyz[2]=fGctrak->vect[2];
+ xyz[3]=fGctrak->tofg;
}
//_____________________________________________________________________________
}
//_____________________________________________________________________________
-void TGeant3::TrackMomentum(Float_t *xyz) const
+void TGeant3::TrackMomentum(TLorentzVector &xyz) const
{
//
// Return the direction and the momentum (GeV/c) of the track
// currently being transported
//
- xyz[0]=fGctrak->vect[3];
- xyz[1]=fGctrak->vect[4];
- xyz[2]=fGctrak->vect[5];
- xyz[3]=fGctrak->vect[6];
+ Double_t ptot=fGctrak->vect[6];
+ xyz[0]=fGctrak->vect[3]*ptot;
+ xyz[1]=fGctrak->vect[4]*ptot;
+ xyz[2]=fGctrak->vect[5]*ptot;
+ xyz[3]=fGctrak->getot;
}
//_____________________________________________________________________________
//
// Return the id of the particle transported
//
- return fGckine->ipart;
+ return PDGFromId(fGckine->ipart);
}
//_____________________________________________________________________________
}
//_____________________________________________________________________________
-Bool_t TGeant3::TrackInside() const
+Bool_t TGeant3::IsNewTrack() const
+{
+ //
+ // True if the track is not at the boundary of the current volume
+ //
+ return (fGctrak->sleng>0);
+}
+
+//_____________________________________________________________________________
+Bool_t TGeant3::IsTrackInside() const
{
//
// True if the track is not at the boundary of the current volume
}
//_____________________________________________________________________________
-Bool_t TGeant3::TrackEntering() const
+Bool_t TGeant3::IsTrackEntering() const
{
//
// True if this is the first step of the track in the current volume
}
//_____________________________________________________________________________
-Bool_t TGeant3::TrackExiting() const
+Bool_t TGeant3::IsTrackExiting() const
{
//
// True if this is the last step of the track in the current volume
}
//_____________________________________________________________________________
-Bool_t TGeant3::TrackOut() const
+Bool_t TGeant3::IsTrackOut() const
{
//
// True if the track is out of the setup
}
//_____________________________________________________________________________
-Bool_t TGeant3::TrackStop() const
+Bool_t TGeant3::IsTrackStop() const
{
//
// True if the track energy has fallen below the threshold
}
//_____________________________________________________________________________
-void TGeant3::ProdProcess(char* proc) const
+const char* TGeant3::ProdProcess() const
{
//
// Name of the process that has produced the secondary particles
// in the current step
//
+ static char proc[5];
const Int_t ipmec[13] = { 5,6,7,8,9,10,11,12,21,23,25,105,108 };
Int_t mec, km, im;
//
strncpy(proc,(char *)&fGctpol->namec1[mec - 101],4);
}
proc[4]='\0';
- return;
+ return proc;
}
}
}
strcpy(proc,"UNKN");
} else strcpy(proc,"NONE");
+ return proc;
}
//_____________________________________________________________________________
-void TGeant3::GetSecondary(Int_t isec, Int_t& ipart, Float_t* x, Float_t* p)
+void TGeant3::GetSecondary(Int_t isec, Int_t& ipart,
+ TLorentzVector &x, TLorentzVector &p)
{
//
// Get the parameters of the secondary track number isec produced
}
//_____________________________________________________________________________
-Bool_t TGeant3::TrackDisappear() const
+Bool_t TGeant3::IsTrackDisappeared() const
{
//
// True if the current particle has disappered
}
//_____________________________________________________________________________
-Bool_t TGeant3::TrackAlive() const
+Bool_t TGeant3::IsTrackAlive() const
{
//
// True if the current particle is alive and will continue to be
return fGctmed->stemax;
}
-//_____________________________________________________________________________
-void TGeant3::SetColors()
-{
- //
- // Set the colors for all the volumes
- // this is done sequentially for all volumes
- // based on the number of their medium
- //
- Int_t kv, icol;
- Int_t jvolum=fGclink->jvolum;
- //Int_t jtmed=fGclink->jtmed;
- //Int_t jmate=fGclink->jmate;
- Int_t nvolum=fGcnum->nvolum;
- char name[5];
- //
- // Now for all the volumes
- for(kv=1;kv<=nvolum;kv++) {
- // Get the tracking medium
- Int_t itm=Int_t (fZq[fZlq[jvolum-kv]+4]);
- // Get the material
- //Int_t ima=Int_t (fZq[fZlq[jtmed-itm]+6]);
- // Get z
- //Float_t z=fZq[fZlq[jmate-ima]+7];
- // Find color number
- //icol = Int_t(z)%6+2;
- //icol = 17+Int_t(z*150./92.);
- //icol = kv%6+2;
- icol = itm%6+2;
- strncpy(name,(char*)&fZiq[jvolum+kv],4);
- name[4]='\0';
- Gsatt(name,"COLO",icol);
- }
-}
-
//_____________________________________________________________________________
void TGeant3::SetMaxStep(Float_t maxstep)
{
gsrotm(krot, thex, phix, they, phiy, thez, phiz);
}
-//_____________________________________________________________________________
-void TGeant3::GetParticle(const Int_t ipart, char *name, Float_t &mass) const
-{
- //
- // Return name and mass of particle code ipart
- // Geant321 conventions
- //
- Int_t hname[6];
- Int_t jpart=fGclink->jpart;
- Int_t jpa=fZlq[jpart-ipart];
- //
- for(Int_t i=1; i<6; i++) hname[i-1]=fZiq[jpa+i];
- hname[5]=0;
- strncpy(name,(char *)hname, 21);
- mass=fZq[jpa+7];
-}
-
//_____________________________________________________________________________
Int_t TGeant3::GetMedium() const
{
//
// Print track and volume parameters at current point
//
- gpcxyz();
+
+ gpcxyz();
}
-
//_____________________________________________________________________________
void TGeant3::Ggclos()
{
// through the routine GHCLOS.
//
ggclos();
+ // Create internal list of volumes
+ fVolNames = new char[fGcnum->nvolum+1][5];
+ Int_t i;
+ for(i=0; i<fGcnum->nvolum; ++i) {
+ strncpy(fVolNames[i], (char *) &fZiq[fGclink->jvolum+i+1], 4);
+ fVolNames[i][4]='\0';
+ }
+ strcpy(fVolNames[fGcnum->nvolum],"NULL");
}
//_____________________________________________________________________________
//
Float_t *ubuf=0;
Int_t nbuf;
- gfpart(ipart, PASSCHARD(name), itrtyp, amass, charge, tlife, ubuf, nbuf
+ Int_t igpart = IdFromPDG(ipart);
+ gfpart(igpart, PASSCHARD(name), itrtyp, amass, charge, tlife, ubuf, nbuf
PASSCHARL(name));
}
//
gftmed(numed, PASSCHARD(name), nmat, isvol, ifield, fieldm, tmaxfd, stemax,
deemax, epsil, stmin, ubuf, nbuf PASSCHARL(name));
+}
+
+
+ void TGeant3::Gftmat(Int_t imate, Int_t ipart, char *chmeca, Int_t kdim,
+ Float_t* tkin, Float_t* value, Float_t* pcut,
+ Int_t &ixst)
+{
+ //
+ // Return parameters for tracking medium NUMED
+ //
+ gftmat(imate, ipart, PASSCHARD(chmeca), kdim,
+ tkin, value, pcut, ixst PASSCHARL(chmeca));
+
}
+
+Float_t TGeant3::Gbrelm(Float_t z, Float_t t, Float_t bcut)
+{
+ return gbrelm(z,t,bcut);
+}
+
+Float_t TGeant3::Gprelm(Float_t z, Float_t t, Float_t bcut)
+{
+ return gprelm(z,t,bcut);
+}
//_____________________________________________________________________________
void TGeant3::Gmate()
gtreve();
}
+//_____________________________________________________________________________
+void TGeant3::GtreveRoot()
+{
+ //
+ // Controls tracking of all particles belonging to the current event
+ //
+ gtreveroot();
+}
+
//_____________________________________________________________________________
void TGeant3::Grndm(Float_t *rvec, const Int_t len) const
{
// with solid colours can now be stored in a view bank or in 'PICTURE FILES'
//
InitHIGZ();
- higz->Clear();
+ gHigz->Clear();
gdopen(iview);
}
// string for the NAME of the volume can be found using the command DTREE).
//
InitHIGZ();
- higz->Clear();
+ gHigz->Clear();
char vname[5];
Vname(name,vname);
if (fGcvdma->raytra != 1) {
// the CVOL/BOX function.
//
InitHIGZ();
- higz->Clear();
+ gHigz->Clear();
char vname[5];
Vname(name,vname);
gdrawc(PASSCHARD(vname), axis,cut,u0,v0,ul,vl PASSCHARL(vname));
// The resulting picture is seen from the viewing angles theta,phi.
//
InitHIGZ();
- higz->Clear();
+ gHigz->Clear();
char vname[5];
Vname(name,vname);
gdrawx(PASSCHARD(vname), cutthe,cutphi,cutval,theta,phi,u0,v0,ul,vl
// volume.
//
InitHIGZ();
- higz->Clear();
+ gHigz->Clear();
char vname[5];
Vname(name,vname);
gdspec(PASSCHARD(vname) PASSCHARL(vname));
// Function called when one double-clicks on a volume name
// in a TPavelabel drawn by Gdtree.
//
- THIGZ *higzSave = higz;
+ THIGZ *higzSave = gHigz;
higzSave->SetName("higzSave");
THIGZ *higzSpec = (THIGZ*)gROOT->FindObject("higzSpec");
- //printf("DrawOneSpec, higz=%x, higzSpec=%x\n",higz,higzSpec);
- if (higzSpec) higz = higzSpec;
+ //printf("DrawOneSpec, gHigz=%x, higzSpec=%x\n",gHigz,higzSpec);
+ if (higzSpec) gHigz = higzSpec;
else higzSpec = new THIGZ(defSize);
higzSpec->SetName("higzSpec");
higzSpec->cd();
higzSpec->Update();
higzSave->cd();
higzSave->SetName("higz");
- higz = higzSave;
+ gHigz = higzSave;
}
//_____________________________________________________________________________
// - drawing tree of parent
//
InitHIGZ();
- higz->Clear();
+ gHigz->Clear();
char vname[5];
Vname(name,vname);
gdtree(PASSCHARD(vname), levmax, isel PASSCHARL(vname));
- higz->fPname = "";
+ gHigz->fPname = "";
}
//_____________________________________________________________________________
// This function draws the logical tree of the parent of name.
//
InitHIGZ();
- higz->Clear();
+ gHigz->Clear();
// Scan list of volumes in JVOLUM
char vname[5];
Int_t gname, i, jvo, in, nin, jin, num;
strncpy(vname,(char*)&fZiq[fGclink->jvolum+i],4);
vname[4] = 0;
gdtree(PASSCHARD(vname), levmax, isel PASSCHARL(vname));
- higz->fPname = "";
+ gHigz->fPname = "";
return;
}
}
fGcphys->idray = par;
}
+//_____________________________________________________________________________
+void TGeant3::SetERAN(Float_t ekmin, Float_t ekmax, Int_t nekbin)
+{
+ //
+ // To control cross section tabulations
+ // ekmin = minimum kinetic energy in GeV
+ // ekmax = maximum kinetic energy in GeV
+ // nekbin = number of logatithmic bins (<200)
+ //
+ fGcmulo->ekmin = ekmin;
+ fGcmulo->ekmax = ekmax;
+ fGcmulo->nekbin = nekbin;
+}
+
//_____________________________________________________________________________
void TGeant3::SetHADR(Int_t par)
{
fGcphys->irayl = par;
}
+//_____________________________________________________________________________
+void TGeant3::SetSTRA(Int_t par)
+{
+ //
+ // To control energy loss fluctuations
+ // with the PhotoAbsorption Ionisation model.
+ // par =0 no Straggling.
+ // =1 Straggling yes => no Delta rays.
+ //
+ fGcphlt->istra = par;
+}
+
//_____________________________________________________________________________
void TGeant3::SetSWIT(Int_t sw, Int_t val)
{
}
//_____________________________________________________________________________
-void TGeant3::SetUserDecay(Int_t ipart)
+void TGeant3::SetUserDecay(Int_t pdg)
{
//
// Force the decays of particles to be done with Pythia
// and not with the Geant routines.
// just kill pointers doing mzdrop
//
+ Int_t ipart = IdFromPDG(pdg);
+ if(ipart<0) {
+ printf("Particle %d not in geant\n",pdg);
+ return;
+ }
Int_t jpart=fGclink->jpart;
Int_t jpa=fZlq[jpart-ipart];
//
vname[4] = 0;
}
+//______________________________________________________________________________
+void TGeant3::Ertrgo()
+{
+ ertrgo();
+}
+
+//______________________________________________________________________________
+void TGeant3::Ertrak(const Float_t *const x1, const Float_t *const p1,
+ const Float_t *x2, const Float_t *p2,
+ Int_t ipa, Option_t *chopt)
+{
+ ertrak(x1,p1,x2,p2,ipa,PASSCHARD(chopt) PASSCHARL(chopt));
+}
+
//_____________________________________________________________________________
void TGeant3::WriteEuclid(const char* filnam, const char* topvol,
Int_t number, Int_t nlevel)
end=i;
break;
}
- filext=new char[end+4];
- filetme=new char[end+4];
+ filext=new char[end+5];
+ filetme=new char[end+5];
strncpy(filext,filnam,end);
strncpy(filetme,filnam,end);
//
}
}
fprintf(lun,"END\n");
+ fclose(lun);
printf(" *** GWEUCL *** file: %s is now written out\n",filext);
printf(" *** GWEUCL *** file: %s is now written out\n",filetme);
// Clean up
Version_t R__v = R__b.ReadVersion(); if (R__v) { }
AliMC::Streamer(R__b);
R__b >> fNextVol;
+ R__b >> fNPDGCodes;
+ R__b.ReadStaticArray(fPDGCode);
} else {
R__b.WriteVersion(TGeant3::IsA());
AliMC::Streamer(R__b);
R__b << fNextVol;
+ R__b << fNPDGCodes;
+ R__b.WriteArray(fPDGCode, fNPDGCodes);
}
}