TGeant3TGeo Class Reference

#include <TGeant3TGeo.h>

Inheritance diagram for TGeant3TGeo:

List of all members.

Public Member Functions
	TGeant3TGeo ()
	TGeant3TGeo (const char *title, Int_t nwgeant=0)
virtual void	LoadAddress ()
virtual	~TGeant3TGeo ()
virtual Bool_t	IsRootGeometrySupported () const
void	GeomIter ()
Int_t	NextVolUp (Text_t *name, Int_t &copy)
Int_t	CurrentVolID (Int_t &copy) const
Int_t	CurrentVolOffID (Int_t off, Int_t &copy) const
const char *	CurrentVolName () const
const char *	CurrentVolOffName (Int_t off) const
const char *	CurrentVolPath ()
Int_t	VolId (const Text_t *name) const
const char *	VolName (Int_t id) const
Int_t	NofVolumes () const
Int_t	NofVolDaughters (const char *volName) const
const char *	VolDaughterName (const char *volName, Int_t i) const
Int_t	VolDaughterCopyNo (const char *volName, Int_t i) const
Int_t	VolId2Mate (Int_t id) const
const char *	GetPath ()
const char *	GetNodeName ()
virtual void	Material (Int_t &kmat, const char *name, Double_t a, Double_t z, Double_t dens, Double_t radl, Double_t absl, Float_t *buf=0, Int_t nwbuf=0)
virtual void	Material (Int_t &kmat, const char *name, Double_t a, Double_t z, Double_t dens, Double_t radl, Double_t absl, Double_t *buf, Int_t nwbuf)
virtual void	Mixture (Int_t &kmat, const char *name, Float_t *a, Float_t *z, Double_t dens, Int_t nlmat, Float_t *wmat)
virtual void	Mixture (Int_t &kmat, const char *name, Double_t *a, Double_t *z, Double_t dens, Int_t nlmat, Double_t *wmat)
virtual void	Medium (Int_t &kmed, const char *name, Int_t nmat, Int_t isvol, Int_t ifield, Double_t fieldm, Double_t tmaxfd, Double_t stemax, Double_t deemax, Double_t epsil, Double_t stmin, Float_t *ubuf=0, Int_t nbuf=0)
virtual void	Medium (Int_t &kmed, const char *name, Int_t nmat, Int_t isvol, Int_t ifield, Double_t fieldm, Double_t tmaxfd, Double_t stemax, Double_t deemax, Double_t epsil, Double_t stmin, Double_t *ubuf, Int_t nbuf)
virtual void	Matrix (Int_t &krot, Double_t thex, Double_t phix, Double_t they, Double_t phiy, Double_t thez, Double_t phiz)
virtual void	SetRootGeometry ()
virtual Gcvol1_t *	Gcvol1 () const
virtual void	Ggclos ()
virtual void	Gprint (const char *name)
virtual void	Gsmate (Int_t imat, const char *name, Float_t a, Float_t z, Float_t dens, Float_t radl, Float_t absl)
virtual void	Gsmixt (Int_t imat, const char *name, Float_t *a, Float_t *z, Float_t dens, Int_t nlmat, Float_t *wmat)
virtual void	Gstmed (Int_t numed, const char *name, Int_t nmat, Int_t isvol, Int_t ifield, Float_t fieldm, Float_t tmaxfd, Float_t stemax, Float_t deemax, Float_t epsil, Float_t stmin)
virtual void	Gtreve ()
virtual void	GtreveRoot ()
virtual void	Gdtom (Float_t *xd, Float_t *xm, Int_t iflag)
virtual void	Gdtom (Double_t *xd, Double_t *xm, Int_t iflag)
virtual void	Gmedia (Float_t *x, Int_t &numed)
virtual void	Gmtod (Float_t *xm, Float_t *xd, Int_t iflag)
virtual void	Gmtod (Double_t *xm, Double_t *xd, Int_t iflag)
virtual void	Gsdvn (const char *name, const char *mother, Int_t ndiv, Int_t iaxis)
virtual void	Gsdvn2 (const char *name, const char *mother, Int_t ndiv, Int_t iaxis, Double_t c0i, Int_t numed)
virtual void	Gsdvs (const char *name, const char *mother, Float_t step, Int_t iaxis, Int_t numed)
virtual void	Gsdvs2 (const char *name, const char *mother, Float_t step, Int_t iaxis, Float_t c0, Int_t numed)
virtual void	Gsdvt (const char *name, const char *mother, Double_t step, Int_t iaxis, Int_t numed, Int_t ndvmx)
virtual void	Gsdvt2 (const char *name, const char *mother, Double_t step, Int_t iaxis, Double_t c0, Int_t numed, Int_t ndvmx)
virtual void	Gsord (const char *name, Int_t iax)
virtual void	Gspos (const char *name, Int_t nr, const char *mother, Double_t x, Double_t y, Double_t z, Int_t irot, const char *konly="ONLY")
virtual void	Gsposp (const char *name, Int_t nr, const char *mother, Double_t x, Double_t y, Double_t z, Int_t irot, const char *konly, Float_t *upar, Int_t np)
virtual void	Gsposp (const char *name, Int_t nr, const char *mother, Double_t x, Double_t y, Double_t z, Int_t irot, const char *konly, Double_t *upar, Int_t np)
virtual void	Gsrotm (Int_t nmat, Float_t theta1, Float_t phi1, Float_t theta2, Float_t phi2, Float_t theta3, Float_t phi3)
virtual void	Gprotm (Int_t nmat=0)
virtual Int_t	Gsvolu (const char *name, const char *shape, Int_t nmed, Float_t *upar, Int_t np)
virtual Int_t	Gsvolu (const char *name, const char *shape, Int_t nmed, Double_t *upar, Int_t np)
virtual void	Gsatt (const char *name, const char *att, Int_t val)
virtual Int_t	Glvolu (Int_t nlev, Int_t *lnam, Int_t *lnum)
virtual Bool_t	GetTransformation (const TString &volumePath, TGeoHMatrix &matrix)
virtual Bool_t	GetShape (const TString &volumePath, TString &shapeType, TArrayD &par)
virtual Bool_t	GetMaterial (const TString &volumeName, TString &name, Int_t &imat, Double_t &a, Double_t &z, Double_t &density, Double_t &radl, Double_t &inter, TArrayD &par)
virtual Bool_t	GetMedium (const TString &volumeName, TString &name, Int_t &imed, Int_t &nmat, Int_t &isvol, Int_t &ifield, Double_t &fieldm, Double_t &tmaxfd, Double_t &stemax, Double_t &deemax, Double_t &epsil, Double_t &stmin, TArrayD &par)
virtual Int_t	GetMedium () const
virtual void	Gdshow (Int_t view)
virtual void	Gdopt (const char *name, const char *value)
virtual void	Gdraw (const char *name, Double_t theta=30, Double_t phi=30, Double_t psi=0, Double_t u0=10, Double_t v0=10, Double_t ul=0.01, Double_t vl=0.01)
virtual void	Gdrawc (const char *name, Int_t axis=1, Float_t cut=0, Float_t u0=10, Float_t v0=10, Float_t ul=0.01, Float_t vl=0.01)
virtual void	Gdrawx (const char *name, Float_t cutthe, Float_t cutphi, Float_t cutval, Float_t theta=30, Float_t phi=30, Float_t u0=10, Float_t v0=10, Float_t ul=0.01, Float_t vl=0.01)
virtual void	Gdspec (const char *name)
virtual void	DrawOneSpec (const char *name)
virtual void	Gdtree (const char *name, Int_t levmax=15, Int_t ispec=0)
virtual void	GdtreeParent (const char *name, Int_t levmax=15, Int_t ispec=0)
virtual void	FinishGeometry ()
virtual void	SetColors ()
Protected Attributes
TGeoMCGeometry *	fMCGeo
Bool_t	fImportRootGeometry
Gcvol1_t *	fGcvol1
Private Member Functions
	TGeant3TGeo (const TGeant3TGeo &)
	GCVOLU common structure.
TGeant3TGeo &	operator= (const TGeant3TGeo &)
Int_t	ImportMaterial (const TGeoMaterial *material)

---

Constructor & Destructor Documentation

TGeant3TGeo::TGeant3TGeo (   )

Definition at line 539 of file TGeant3TGeo.cxx. : TGeant3(), fMCGeo(0) { // // Default constructor }

TGeant3TGeo::TGeant3TGeo (  const char *  title, Int_t  nwgeant = 0 )

Definition at line 548 of file TGeant3TGeo.cxx. References fggperp, fginvol, fglvolu, fgmedia, fgtmany, fgtmedi, fgtnext, fgtonly, fMCGeo, and LoadAddress(). : TGeant3(title,nwgeant), fImportRootGeometry(kFALSE) { // // Standard constructor for TGeant3 with ZEBRA initialisation // SetName("TGeant3TGeo"); fMCGeo = new TGeoMCGeometry("MCGeo", "TGeo Implementation of VirtualMCGeometry"); LoadAddress(); //set pointers to tracker functions fginvol = ginvolTGeo; fgtmedi = gtmediTGeo; fgtmany = gtmanyTGeo; fgtonly = gtonlyTGeo; fgmedia = gmediaTGeo; fglvolu = glvoluTGeo; fgtnext = gtnextTGeo; fggperp = ggperpTGeo; }

TGeant3TGeo::~TGeant3TGeo (   )  [virtual]

Definition at line 573 of file TGeant3TGeo.cxx. { delete fMCGeo; }

TGeant3TGeo::TGeant3TGeo (  const TGeant3TGeo &   )  [inline, private]

GCVOLU common structure. Definition at line 216 of file TGeant3TGeo.h. : TGeant3() {}

---

Member Function Documentation

Int_t TGeant3TGeo::CurrentVolID (  Int_t &  copy  )  const

Reimplemented from TGeant3. Definition at line 622 of file TGeant3TGeo.cxx. Referenced by CurrentVolOffID(). { // // Returns the current volume ID and copy number // if (gGeoManager->IsOutside()) return 0; TGeoNode *node = gGeoManager->GetCurrentNode(); copy = node->GetNumber(); Int_t id = node->GetVolume()->GetNumber(); return id; }

const char * TGeant3TGeo::CurrentVolName (   )  const

Reimplemented from TGeant3. Definition at line 650 of file TGeant3TGeo.cxx. Referenced by CurrentVolOffName(). { // // Returns the current volume name // if (gGeoManager->IsOutside()) return gGeoManager->GetTopVolume()->GetName(); return gGeoManager->GetCurrentVolume()->GetName(); }

Int_t TGeant3TGeo::CurrentVolOffID (  Int_t  off, Int_t &  copy )  const

Reimplemented from TGeant3. Definition at line 635 of file TGeant3TGeo.cxx. References CurrentVolID(). { // // Return the current volume "off" upward in the geometrical tree // ID and copy number // if (off<0 || off>gGeoManager->GetLevel()) return 0; if (off==0) return CurrentVolID(copy); TGeoNode *node = gGeoManager->GetMother(off); if (!node) return 0; copy = node->GetNumber(); return node->GetVolume()->GetNumber(); }

const char * TGeant3TGeo::CurrentVolOffName (  Int_t  off  )  const

Reimplemented from TGeant3. Definition at line 660 of file TGeant3TGeo.cxx. References CurrentVolName(), and Gcvolu_t::nlevel. { // // 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; if( (i=fGcvolu->nlevel-off-1) < 0 ) { Warning("CurrentVolOffName", "Offset requested %d but stack depth %d\n",off,fGcvolu->nlevel); return 0; } if (off<0 || off>gGeoManager->GetLevel()) return 0; if (off==0) return CurrentVolName(); TGeoNode *node = gGeoManager->GetMother(off); if (!node) return 0; return node->GetVolume()->GetName(); }

const char * TGeant3TGeo::CurrentVolPath (   )

Reimplemented from TGeant3. Definition at line 681 of file TGeant3TGeo.cxx. References GetPath(). { // Return the path in geometry tree for the current volume // --- return GetPath(); }

void TGeant3TGeo::DrawOneSpec (  const char *  name  )  [virtual]

Reimplemented from TGeant3. Definition at line 1957 of file TGeant3TGeo.cxx. { // // Function called when one double-clicks on a volume name // in a TPavelabel drawn by Gdtree. // return; }

void TGeant3TGeo::FinishGeometry (   )  [virtual]

Reimplemented from TGeant3. Definition at line 2028 of file TGeant3TGeo.cxx. References TGeant3::G3Medium(), Ggclos(), ImportMaterial(), and SetColors(). { // // Finalise geometry construction // //Close the geometry structure if (gDebug > 0) printf("FinishGeometry, calling ggclos\n"); Ggclos(); if (fImportRootGeometry) { // Import materials // TIter next1(gGeoManager->GetListOfMaterials()); TGeoMaterial* mat; Int_t nofMaterials = 0; while ((mat=(TGeoMaterial*)next1())) { Int_t kmat = ImportMaterial(mat); mat->SetUniqueID(kmat); nofMaterials++; } // Number of media Int_t nofMedia = 0; TIter next2(gGeoManager->GetListOfMedia()); TGeoMedium* medx; while ((medx=(TGeoMedium*)next2())) nofMedia++; // Import media // Int_t maxNofMaterials = nofMaterials + nofMedia; TArrayI usedMaterials(maxNofMaterials); for (Int_t i=0; i<maxNofMaterials; i++) usedMaterials[i] = -1; TIter next3(gGeoManager->GetListOfMedia()); TGeoMedium* med; while ((med=(TGeoMedium*)next3())) { Int_t kmed; Int_t nmat = med->GetMaterial()->GetUniqueID(); // if material is already used define a new Geant3 material // (do not reset TGeoMaterial index) if (usedMaterials[nmat] >0 ) nmat = ImportMaterial(med->GetMaterial()); usedMaterials[nmat] = 1; Int_t isvol = (Int_t) med->GetParam(0); Int_t ifield = (Int_t) med->GetParam(1); Double_t fieldm = med->GetParam(2); Double_t tmaxfd = med->GetParam(3); Double_t stemax = med->GetParam(4); Double_t deemax = med->GetParam(5); Double_t epsil = med->GetParam(6); Double_t stmin = med->GetParam(7); G3Medium(kmed, med->GetName(), nmat, isvol, ifield, fieldm, tmaxfd, stemax,deemax, epsil, stmin); med->SetId(kmed); } if (gDebug > 0) printf("FinishGeometry, geometry retreived from file, materials/media mapped to G3\n"); } else { TGeoVolume *top = (TGeoVolume*)gGeoManager->GetListOfVolumes()->First(); gGeoManager->SetTopVolume(top); if (gDebug > 0) printf("FinishGeometry, calling CloseGeometry\n"); gGeoManager->CloseGeometry(); } if (gDebug > 0) printf("FinishGeometry, calling MisalignGeometry()\n"); TVirtualMCApplication::Instance()->MisalignGeometry(); // gROOT->GetListOfBrowsables()->Add(gGeoManager); if (gDebug > 0) printf("FinishGeometry, calling SetColors\n"); //Create the color table SetColors(); if (gDebug > 0) printf("FinishGeometry, returning\n"); }

virtual Gcvol1_t* TGeant3TGeo::Gcvol1 (   )  const [inline, virtual]

Definition at line 107 of file TGeant3TGeo.h. {return fGcvol1;}

void TGeant3TGeo::Gdopt (  const char *  name, const char *  value )  [virtual]

Reimplemented from TGeant3. Definition at line 1819 of file TGeant3TGeo.cxx. { // // NAME Option name // VALUE Option value // // To set/modify the drawing options. // IOPT IVAL Action // // THRZ ON Draw tracks in R vs Z // OFF (D) Draw tracks in X,Y,Z // 180 // 360 // PROJ PARA (D) Parallel projection // PERS Perspective // TRAK LINE (D) Trajectory drawn with lines // POIN " " with markers // HIDE ON Hidden line removal using the CG package // OFF (D) No hidden line removal // SHAD ON Fill area and shading of surfaces. // OFF (D) Normal hidden line removal. // RAYT ON Ray-tracing on. // OFF (D) Ray-tracing off. // EDGE OFF Does not draw contours when shad is on. // ON (D) Normal shading. // MAPP 1,2,3,4 Mapping before ray-tracing. // 0 (D) No mapping. // USER ON User graphics options in the raytracing. // OFF (D) Automatic graphics options. // return; }

void TGeant3TGeo::Gdraw (  const char *  name, Double_t  theta = 30, Double_t  phi = 30, Double_t  psi = 0, Double_t  u0 = 10, Double_t  v0 = 10, Double_t  ul = 0.01, Double_t  vl = 0.01 )  [virtual]

Reimplemented from TGeant3. Definition at line 1853 of file TGeant3TGeo.cxx. { // // NAME Volume name // + // THETA Viewing angle theta (for 3D projection) // PHI Viewing angle phi (for 3D projection) // PSI Viewing angle psi (for 2D rotation) // U0 U-coord. (horizontal) of volume origin // V0 V-coord. (vertical) of volume origin // SU Scale factor for U-coord. // SV Scale factor for V-coord. // // This function will draw the volumes, // selected with their graphical attributes, set by the Gsatt // facility. The drawing may be performed with hidden line removal // and with shading effects according to the value of the options HIDE // and SHAD; if the option SHAD is ON, the contour's edges can be // drawn or not. If the option HIDE is ON, the detector can be // exploded (BOMB), clipped with different shapes (CVOL), and some // of its parts can be shifted from their original // position (SHIFT). When HIDE is ON, if // the drawing requires more than the available memory, the program // will evaluate and display the number of missing words // (so that the user can increase the // size of its ZEBRA store). Finally, at the end of each drawing (with HIDE on), // the program will print messages about the memory used and // statistics on the volumes' visibility. // The following commands will produce the drawing of a green // volume, specified by NAME, without using the hidden line removal // technique, using the hidden line removal technique, // with different linewidth and colour (red), with // solid colour, with shading of surfaces, and without edges. // Finally, some examples are given for the ray-tracing. (A possible // string for the NAME of the volume can be found using the command DTREE). // return; }

void TGeant3TGeo::Gdrawc (  const char *  name, Int_t  axis = 1, Float_t  cut = 0, Float_t  u0 = 10, Float_t  v0 = 10, Float_t  ul = 0.01, Float_t  vl = 0.01 )  [virtual]

Reimplemented from TGeant3. Definition at line 1894 of file TGeant3TGeo.cxx. { // // NAME Volume name // CAXIS Axis value // CUTVAL Cut plane distance from the origin along the axis // + // U0 U-coord. (horizontal) of volume origin // V0 V-coord. (vertical) of volume origin // SU Scale factor for U-coord. // SV Scale factor for V-coord. // // The cut plane is normal to caxis (X,Y,Z), corresponding to iaxis (1,2,3), // and placed at the distance cutval from the origin. // The resulting picture is seen from the the same axis. // When HIDE Mode is ON, it is possible to get the same effect with // the CVOL/BOX function. // return; }

void TGeant3TGeo::Gdrawx (  const char *  name, Float_t  cutthe, Float_t  cutphi, Float_t  cutval, Float_t  theta = 30, Float_t  phi = 30, Float_t  u0 = 10, Float_t  v0 = 10, Float_t  ul = 0.01, Float_t  vl = 0.01 )  [virtual]

Reimplemented from TGeant3. Definition at line 1917 of file TGeant3TGeo.cxx. { // // NAME Volume name // CUTTHE Theta angle of the line normal to cut plane // CUTPHI Phi angle of the line normal to cut plane // CUTVAL Cut plane distance from the origin along the axis // + // THETA Viewing angle theta (for 3D projection) // PHI Viewing angle phi (for 3D projection) // U0 U-coord. (horizontal) of volume origin // V0 V-coord. (vertical) of volume origin // SU Scale factor for U-coord. // SV Scale factor for V-coord. // // The cut plane is normal to the line given by the cut angles // cutthe and cutphi and placed at the distance cutval from the origin. // The resulting picture is seen from the viewing angles theta,phi. // return; }

void TGeant3TGeo::Gdshow (  Int_t  view  )  [virtual]

Reimplemented from TGeant3. Definition at line 1808 of file TGeant3TGeo.cxx. { // // IVIEW View number // // It shows on the screen the contents of a view bank. It // can be called after a view bank has been closed. // }

void TGeant3TGeo::Gdspec (  const char *  name  )  [virtual]

Reimplemented from TGeant3. Definition at line 1942 of file TGeant3TGeo.cxx. { // // NAME Volume name // // Shows 3 views of the volume (two cut-views and a 3D view), together with // its geometrical specifications. The 3D drawing will // be performed according the current values of the options HIDE and // SHAD and according the current SetClipBox clipping parameters for that // volume. // return; }

void TGeant3TGeo::Gdtom (  Double_t *  xd, Double_t *  xm, Int_t  iflag )  [virtual]

Reimplemented from TGeant3. Definition at line 1322 of file TGeant3TGeo.cxx. { // // Computes coordinates XM (Master Reference System // knowing the coordinates XD (Detector Ref System) // The local reference system can be initialized by // - the tracking routines and GDTOM used in GUSTEP // - a call to GSCMED(NLEVEL,NAMES,NUMBER) // (inverse routine is GMTOD) // // If IFLAG=1 convert coordinates // IFLAG=2 convert direction cosinus // if (iflag == 1) gGeoManager->LocalToMaster(xd,xm); else gGeoManager->LocalToMasterVect(xd,xm); }

void TGeant3TGeo::Gdtom (  Float_t *  xd, Float_t *  xm, Int_t  iflag )  [virtual]

Reimplemented from TGeant3. Definition at line 1300 of file TGeant3TGeo.cxx. { // // Computes coordinates XM (Master Reference System // knowing the coordinates XD (Detector Ref System) // The local reference system can be initialized by // - the tracking routines and GDTOM used in GUSTEP // - a call to GSCMED(NLEVEL,NAMES,NUMBER) // (inverse routine is GMTOD) // // If IFLAG=1 convert coordinates // IFLAG=2 convert direction cosinus // Double_t XM[3], XD[3]; Int_t i; for (i=0;i<3;i++) XD[i] = xd[i]; if (iflag == 1) gGeoManager->LocalToMaster(XD,XM); else gGeoManager->LocalToMasterVect(XD,XM); for (i=0;i<3;i++) xm[i]=XM[i]; }

void TGeant3TGeo::Gdtree (  const char *  name, Int_t  levmax = 15, Int_t  ispec = 0 )  [virtual]

Reimplemented from TGeant3. Definition at line 1967 of file TGeant3TGeo.cxx. { // // NAME Volume name // LEVMAX Depth level // ISELT Options // // This function draws the logical tree, // Each volume in the tree is represented by a TPaveTree object. // Double-clicking on a TPaveTree draws the specs of the corresponding volume. // Use TPaveTree pop-up menu to select: // - drawing specs // - drawing tree // - drawing tree of parent // return; }

void TGeant3TGeo::GdtreeParent (  const char *  name, Int_t  levmax = 15, Int_t  ispec = 0 )  [virtual]

Reimplemented from TGeant3. Definition at line 1986 of file TGeant3TGeo.cxx. { // // NAME Volume name // LEVMAX Depth level // ISELT Options // // This function draws the logical tree of the parent of name. // }

void TGeant3TGeo::GeomIter (   )

Reimplemented from TGeant3. Definition at line 592 of file TGeant3TGeo.cxx. { // // Geometry iterator for moving upward in the geometry tree // Initialise the iterator // fNextVol=gGeoManager->GetLevel(); }

Bool_t TGeant3TGeo::GetMaterial (  const TString &  volumeName, TString &  name, Int_t &  imat, Double_t &  a, Double_t &  z, Double_t &  density, Double_t &  radl, Double_t &  inter, TArrayD &  par )  [virtual]

Reimplemented from TGeant3. Definition at line 1032 of file TGeant3TGeo.cxx. References TGeant3::Gclink(), TGeant3::Gfmate(), Gclink_t::jmate, and TGeant3::Lq(). { // Returns the Material and its parameters for the volume specified // by volumeName. // Note, Geant3 stores and uses mixtures as an element with an effective // Z and A. Consequently, if the parameter Z is not integer, then // this material represents some sort of mixture. // Inputs: // TString& volumeName The volume name // Outputs: // TSrting &name Material name // Int_t &imat Material index number // Double_t &a Average Atomic mass of material // Double_t &z Average Atomic number of material // Double_t &dens Density of material [g/cm^3] // Double_t &radl Average radiation length of material [cm] // Double_t &inter Average interaction length of material [cm] // TArrayD &par A TArrayD of user defined parameters. // Return: // kTRUE if no errors Int_t i,jma,nbuf; Float_t af,zf,densf,radlf,interf; Float_t *ubuf; Char_t namec[20] = {20*'\0'}; TGeoVolume *vol = gGeoManager->GetVolume(volumeName.Data()); if (!vol) return kFALSE; TGeoMedium *med = vol->GetMedium(); if (!med) return kFALSE; TGeoMaterial *mat = med->GetMaterial(); imat = mat->GetUniqueID(); nbuf = jma = Lq()[Gclink()->jmate-imat]; ubuf = new Float_t[nbuf]; Gfmate(imat,namec,af,zf,densf,radlf,interf,ubuf,nbuf); name = mat->GetName(); name = name.Strip(TString::kTrailing, '$'); // par.Set(nbuf); for(i=0;i<nbuf;i++) par.AddAt(((Double_t)ubuf[i]),i); delete[] ubuf; a = mat->GetA(); z = mat->GetZ(); dens = mat->GetDensity(); radl = radlf; inter = interf; return kTRUE; }

Int_t TGeant3TGeo::GetMedium (   )  const [virtual]

Reimplemented from TGeant3. Definition at line 1139 of file TGeant3TGeo.cxx. References TGeant3::GetMedium(). { // Temporary added return TGeant3::GetMedium(); }

Bool_t TGeant3TGeo::GetMedium (  const TString &  volumeName, TString &  name, Int_t &  imed, Int_t &  nmat, Int_t &  isvol, Int_t &  ifield, Double_t &  fieldm, Double_t &  tmaxfd, Double_t &  stemax, Double_t &  deemax, Double_t &  epsil, Double_t &  stmin, TArrayD &  par )  [virtual]

Reimplemented from TGeant3. Definition at line 1084 of file TGeant3TGeo.cxx. References TGeant3::Gclink(), TGeant3::Gftmed(), Gclink_t::jtmed, and TGeant3::Lq(). { // Returns the Medium and its parameters for the volume specified // by volumeName. // Inputs: // TString& volumeName The volume name. // Outputs: // TString &name Medium name // Int_t &nmat Material number defined for this medium // Int_t &imed The medium index number // Int_t &isvol volume number defined for this medium // Int_t &iflield Magnetic field flag // Double_t &fieldm Magnetic field strength // Double_t &tmaxfd Maximum angle of deflection per step // Double_t &stemax Maximum step size // Double_t &deemax Maximum fraction of energy allowed to be lost // to continuous process. // Double_t &epsil Boundary crossing precision // Double_t &stmin Minimum step size allowed // TArrayD &par A TArrayD of user parameters with all of the // parameters of the specified medium. // Return: // kTRUE if there where no errors Int_t i,nbuf; Float_t fieldmf,tmaxfdf,stemaxf,deemaxf,epsilf,stminf; Float_t *buf; Char_t namec[25] = {25*'\0'}; TGeoVolume *vol = gGeoManager->GetVolume(volumeName.Data()); if (!vol) return kFALSE; TGeoMedium *med = vol->GetMedium(); if (!med) return kFALSE; imed = med->GetId(); nbuf = Lq()[Gclink()->jtmed-imed]; buf = new Float_t[nbuf]; Gftmed(imed,namec,nmat,isvol,ifield,fieldmf,tmaxfdf,stemaxf,deemaxf, epsilf,stminf,buf,&nbuf); name = med->GetName(); name = name.Strip(TString::kTrailing, '$'); par.Set(nbuf); for(i=0;i<nbuf;i++) par.AddAt(((Double_t)buf[i]),i); delete[] buf; fieldm = (Double_t) fieldmf; tmaxfd = (Double_t) tmaxfdf; stemax = (Double_t) stemaxf; deemax = (Double_t) deemaxf; epsil = (Double_t) epsilf; stmin = (Double_t) stminf; return kTRUE; }

const char * TGeant3TGeo::GetNodeName (   )

Reimplemented from TGeant3. Definition at line 980 of file TGeant3TGeo.cxx. { // Get name of current G3 node if (gGeoManager->IsOutside()) return ""; return gGeoManager->GetCurrentNode()->GetName(); }

const char * TGeant3TGeo::GetPath (   )

Reimplemented from TGeant3. Definition at line 973 of file TGeant3TGeo.cxx. Referenced by CurrentVolPath(). { // Get current path inside G3 geometry return gGeoManager->GetPath(); }

Bool_t TGeant3TGeo::GetShape (  const TString &  volumePath, TString &  shapeType, TArrayD &  par )  [virtual]

Reimplemented from TGeant3. Definition at line 1014 of file TGeant3TGeo.cxx. References fMCGeo. { // Returns the shape and its parameters for the volume specified // by volumeName. // Inputs: // TString& volumeName The volume name // Outputs: // TString &shapeType Shape type // TArrayD &par A TArrayD of parameters with all of the // parameters of the specified shape. // Return: // A logical indicating whether there was an error in getting this // information return fMCGeo->GetShape(volumePath, shapeType, par); }

Bool_t TGeant3TGeo::GetTransformation (  const TString &  volumePath, TGeoHMatrix &  matrix )  [virtual]

Reimplemented from TGeant3. Definition at line 988 of file TGeant3TGeo.cxx. References fMCGeo. { // Returns the Transformation matrix between the volume specified // by the path volumePath and the Top or mater volume. The format // of the path volumePath is as follows (assuming ALIC is the Top volume) // "/ALIC_1/DDIP_1/S05I_2/S05H_1/S05G_3". Here ALIC is the top most // or master volume which has only 1 instance of. Of all of the daughter // volumes of ALICE, DDIP volume copy #1 is indicated. Similarly for // the daughter volume of DDIP is S05I copy #2 and so on. // Inputs: // TString& volumePath The volume path to the specific volume // for which you want the matrix. Volume name // hierarchy is separated by "/" while the // copy number is appended using a "_". // Outputs: // TGeoHMatrix &mat A matrix with its values set to those // appropriate to the Local to Master transformation // Return: // A logical value if kFALSE then an error occurred and no change to // mat was made. // We have to preserve the modeler state return fMCGeo->GetTransformation(volumePath, mat); }

void TGeant3TGeo::Ggclos (   )  [virtual]

Reimplemented from TGeant3. Definition at line 1153 of file TGeant3TGeo.cxx. Referenced by FinishGeometry(). { // // Closes off the geometry setting. // Initializes the search list for the contents of each // volume following the order they have been positioned, and // inserting the content '0' when a call to GSNEXT (-1) has // been required by the user. // Performs the development of the JVOLUM structure for all // volumes with variable parameters, by calling GGDVLP. // Interprets the user calls to GSORD, through GGORD. // Computes and stores in a bank (next to JVOLUM mother bank) // the number of levels in the geometrical tree and the // maximum number of contents per level, by calling GGNLEV. // Sets status bit for CONCAVE volumes, through GGCAVE. // Completes the JSET structure with the list of volume names // which identify uniquely a given physical detector, the // list of bit numbers to pack the corresponding volume copy // numbers, and the generic path(s) in the JVOLUM tree, // through the routine GHCLOS. // fVolNames = 0; }

Int_t TGeant3TGeo::Glvolu (  Int_t  nlev, Int_t *  lnam, Int_t *  lnum )  [virtual]

Reimplemented from TGeant3. Definition at line 1785 of file TGeant3TGeo.cxx. { // // nlev number of leveles deap into the volume tree // size of the arrays lnam and lnum // lnam an integer array whos 4 bytes contain the askii code for the // volume names // lnum an integer array containing the copy numbers for that specific // volume // // This routine fills the volulme paramters in common /gcvolu/ for a // physical tree, specified by the list lnam and lnum of volume names // and numbers, and for all its ascendants up to level 1. This routine // is optimsed and does not re-compute the part of the history already // available in GCVOLU. This means that if it is used in user programs // outside the usual framwork of the tracking, the user has to initilise // to zero NLEVEL in the common GCVOLU. It return 0 if there were no // problems in make the call. // return 0; }

void TGeant3TGeo::Gmedia (  Float_t *  x, Int_t &  numed )  [virtual]

Reimplemented from TGeant3. Definition at line 1341 of file TGeant3TGeo.cxx. References gCurrentNode, gcvolu, Gcvolu_t::lvolum, Gcvolu_t::names, Gcvolu_t::nlevel, and Gcvolu_t::number. { // // Finds in which volume/medium the point X is, and updates the // common /GCVOLU/ and the structure JGPAR accordingly. // // NUMED returns the tracking medium number, or 0 if point is // outside the experimental setup. // gCurrentNode = gGeoManager->FindNode(x[0],x[1],x[2]); if (gGeoManager->IsOutside()) { numed=0; } else { gcvolu->nlevel = 1 + gGeoManager->GetLevel(); gGeoManager->GetBranchNames(gcvolu->names); gGeoManager->GetBranchNumbers(gcvolu->number,gcvolu->lvolum); TGeoVolume *vol = gCurrentNode->GetVolume(); if (vol) { TGeoMedium *medium = vol->GetMedium(); if (medium) numed = medium->GetId(); } else { printf("ERROR: gmedia: NULL volume\n"); } } }

void TGeant3TGeo::Gmtod (  Double_t *  xm, Double_t *  xd, Int_t  iflag )  [virtual]

Reimplemented from TGeant3. Definition at line 1392 of file TGeant3TGeo.cxx. { // // Computes coordinates XD (in DRS) // from known coordinates XM in MRS // The local reference system can be initialized by // - the tracking routines and GMTOD used in GUSTEP // - a call to GMEDIA(XM,NUMED,CHECK) // - a call to GLVOLU(NLEVEL,NAMES,NUMBER,IER) // (inverse routine is GDTOM) // // If IFLAG=1 convert coordinates // IFLAG=2 convert direction cosinus // if (iflag == 1) gGeoManager->MasterToLocal(xm,xd); else gGeoManager->MasterToLocalVect(xm,xd); }

void TGeant3TGeo::Gmtod (  Float_t *  xm, Float_t *  xd, Int_t  iflag )  [virtual]

Reimplemented from TGeant3. Definition at line 1369 of file TGeant3TGeo.cxx. { // // Computes coordinates XD (in DRS) // from known coordinates XM in MRS // The local reference system can be initialized by // - the tracking routines and GMTOD used in GUSTEP // - a call to GMEDIA(XM,NUMED,CHECK) // - a call to GLVOLU(NLEVEL,NAMES,NUMBER,IER) // (inverse routine is GDTOM) // // If IFLAG=1 convert coordinates // IFLAG=2 convert direction cosinus // Double_t XM[3], XD[3]; Int_t i; for (i=0;i<3;i++) XM[i]=xm[i]; if (iflag == 1) gGeoManager->MasterToLocal(XM,XD); else gGeoManager->MasterToLocalVect(XM,XD); for (i=0;i<3;i++) xd[i] = XD[i]; }

void TGeant3TGeo::Gprint (  const char *  name  )  [virtual]

Reimplemented from TGeant3. Definition at line 1178 of file TGeant3TGeo.cxx. { // // Routine to print data structures // CHNAME name of a data structure // }

void TGeant3TGeo::Gprotm (  Int_t  nmat = 0  )  [virtual]

Reimplemented from TGeant3. Definition at line 1586 of file TGeant3TGeo.cxx. References Error. { // // To print rotation matrices structure JROTM // nmat Rotation matrix number // TIter next(gGeoManager->GetListOfMatrices()); TGeoMatrix *matrix; while ((matrix = (TGeoMatrix*)next())) { if (UInt_t(nmat) == matrix->GetUniqueID()) { matrix->Print(); return; } } Error("Gprotm","Rotation with id=%i not found", nmat); }

void TGeant3TGeo::Gsatt (  const char *  name, const char *  att, Int_t  val )  [virtual]

Reimplemented from TGeant3. Definition at line 1696 of file TGeant3TGeo.cxx. { // // NAME Volume name // IOPT Name of the attribute to be set // IVAL Value to which the attribute is to be set // // name= "*" stands for all the volumes. // iopt can be chosen among the following : // // WORK 0=volume name is inactive for the tracking // 1=volume name is active for the tracking (default) // // SEEN 0=volume name is invisible // 1=volume name is visible (default) // -1=volume invisible with all its descendants in the tree // -2=volume visible but not its descendants in the tree // // LSTY line style 1,2,3,... (default=1) // LSTY=7 will produce a very precise approximation for // revolution bodies. // // LWID line width -7,...,1,2,3,..7 (default=1) // LWID<0 will act as abs(LWID) was set for the volume // and for all the levels below it. When SHAD is 'ON', LWID // represent the linewidth of the scan lines filling the surfaces // (whereas the FILL value represent their number). Therefore // tuning this parameter will help to obtain the desired // quality/performance ratio. // // COLO colour code -166,...,1,2,..166 (default=1) // n=1=black // n=2=red; n=17+m, m=0,25, increasing luminosity according to 'm'; // n=3=green; n=67+m, m=0,25, increasing luminosity according to 'm'; // n=4=blue; n=117+m, m=0,25, increasing luminosity according to 'm'; // n=5=yellow; n=42+m, m=0,25, increasing luminosity according to 'm'; // n=6=violet; n=142+m, m=0,25, increasing luminosity according to 'm'; // n=7=lightblue; n=92+m, m=0,25, increasing luminosity according to 'm'; // colour=n*10+m, m=1,2,...9, will produce the same colour // as 'n', but with increasing luminosity according to 'm'; // COLO<0 will act as if abs(COLO) was set for the volume // and for all the levels below it. // When for a volume the attribute FILL is > 1 (and the // option SHAD is on), the ABS of its colour code must be < 8 // because an automatic shading of its faces will be // performed. // // FILL (1992) fill area -7,...,0,1,...7 (default=0) // when option SHAD is "on" the FILL attribute of any // volume can be set different from 0 (normal drawing); // if it is set to 1, the faces of such volume will be filled // with solid colours; if ABS(FILL) is > 1, then a light // source is placed along the observer line, and the faces of // such volumes will be painted by colours whose luminosity // will depend on the amount of light reflected; // if ABS(FILL) = 1, then it is possible to use all the 166 // colours of the colour table, becouse the automatic shading // is not performed; // for increasing values of FILL the drawing will be performed // with higher and higher resolution improving the quality (the // number of scan lines used to fill the faces increases with FILL); // it is possible to set different values of FILL // for different volumes, in order to optimize at the same time // the performance and the quality of the picture; // FILL<0 will act as if abs(FILL) was set for the volume // and for all the levels below it. // This kind of drawing can be saved in 'picture files' // or in view banks. // 0=drawing without fill area // 1=faces filled with solid colours and resolution = 6 // 2=lowest resolution (very fast) // 3=default resolution // 4=................. // 5=................. // 6=................. // 7=max resolution // Finally, if a coloured background is desired, the FILL // attribute for the first volume of the tree must be set // equal to -abs(colo), colo being >0 and <166. // // SET set number associated to volume name // DET detector number associated to volume name // DTYP detector type (1,2) // // InitHIGZ(); gGeoManager->SetVolumeAttribute(name, att, val); }

void TGeant3TGeo::Gsdvn (  const char *  name, const char *  mother, Int_t  ndiv, Int_t  iaxis )  [virtual]

Reimplemented from TGeant3. Definition at line 1413 of file TGeant3TGeo.cxx. References fMCGeo. { // // Create a new volume by dividing an existing one // // NAME Volume name // MOTHER Mother volume name // NDIV Number of divisions // IAXIS Axis value // // X,Y,Z of CAXIS will be translated to 1,2,3 for IAXIS. // It divides a previously defined volume. // fMCGeo->Gsdvn(name, mother, ndiv, iaxis); }

void TGeant3TGeo::Gsdvn2 (  const char *  name, const char *  mother, Int_t  ndiv, Int_t  iaxis, Double_t  c0i, Int_t  numed )  [virtual]

Reimplemented from TGeant3. Definition at line 1431 of file TGeant3TGeo.cxx. References fMCGeo. { // // Create a new volume by dividing an existing one // // Divides mother into ndiv divisions called name // along axis iaxis starting at coordinate value c0. // the new volume created will be medium number numed. // fMCGeo->Gsdvn2(name, mother, ndiv, iaxis, c0i, numed); }

void TGeant3TGeo::Gsdvs (  const char *  name, const char *  mother, Float_t  step, Int_t  iaxis, Int_t  numed )  [virtual]

Reimplemented from TGeant3. Definition at line 1445 of file TGeant3TGeo.cxx. { // // Create a new volume by dividing an existing one // gGeoManager->Division(name,mother,iaxis,0,0,step,numed,"s"); }

void TGeant3TGeo::Gsdvs2 (  const char *  name, const char *  mother, Float_t  step, Int_t  iaxis, Float_t  c0, Int_t  numed )  [virtual]

Reimplemented from TGeant3. Definition at line 1455 of file TGeant3TGeo.cxx. { // // Create a new volume by dividing an existing one // gGeoManager->Division(name,mother,iaxis,0,c0,step,numed,"sx"); }

void TGeant3TGeo::Gsdvt (  const char *  name, const char *  mother, Double_t  step, Int_t  iaxis, Int_t  numed, Int_t  ndvmx )  [virtual]

Reimplemented from TGeant3. Definition at line 1465 of file TGeant3TGeo.cxx. References fMCGeo. { // // Create a new volume by dividing an existing one // // Divides MOTHER into divisions called NAME along // axis IAXIS in steps of STEP. If not exactly divisible // will make as many as possible and will centre them // with respect to the mother. Divisions will have medium // number NUMED. If NUMED is 0, NUMED of MOTHER is taken. // NDVMX is the expected maximum number of divisions // (If 0, no protection tests are performed) // fMCGeo->Gsdvt(name, mother, step, iaxis, numed, ndvmx); }

void TGeant3TGeo::Gsdvt2 (  const char *  name, const char *  mother, Double_t  step, Int_t  iaxis, Double_t  c0, Int_t  numed, Int_t  ndvmx )  [virtual]

Reimplemented from TGeant3. Definition at line 1483 of file TGeant3TGeo.cxx. References fMCGeo. { // // Create a new volume by dividing an existing one // // Divides MOTHER into divisions called NAME along // axis IAXIS starting at coordinate value C0 with step // size STEP. // The new volume created will have medium number NUMED. // If NUMED is 0, NUMED of mother is taken. // NDVMX is the expected maximum number of divisions // (If 0, no protection tests are performed) // fMCGeo->Gsdvt2(name, mother, step, iaxis, c0, numed, ndvmx); }

void TGeant3TGeo::Gsmate (  Int_t  imat, const char *  name, Float_t  a, Float_t  z, Float_t  dens, Float_t  radl, Float_t  absl )  [virtual]

Reimplemented from TGeant3. Definition at line 1193 of file TGeant3TGeo.cxx. References g3smate, PASSCHARD, and PASSCHARL. { // // Defines a Material // // kmat number assigned to the material // name material name // a atomic mass in au // z atomic number // dens density in g/cm3 // absl absorbtion length in cm // if >=0 it is ignored and the program // calculates it, if <0. -absl is taken // radl radiation length in cm // if >=0 it is ignored and the program // calculates it, if <0. -radl is taken // buf pointer to an array of user words // nbuf number of user words // Float_t *ubuf=0; Int_t nbuf=0; if (dens <= 0 && a != 0 && z != 0) { Warning("Gsmate","Density was o, set to 0.01 for imat=%d, name=%s",imat,name); dens = 0.01; } g3smate(imat,PASSCHARD(name), a, z, dens, radl, absl, ubuf, nbuf PASSCHARL(name)); gGeoManager->Material(name,a,z,dens,imat); }

void TGeant3TGeo::Gsmixt (  Int_t  imat, const char *  name, Float_t *  a, Float_t *  z, Float_t  dens, Int_t  nlmat, Float_t *  wmat )  [virtual]

Reimplemented from TGeant3. Definition at line 1226 of file TGeant3TGeo.cxx. References fMCGeo, g3smixt, PASSCHARD, and PASSCHARL. { // // Defines mixture OR COMPOUND IMAT as composed by // THE BASIC NLMAT materials defined by arrays A,Z and WMAT // // If NLMAT.GT.0 then WMAT contains the PROPORTION BY // WEIGTHS OF EACH BASIC MATERIAL IN THE MIXTURE. // // If NLMAT.LT.0 then WMAT contains the number of atoms // of a given kind into the molecule of the COMPOUND // In this case, WMAT in output is changed to relative // weigths. // g3smixt(imat,PASSCHARD(name),a,z,dens,nlmat,wmat PASSCHARL(name)); fMCGeo->Mixture(imat, name, a, z, dens, TMath::Abs(nlmat), wmat); }

void TGeant3TGeo::Gsord (  const char *  name, Int_t  iax )  [virtual]

Reimplemented from TGeant3. Definition at line 1501 of file TGeant3TGeo.cxx. { // // Flags volume CHNAME whose contents will have to be ordered // along axis IAX, by setting the search flag to -IAX // IAX = 1 X axis // IAX = 2 Y axis // IAX = 3 Z axis // IAX = 4 Rxy (static ordering only -> GTMEDI) // IAX = 14 Rxy (also dynamic ordering -> GTNEXT) // IAX = 5 Rxyz (static ordering only -> GTMEDI) // IAX = 15 Rxyz (also dynamic ordering -> GTNEXT) // IAX = 6 PHI (PHI=0 => X axis) // IAX = 7 THETA (THETA=0 => Z axis) // }

void TGeant3TGeo::Gspos (  const char *  name, Int_t  nr, const char *  mother, Double_t  x, Double_t  y, Double_t  z, Int_t  irot, const char *  konly = "ONLY" )  [virtual]

Reimplemented from TGeant3. Definition at line 1520 of file TGeant3TGeo.cxx. References fMCGeo. { // // Position a volume into an existing one // // NAME Volume name // NUMBER Copy number of the volume // MOTHER Mother volume name // X X coord. of the volume in mother ref. sys. // Y Y coord. of the volume in mother ref. sys. // Z Z coord. of the volume in mother ref. sys. // IROT Rotation matrix number w.r.t. mother ref. sys. // ONLY ONLY/MANY flag // // It positions a previously defined volume in the mother. // fMCGeo->Gspos(name, nr, mother, x, y, z, irot, konly); }

void TGeant3TGeo::Gsposp (  const char *  name, Int_t  nr, const char *  mother, Double_t  x, Double_t  y, Double_t  z, Int_t  irot, const char *  konly, Double_t *  upar, Int_t  np )  [virtual]

Reimplemented from TGeant3. Definition at line 1554 of file TGeant3TGeo.cxx. References fMCGeo. { // // Place a copy of generic volume NAME with user number // NR inside MOTHER, with its parameters UPAR(1..NP) // fMCGeo->Gsposp(name, nr, mother, x, y, z, irot, konly, upar, np); }

void TGeant3TGeo::Gsposp (  const char *  name, Int_t  nr, const char *  mother, Double_t  x, Double_t  y, Double_t  z, Int_t  irot, const char *  konly, Float_t *  upar, Int_t  np )  [virtual]

Reimplemented from TGeant3. Definition at line 1541 of file TGeant3TGeo.cxx. References fMCGeo. { // // Place a copy of generic volume NAME with user number // NR inside MOTHER, with its parameters UPAR(1..NP) // fMCGeo->Gsposp(name, nr, mother, x, y, z, irot, konly, upar, np); }

void TGeant3TGeo::Gsrotm (  Int_t  nmat, Float_t  theta1, Float_t  phi1, Float_t  theta2, Float_t  phi2, Float_t  theta3, Float_t  phi3 )  [virtual]

Reimplemented from TGeant3. Definition at line 1567 of file TGeant3TGeo.cxx. { // // nmat Rotation matrix number // THETA1 Polar angle for axis I // PHI1 Azimuthal angle for axis I // THETA2 Polar angle for axis II // PHI2 Azimuthal angle for axis II // THETA3 Polar angle for axis III // PHI3 Azimuthal angle for axis III // // It defines the rotation matrix number IROT. // gGeoManager->Matrix(nmat, theta1, phi1, theta2, phi2, theta3, phi3); }

void TGeant3TGeo::Gstmed (  Int_t  numed, const char *  name, Int_t  nmat, Int_t  isvol, Int_t  ifield, Float_t  fieldm, Float_t  tmaxfd, Float_t  stemax, Float_t  deemax, Float_t  epsil, Float_t  stmin )  [virtual]

Reimplemented from TGeant3. Definition at line 1246 of file TGeant3TGeo.cxx. References g3stmed, PASSCHARD, and PASSCHARL. { // // NTMED Tracking medium number // NAME Tracking medium name // NMAT Material number // ISVOL Sensitive volume flag // IFIELD Magnetic field // FIELDM Max. field value (Kilogauss) // TMAXFD Max. angle due to field (deg/step) // STEMAX Max. step allowed // DEEMAX Max. fraction of energy lost in a step // EPSIL Tracking precision (cm) // STMIN Min. step due to continuous processes (cm) // // IFIELD = 0 if no magnetic field; IFIELD = -1 if user decision in GUSWIM; // IFIELD = 1 if tracking performed with G3RKUTA; IFIELD = 2 if tracking // performed with G3HELIX; IFIELD = 3 if tracking performed with G3HELX3. // Float_t *ubuf=0; Int_t nbuf=0; g3stmed(numed,PASSCHARD(name), nmat, isvol, ifield, fieldm, tmaxfd, stemax, deemax, epsil, stmin, ubuf, nbuf PASSCHARL(name)); gGeoManager->Medium(name,numed,nmat, isvol, ifield, fieldm, tmaxfd, stemax,deemax, epsil, stmin); }

Int_t TGeant3TGeo::Gsvolu (  const char *  name, const char *  shape, Int_t  nmed, Double_t *  upar, Int_t  np )  [virtual]

Reimplemented from TGeant3. Definition at line 1624 of file TGeant3TGeo.cxx. References fMCGeo. { // // NAME Volume name // SHAPE Volume type // NUMED Tracking medium number // NPAR Number of shape parameters // UPAR Vector containing shape parameters // // It creates a new volume in the JVOLUM data structure. // Int_t ivolu = 0; ivolu = fMCGeo->Gsvolu(name, shape, nmed, upar, npar); return ivolu; }

Int_t TGeant3TGeo::Gsvolu (  const char *  name, const char *  shape, Int_t  nmed, Float_t *  upar, Int_t  np )  [virtual]

Reimplemented from TGeant3. Definition at line 1604 of file TGeant3TGeo.cxx. References fMCGeo. { // // NAME Volume name // SHAPE Volume type // NUMED Tracking medium number // NPAR Number of shape parameters // UPAR Vector containing shape parameters // // It creates a new volume in the JVOLUM data structure. // Int_t ivolu = 0; ivolu = fMCGeo->Gsvolu(name, shape, nmed, upar, npar); return ivolu; }

void TGeant3TGeo::Gtreve (   )  [virtual]

Reimplemented from TGeant3. Definition at line 1276 of file TGeant3TGeo.cxx. References g3treve. { // // Controls tracking of all particles belonging to the current event // g3treve(); }

void TGeant3TGeo::GtreveRoot (   )  [virtual]

Reimplemented from TGeant3. Definition at line 1285 of file TGeant3TGeo.cxx. References gtreveroot. { // // Controls tracking of all particles belonging to the current event // gtreveroot(); }

Int_t TGeant3TGeo::ImportMaterial (  const TGeoMaterial *  material  )  [private]

Definition at line 1998 of file TGeant3TGeo.cxx. References TGeant3::CreateFloatArray(), TGeant3::G3Material(), and TGeant3::G3Mixture(). Referenced by FinishGeometry(). { // Imports the Root material in Geant3 and returns its Geant3 index // --- Int_t kmat; const TGeoMixture* mixt = dynamic_cast<const TGeoMixture*>(mat); if (mixt) { // TGeo stores only proportions by weigth Int_t nlmat = mixt->GetNelements(); Float_t* fa = CreateFloatArray(mixt->GetAmixt(), TMath::Abs(nlmat)); Float_t* fz = CreateFloatArray(mixt->GetZmixt(), TMath::Abs(nlmat)); Float_t* fwmat = CreateFloatArray(mixt->GetWmixt(), TMath::Abs(nlmat)); G3Mixture(kmat, mixt->GetName(), fa, fz, mixt->GetDensity(), TMath::Abs(nlmat), fwmat); delete [] fa; delete [] fz; delete [] fwmat; } else { Float_t* buf = 0; // Inject radlen with negative sign to be stored in G3 Double_t radlen = mat->GetRadLen(); // Ignore abslen from TGeo and let G3 compute it G3Material(kmat, mat->GetName(), mat->GetA(), mat->GetZ(), mat->GetDensity(), -radlen, 0, buf, 0); } return kmat; }

virtual Bool_t TGeant3TGeo::IsRootGeometrySupported (   )  const [inline, virtual]

Reimplemented from TGeant3. Definition at line 41 of file TGeant3TGeo.h. {return kTRUE;}

void TGeant3TGeo::LoadAddress (   )  [virtual]

Reimplemented from TGeant3. Definition at line 579 of file TGeant3TGeo.cxx. References fGcvol1, gcomad, gcvol1, PASSCHARD, and PASSCHARL. Referenced by TGeant3TGeo(). { // // Assigns the address of the GEANT common blocks to the structures // that allow their access from C++ // // printf("LoadAddress\n"); // TGeant3::LoadAddress(); gcomad(PASSCHARD("GCVOL1"),(int*&) fGcvol1 PASSCHARL("GCVOL1")); gcvol1 = fGcvol1; }

void TGeant3TGeo::Material (  Int_t &  kmat, const char *  name, Double_t  a, Double_t  z, Double_t  dens, Double_t  radl, Double_t  absl, Double_t *  buf, Int_t  nwbuf )  [virtual]

Reimplemented from TGeant3. Definition at line 792 of file TGeant3TGeo.cxx. References TGeant3::CreateFloatArray(), fMCGeo, and TGeant3::G3Material(). { // // Defines a Material // // kmat number assigned to the material // name material name // a atomic mass in au // z atomic number // dens density in g/cm3 // absl absorbtion length in cm // if >=0 it is ignored and the program // calculates it, if <0. -absl is taken // radl radiation length in cm // if >=0 it is ignored and the program // calculates it, if <0. -radl is taken // buf pointer to an array of user words // nbuf number of user words // Float_t* fbuf = CreateFloatArray(buf, nwbuf); G3Material(kmat, name, a, z, dens, radl, absl, fbuf, nwbuf); delete [] fbuf; fMCGeo->Material(kmat, name, a, z, dens, radl, absl, buf, nwbuf); }

void TGeant3TGeo::Material (  Int_t &  kmat, const char *  name, Double_t  a, Double_t  z, Double_t  dens, Double_t  radl, Double_t  absl, Float_t *  buf = 0, Int_t  nwbuf = 0 )  [virtual]

Reimplemented from TGeant3. Definition at line 762 of file TGeant3TGeo.cxx. References TGeant3::CreateFloatArray(), fMCGeo, and TGeant3::G3Material(). { // // Defines a Material // // kmat number assigned to the material // name material name // a atomic mass in au // z atomic number // dens density in g/cm3 // absl absorbtion length in cm // if >=0 it is ignored and the program // calculates it, if <0. -absl is taken // radl radiation length in cm // if >=0 it is ignored and the program // calculates it, if <0. -radl is taken // buf pointer to an array of user words // nbuf number of user words // Float_t* fbuf = CreateFloatArray(buf, nwbuf); G3Material(kmat, name, a, z, dens, radl, absl, fbuf, nwbuf); delete [] fbuf; fMCGeo->Material(kmat, name, a, z, dens, radl, absl, buf, nwbuf); }

void TGeant3TGeo::Matrix (  Int_t &  krot, Double_t  thex, Double_t  phix, Double_t  they, Double_t  phiy, Double_t  thez, Double_t  phiz )  [virtual]

Reimplemented from TGeant3. Definition at line 943 of file TGeant3TGeo.cxx. References fMCGeo. { // // krot rotation matrix number assigned // theta1 polar angle for axis i // phi1 azimuthal angle for axis i // theta2 polar angle for axis ii // phi2 azimuthal angle for axis ii // theta3 polar angle for axis iii // phi3 azimuthal angle for axis iii // // it defines the rotation matrix number irot. // krot = -1; fMCGeo->Matrix(krot, thex, phix, they, phiy, thez, phiz); }

void TGeant3TGeo::Medium (  Int_t &  kmed, const char *  name, Int_t  nmat, Int_t  isvol, Int_t  ifield, Double_t  fieldm, Double_t  tmaxfd, Double_t  stemax, Double_t  deemax, Double_t  epsil, Double_t  stmin, Double_t *  ubuf, Int_t  nbuf )  [virtual]

Reimplemented from TGeant3. Definition at line 910 of file TGeant3TGeo.cxx. References TGeant3::CreateFloatArray(), fMCGeo, and TGeant3::G3Medium(). { // // kmed tracking medium number assigned // name tracking medium name // nmat material number // isvol sensitive volume flag // ifield magnetic field // fieldm max. field value (kilogauss) // tmaxfd max. angle due to field (deg/step) // stemax max. step allowed // deemax max. fraction of energy lost in a step // epsil tracking precision (cm) // stmin min. step due to continuos processes (cm) // // ifield = 0 if no magnetic field; ifield = -1 if user decision in guswim; // ifield = 1 if tracking performed with g3rkuta; ifield = 2 if tracking // performed with g3helix; ifield = 3 if tracking performed with g3helx3. // Float_t* fubuf = CreateFloatArray(ubuf, nbuf); G3Medium(kmed, name, nmat, isvol, ifield, fieldm, tmaxfd, stemax, deemax, epsil, stmin, fubuf, nbuf); delete [] fubuf; fMCGeo->Medium(kmed, name, nmat, isvol, ifield, fieldm, tmaxfd, stemax, deemax, epsil, stmin, ubuf, nbuf); }

void TGeant3TGeo::Medium (  Int_t &  kmed, const char *  name, Int_t  nmat, Int_t  isvol, Int_t  ifield, Double_t  fieldm, Double_t  tmaxfd, Double_t  stemax, Double_t  deemax, Double_t  epsil, Double_t  stmin, Float_t *  ubuf = 0, Int_t  nbuf = 0 )  [virtual]

Reimplemented from TGeant3. Definition at line 879 of file TGeant3TGeo.cxx. References fMCGeo, and TGeant3::G3Medium(). { // // kmed tracking medium number assigned // name tracking medium name // nmat material number // isvol sensitive volume flag // ifield magnetic field // fieldm max. field value (kilogauss) // tmaxfd max. angle due to field (deg/step) // stemax max. step allowed // deemax max. fraction of energy lost in a step // epsil tracking precision (cm) // stmin min. step due to continuous processes (cm) // // ifield = 0 if no magnetic field; ifield = -1 if user decision in guswim; // ifield = 1 if tracking performed with g3rkuta; ifield = 2 if tracking // performed with g3helix; ifield = 3 if tracking performed with g3helx3. // G3Medium(kmed, name, nmat, isvol, ifield, fieldm, tmaxfd, stemax, deemax, epsil, stmin, ubuf, nbuf); fMCGeo->Medium(kmed, name, nmat, isvol, ifield, fieldm, tmaxfd, stemax, deemax, epsil, stmin, ubuf, nbuf); }

void TGeant3TGeo::Mixture (  Int_t &  kmat, const char *  name, Double_t *  a, Double_t *  z, Double_t  dens, Int_t  nlmat, Double_t *  wmat )  [virtual]

Reimplemented from TGeant3. Definition at line 845 of file TGeant3TGeo.cxx. References TGeant3::CreateFloatArray(), fMCGeo, and TGeant3::G3Mixture(). { // // Defines mixture OR COMPOUND IMAT as composed by // THE BASIC NLMAT materials defined by arrays A,Z and WMAT // // If NLMAT > 0 then wmat contains the proportion by // weights of each basic material in the mixture. // // If nlmat < 0 then WMAT contains the number of atoms // of a given kind into the molecule of the COMPOUND // In this case, WMAT in output is changed to relative // weigths. // Float_t* fa = CreateFloatArray(a, TMath::Abs(nlmat)); Float_t* fz = CreateFloatArray(z, TMath::Abs(nlmat)); Float_t* fwmat = CreateFloatArray(wmat, TMath::Abs(nlmat)); G3Mixture(kmat, name, fa, fz, dens, nlmat, fwmat); Int_t i; for (i=0; i<TMath::Abs(nlmat); i++) { a[i] = fa[i]; z[i] = fz[i]; wmat[i] = fwmat[i]; } delete [] fa; delete [] fz; delete [] fwmat; fMCGeo->Mixture(kmat, name, a, z, dens, TMath::Abs(nlmat), wmat); }

void TGeant3TGeo::Mixture (  Int_t &  kmat, const char *  name, Float_t *  a, Float_t *  z, Double_t  dens, Int_t  nlmat, Float_t *  wmat )  [virtual]

Reimplemented from TGeant3. Definition at line 823 of file TGeant3TGeo.cxx. References fMCGeo, and TGeant3::G3Mixture(). { // // Defines mixture OR COMPOUND IMAT as composed by // THE BASIC NLMAT materials defined by arrays A,Z and WMAT // // If NLMAT > 0 then wmat contains the proportion by // weights of each basic material in the mixture. // // If nlmat < 0 then WMAT contains the number of atoms // of a given kind into the molecule of the COMPOUND // In this case, WMAT in output is changed to relative // weigths. // G3Mixture(kmat, name, a, z, dens, nlmat, wmat); fMCGeo->Mixture(kmat, name, a, z, dens, TMath::Abs(nlmat), wmat); }

Int_t TGeant3TGeo::NextVolUp (  Text_t *  name, Int_t &  copy )

Reimplemented from TGeant3. Definition at line 602 of file TGeant3TGeo.cxx. { // // Geometry iterator for moving upward in the geometry tree // Return next volume up // fNextVol--; if (fNextVol>=0) { Int_t level = gGeoManager->GetLevel(); if (level<=fNextVol) return 0; TGeoNode *mother = gGeoManager->GetMother(level-fNextVol); if (!mother) return 0; sprintf(name, "%s", mother->GetVolume()->GetName()); copy = mother->GetNumber(); return mother->GetVolume()->GetNumber(); } return 0; }

Int_t TGeant3TGeo::NofVolDaughters (  const char *  volName  )  const

Reimplemented from TGeant3. Definition at line 713 of file TGeant3TGeo.cxx. References fMCGeo. { // Return number of daughters of the volume specified by volName // According to A. Morsch' G3toRoot class // --- return fMCGeo->NofVolDaughters(volName); }

Int_t TGeant3TGeo::NofVolumes (   )  const

Reimplemented from TGeant3. Definition at line 704 of file TGeant3TGeo.cxx. References fMCGeo. { // // Return total number of volumes in the geometry // return fMCGeo->NofVolumes(); }

TGeant3TGeo& TGeant3TGeo::operator= (  const TGeant3TGeo &   )  [inline, private]

Definition at line 217 of file TGeant3TGeo.h. {return *this;}

void TGeant3TGeo::SetColors (   )  [virtual]

Reimplemented from TGeant3. Definition at line 2107 of file TGeant3TGeo.cxx. Referenced by FinishGeometry(). { // // Set the colors for all the volumes // this is done sequentially for all volumes // based on the number of their medium // TIter next(gGeoManager->GetListOfVolumes()); TGeoVolume *volume; while ((volume = (TGeoVolume*)next())) { if (volume->IsAssembly()) continue; TGeoMedium *medium = (TGeoMedium*)volume->GetMedium(); Int_t icol = medium->GetId()%6+2; volume->SetLineColor(icol); } }

void TGeant3TGeo::SetRootGeometry (   )  [virtual]

Reimplemented from TGeant3. Definition at line 962 of file TGeant3TGeo.cxx. References fImportRootGeometry. { // Notify Geant3 about use of TGeo geometry. // The materials and tracking medias will be imported from // TGeo at FinishGeometry(). fImportRootGeometry = kTRUE; }

Int_t TGeant3TGeo::VolDaughterCopyNo (  const char *  volName, Int_t  i )  const

Reimplemented from TGeant3. Definition at line 734 of file TGeant3TGeo.cxx. References fMCGeo. { // Return the copyNo of i-th daughters of the volume specified by volName // According to A. Morsch' G3toRoot class // --- return fMCGeo->VolDaughterCopyNo(volName, i); }

const char * TGeant3TGeo::VolDaughterName (  const char *  volName, Int_t  i )  const

Reimplemented from TGeant3. Definition at line 723 of file TGeant3TGeo.cxx. References fMCGeo. { // Return the name of i-th daughters of the volume specified by volName // According to A. Morsch' G3toRoot class // --- return fMCGeo->VolDaughterName(volName, i); }

Int_t TGeant3TGeo::VolId (  const Text_t *  name  )  const

Reimplemented from TGeant3. Definition at line 690 of file TGeant3TGeo.cxx. References fMCGeo, and len. { // // Return the unique numeric identifier for volume name // char sname[20]; Int_t len = strlen(name)-1; if (name[len] != ' ') return fMCGeo->VolId(name); strncpy(sname, name, len); sname[len] = 0; return fMCGeo->VolId(sname); }

Int_t TGeant3TGeo::VolId2Mate (  Int_t  id  )  const

Reimplemented from TGeant3. Definition at line 744 of file TGeant3TGeo.cxx. References fMCGeo. { // // Return material number for a given volume id // return fMCGeo->VolId2Mate(id); }

const char * TGeant3TGeo::VolName (  Int_t  id  )  const

Reimplemented from TGeant3. Definition at line 753 of file TGeant3TGeo.cxx. References fMCGeo. { // // Return the volume name given the volume identifier // return fMCGeo->VolName(id); }

---

Member Data Documentation

Gcvol1_t* TGeant3TGeo::fGcvol1 [protected]

Definition at line 212 of file TGeant3TGeo.h. Referenced by LoadAddress().

Bool_t TGeant3TGeo::fImportRootGeometry [protected]

Reimplemented from TGeant3. Definition at line 210 of file TGeant3TGeo.h. Referenced by SetRootGeometry().

TGeoMCGeometry* TGeant3TGeo::fMCGeo [protected]

Reimplemented from TGeant3. Definition at line 209 of file TGeant3TGeo.h. Referenced by GetShape(), GetTransformation(), Gsdvn(), Gsdvn2(), Gsdvt(), Gsdvt2(), Gsmixt(), Gspos(), Gsposp(), Gsvolu(), Material(), Matrix(), Medium(), Mixture(), NofVolDaughters(), NofVolumes(), TGeant3TGeo(), VolDaughterCopyNo(), VolDaughterName(), VolId(), VolId2Mate(), and VolName().

---

The documentation for this class was generated from the following files:

• TGeant3TGeo.h
• TGeant3TGeo.cxx

---