]> git.uio.no Git - u/mrichter/AliRoot.git/commitdiff
First version of AliGeant3
authorhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sun, 16 Jun 2002 17:09:41 +0000 (17:09 +0000)
committerhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sun, 16 Jun 2002 17:09:41 +0000 (17:09 +0000)
25 files changed:
AliGeant3/AliG3Material.cxx [new file with mode: 0644]
AliGeant3/AliG3Material.h [new file with mode: 0644]
AliGeant3/AliG3Medium.cxx [new file with mode: 0644]
AliGeant3/AliG3Medium.h [new file with mode: 0644]
AliGeant3/AliG3Volume.cxx [new file with mode: 0644]
AliGeant3/AliG3Volume.h [new file with mode: 0644]
AliGeant3/AliG3toRoot.cxx [new file with mode: 0644]
AliGeant3/AliG3toRoot.h [new file with mode: 0644]
AliGeant3/AliGUISliders.cxx [new file with mode: 0644]
AliGeant3/AliGUISliders.h [new file with mode: 0644]
AliGeant3/AliGeant3.cxx.orig [new file with mode: 0644]
AliGeant3/AliGeant3.h.orig [new file with mode: 0644]
AliGeant3/AliGeant3Cint.cxx [new file with mode: 0644]
AliGeant3/AliGeant3Cint.h [new file with mode: 0644]
AliGeant3/AliGeant3GUI.C [new file with mode: 0644]
AliGeant3/AliGeant3GeometryGUI.cxx [new file with mode: 0644]
AliGeant3/AliGeant3GeometryGUI.h [new file with mode: 0644]
AliGeant3/AliGeant3LinkDef.h [new file with mode: 0644]
AliGeant3/AliGuiGeomDialog.cxx [new file with mode: 0644]
AliGeant3/AliGuiGeomDialog.h [new file with mode: 0644]
AliGeant3/AliGuiGeomMain.cxx [new file with mode: 0644]
AliGeant3/AliGuiGeomMain.h [new file with mode: 0644]
AliGeant3/AliNode.cxx [new file with mode: 0644]
AliGeant3/AliNode.h [new file with mode: 0644]
AliGeant3/Makefile [new file with mode: 0644]

diff --git a/AliGeant3/AliG3Material.cxx b/AliGeant3/AliG3Material.cxx
new file mode 100644 (file)
index 0000000..030e530
--- /dev/null
@@ -0,0 +1,104 @@
+/* *************************************************************************
+ * 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.1  2001/07/09 11:41:46  morsch
+AliGUIMedium, AliGUIMaterial and AliDrawVolume obselete. Development continues
+on AliG3Material, AliG3Medium and AliG3Volume.
+
+*/
+
+/*
+Old Logs: AliGUIMaterial.cxx,v $
+Revision 1.1  2000/07/13 16:19:10  fca
+Mainly coding conventions + some small bug fixes
+
+Revision 1.8  2000/07/12 08:56:32  fca
+Coding convention correction and warning removal
+
+Revision 1.7  2000/06/28 21:27:45  morsch
+Most coding rule violations corrected.
+Still to do: Split the file (on file per class) ? Avoid the global variables.
+Copy constructors and assignment operators (dummy ?)
+
+Revision 1.6  2000/04/14 11:07:46  morsch
+Correct volume to medium assignment in case several media are asigned to the
+same material.
+
+Revision 1.5  2000/03/20 15:11:03  fca
+Mods to make the code compile on HP
+
+Revision 1.4  2000/01/18 16:12:08  morsch
+Bug in calculation of number of volume divisions and number of positionings corrected
+Browser for Material and Media properties added
+
+Revision 1.3  1999/11/14 14:31:14  fca
+Correct small error and remove compilation warnings on HP
+
+Revision 1.2  1999/11/10 16:53:35  fca
+The new geometry viewer from A.Morsch
+
+*/
+
+/* 
+ *  Version: 0
+ *  Written by Andreas Morsch
+ *  
+ * 
+ *
+ * For questions critics and suggestions to this part of the code
+ * contact andreas.morsch@cern.ch
+ * 
+ **************************************************************************/
+
+#include "AliG3Material.h"
+
+ClassImp(AliG3Material)
+AliG3Material::AliG3Material(char* name, char* title,
+                              Float_t a, Float_t z, Float_t dens, Float_t radl, Float_t intl):
+    TMaterial(name, title, a, z, dens, radl, intl)
+{
+    fId=-1;
+}
+
+
+void AliG3Material::Dump()
+{
+// Dump material information
+    printf("\n *****************************************");
+    printf("\n Material Number:   %10d", fId);
+    printf("\n %s", GetName());
+    printf("\n Mass   Number:     %10.2f", fA);    
+    printf("\n Charge Number:     %10.2f", fZ);
+    printf("\n Density:           %10.2f", fDensity);
+    printf("\n Radiation  Length: %10.2f", fRadLength);
+    printf("\n Absorption Length: %10.2f", fInterLength);              
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/AliGeant3/AliG3Material.h b/AliGeant3/AliG3Material.h
new file mode 100644 (file)
index 0000000..dc4fb62
--- /dev/null
@@ -0,0 +1,40 @@
+#ifndef ALIG3MATERIAL_H
+#define ALIG3MATERIAL_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+
+#include "TMaterial.h"
+
+class AliG3Material : public TMaterial 
+{
+public:
+    AliG3Material(){}
+    AliG3Material(char* name, char* title,
+                  Float_t a, Float_t z, Float_t dens, Float_t radl, Float_t intl);
+    
+    virtual ~AliG3Material(){}
+    // Dump material parameters
+    virtual void  Dump();
+    // Get material id
+    virtual Int_t Id()    {return fId;}
+    virtual void  SetId(Int_t id) {fId = id;}
+    
+private:
+    Int_t   fId;          // Id number of the material
+    AliG3Material(const AliG3Material &) {}
+    AliG3Material &operator=(const AliG3Material &) {return *this;}
+
+    ClassDef(AliG3Material,1) // Material Object for GUI 
+};
+
+#endif
+
+
+
+
+
+
+
+
diff --git a/AliGeant3/AliG3Medium.cxx b/AliGeant3/AliG3Medium.cxx
new file mode 100644 (file)
index 0000000..091ed39
--- /dev/null
@@ -0,0 +1,143 @@
+/* *************************************************************************
+ * 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.1  2001/07/09 11:41:46  morsch
+AliGUIMedium, AliGUIMaterial and AliDrawVolume obselete. Development continues
+on AliG3Material, AliG3Medium and AliG3Volume.
+
+*/
+
+/*
+Old logs: AliGUIMedium.cxx,v $
+Revision 1.1  2000/07/13 16:19:10  fca
+Mainly coding conventions + some small bug fixes
+
+Revision 1.8  2000/07/12 08:56:32  fca
+Coding convention correction and warning removal
+
+Revision 1.7  2000/06/28 21:27:45  morsch
+Most coding rule violations corrected.
+Still to do: Split the file (on file per class) ? Avoid the global variables.
+Copy constructors and assignment operators (dummy ?)
+
+Revision 1.6  2000/04/14 11:07:46  morsch
+Correct volume to medium assignment in case several media are asigned to the
+same material.
+
+Revision 1.5  2000/03/20 15:11:03  fca
+Mods to make the code compile on HP
+
+Revision 1.4  2000/01/18 16:12:08  morsch
+Bug in calculation of number of volume divisions and number of positionings corrected
+Browser for Material and Media properties added
+
+Revision 1.3  1999/11/14 14:31:14  fca
+Correct small error and remove compilation warnings on HP
+
+Revision 1.2  1999/11/10 16:53:35  fca
+The new geometry viewer from A.Morsch
+
+*/
+
+/* 
+ *  Version: 0
+ *  Written by Andreas Morsch
+ *  
+ * 
+ *
+ * For questions critics and suggestions to this part of the code
+ * contact andreas.morsch@cern.ch
+ * 
+ **************************************************************************/
+
+#include "AliG3Medium.h"
+
+ClassImp(AliG3Medium)
+
+AliG3Medium::AliG3Medium()
+{ 
+// constructor
+    fId=-1;
+}
+
+AliG3Medium::AliG3Medium(Int_t imed, Int_t imat, const char* name, 
+                          Int_t isvol, Int_t ifield,
+                          Float_t fieldm, Float_t tmaxfd, 
+                          Float_t stemax, Float_t deemax,
+                          Float_t epsil, Float_t stmin)
+    : TNamed(name, "Medium")
+{
+// constructor
+    fId=imed;
+    fIdMat=imat;
+    fIsvol=isvol;
+    fIfield=ifield;
+    fFieldm=fieldm;
+    fTmaxfd=tmaxfd;
+    fStemax=stemax;
+    fDeemax=deemax;
+    fEpsil=epsil;
+    fStmin=stmin;
+}
+
+void AliG3Medium::Dump()
+{
+// Dummy dump
+    ;
+}
+
+Int_t AliG3Medium::Id()
+{
+// return medium id
+    return fId;
+}
+
+
+Float_t AliG3Medium::GetPar(Int_t ipar)
+{ 
+// Get parameter number ipar
+    Float_t p;
+    if (ipar < 23) {
+       p= fPars[ipar-1];   
+    } else if(ipar >=23 && ipar <27) {
+       p= fPars[ipar-1+3];   
+    } else {
+       p= fPars[ipar-1+4];   
+    }
+    
+    return p;
+}
+void AliG3Medium::Streamer(TBuffer &)
+{
+// dummy streamer
+;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/AliGeant3/AliG3Medium.h b/AliGeant3/AliG3Medium.h
new file mode 100644 (file)
index 0000000..8c3971e
--- /dev/null
@@ -0,0 +1,63 @@
+#ifndef ALIG3Medium_H
+#define ALIG3Medium_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+
+#include "TNamed.h"
+
+const static Int_t kNPars=33;
+
+class AliG3Medium : public TNamed
+{
+public:
+    AliG3Medium();
+    AliG3Medium(Int_t imed, Int_t imat, const char* name, 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 ~AliG3Medium(){;}
+    // Dump medium parameters
+    virtual void    Dump();
+    // Get id
+    virtual Int_t   Id();
+    // Get parameters
+    virtual Int_t   IdMat()   {return fIdMat;}
+    virtual Int_t   Isvol()   {return fIsvol;}
+    virtual Int_t   Ifield()  {return fIfield;}
+    virtual Float_t Fieldm()  {return fFieldm;}    
+    virtual Float_t Tmaxfd()  {return fTmaxfd;}        
+    virtual Float_t Stemax()  {return fStemax;}    
+    virtual Float_t Deemax()  {return fDeemax;}        
+    virtual Float_t Epsil()   {return fEpsil;}
+    virtual Float_t Stmin()   {return fStmin;}
+    virtual void    SetPar(Int_t ipar, Float_t par) {fPars[ipar-1]=par;}
+    virtual Float_t GetPar(Int_t ipar);
+    // Set and get link to widget entry
+    virtual Int_t ItemId() {return fItem;}
+    virtual void  SetItemId(Int_t id) {fItem=id;}
+    
+ private:
+    Float_t fPars[kNPars];   // special medium parameters
+    Int_t   fId;             // Id number of the Medium
+    Int_t   fIdMat;          // Associated material
+    Int_t   fIsvol;          // Sensitivity flag 
+    Int_t   fIfield;         // Magnetic Field Flag
+    Float_t fFieldm;         // Maximum Field Strength
+    Float_t fTmaxfd;         // Max. Ang. Deviation
+    Float_t fStemax;         // Maximum Step   
+    Float_t fDeemax;         // Max. Frac. Energy Loss",
+    Float_t fEpsil;          // Crossing Precission 
+    Float_t fStmin;          // Minimum Step Size
+    //
+    Int_t   fItem;           // Link to Widget Entry
+
+  AliG3Medium(const AliG3Medium&) {}
+  AliG3Medium & operator=(const AliG3Medium&) {return *this;}
+
+    ClassDef(AliG3Medium,1) // Tracking Medium Object for GUI 
+};
+
+#endif
diff --git a/AliGeant3/AliG3Volume.cxx b/AliGeant3/AliG3Volume.cxx
new file mode 100644 (file)
index 0000000..58477a9
--- /dev/null
@@ -0,0 +1,577 @@
+/* *************************************************************************
+ * 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.1  2001/07/09 11:41:46  morsch
+AliGUIMedium, AliGUIMaterial and AliDrawVolume obselete. Development continues
+on AliG3Material, AliG3Medium and AliG3Volume.
+
+*/
+
+/*
+Old Logs: AliDrawVolume.cxx,v $
+Revision 1.1  2000/07/13 16:19:10  fca
+Mainly coding conventions + some small bug fixes
+
+Revision 1.8  2000/07/12 08:56:32  fca
+Coding convention correction and warning removal
+
+Revision 1.7  2000/06/28 21:27:45  morsch
+Most coding rule violations corrected.
+Still to do: Split the file (on file per class) ? Avoid the global variables.
+Copy constructors and assignment operators (dummy ?)
+
+Revision 1.6  2000/04/14 11:07:46  morsch
+Correct volume to medium assignment in case several media are asigned to the
+same material.
+
+Revision 1.5  2000/03/20 15:11:03  fca
+Mods to make the code compile on HP
+
+Revision 1.4  2000/01/18 16:12:08  morsch
+Bug in calculation of number of volume divisions and number of positionings corrected
+Browser for Material and Media properties added
+
+Revision 1.3  1999/11/14 14:31:14  fca
+Correct small error and remove compilation warnings on HP
+
+Revision 1.2  1999/11/10 16:53:35  fca
+The new geometry viewer from A.Morsch
+
+*/
+
+/* 
+ *  Version: 0
+ *  Written by Andreas Morsch
+ *  
+ * 
+ *
+ * For questions critics and suggestions to this part of the code
+ * contact andreas.morsch@cern.ch
+ * 
+ **************************************************************************/
+
+#include "AliG3Volume.h"
+#include <TArrayF.h>
+#include "TMaterial.h"
+#include "TShape.h"
+#include "TTUBE.h"
+#include "TBRIK.h"
+#include "TTRD1.h"
+#include "TTRD2.h"
+#include "TTRAP.h"
+#include "TTUBS.h"
+#include "TCONE.h"
+#include "TCONS.h"
+#include "TSPHE.h"
+#include "TPARA.h"
+#include "TPGON.h"
+#include "TPCON.h"
+#include "TTUBS.h"
+#include "TELTU.h"
+#include "THYPE.h"
+#include "TGTRA.h"
+#include "TCTUB.h"
+
+ClassImp(AliG3Volume)
+
+    AliG3Volume::AliG3Volume(const char* name) 
+       : TNamed(name, " ")
+{
+// Constructor
+
+    fTheta  = 30;
+    fPhi    = 30;
+    fPsi    = 0;
+    fU      = 10;
+    fV      = 10;
+    fUscale = 0.01;
+    fVscale = 0.01;
+    fHide=0;
+    fShadow=0;
+    fFill=1;
+    fSeen=1;
+    fClip=0;
+    fClipXmin=0.;
+    fClipXmax=2000.;
+    fClipYmin=0.;
+    fClipYmax=2000.;
+    fClipZmin=0.;
+    fClipZmax=2000.;
+    fNParam = 0;
+    fPosition.Set(3);
+    fCopies = new TList;
+    fNCopies = 0;
+    fPosp = kFALSE;
+    fAxis = -1;
+}
+
+AliG3Volume::AliG3Volume(const AliG3Volume& volume)
+    : TNamed(volume)
+{
+// Constructor
+
+    fTheta  = 30;
+    fPhi    = 30;
+    fPsi    = 0;
+    fU      = 10;
+    fV      = 10;
+    fUscale = 0.01;
+    fVscale = 0.01;
+    fHide=0;
+    fShadow=0;
+    fFill=1;
+    fSeen=1;
+    fClip=0;
+    fClipXmin=0.;
+    fClipXmax=2000.;
+    fClipYmin=0.;
+    fClipYmax=2000.;
+    fClipZmin=0.;
+    fClipZmax=2000.;
+    fAxis = -1;
+//
+    fIdVolume   = volume.GetIdVolume();
+    fIdCopy     = volume.GetIdCopy();
+    fIdMedium   = volume.Medium();
+    fIdMaterial = volume.Material();
+    fPosition   = volume.Position(0);
+    fShape      = volume.Shape();
+    fRotMatrix  = volume.RotMatrix();
+    TArrayF par;
+    volume.Parameters(0, fParameters);
+    fNCopies    = volume.NCopies();
+    fPosp       = volume.Posp();
+    
+    fNParam     = volume.NParam();
+    fCopies     = volume.Copies();
+    fRotMatrix  = volume.RotMatrix();
+    volume.Division(fNdiv, fAxis, fStartC, fStep);
+    
+}
+
+
+
+
+void AliG3Volume::Draw(Option_t *)
+{
+// Wraps the geant Gdraw
+    gMC->Gsatt(fName,"seen", fSeen);
+    
+    if (fHide) {
+       gMC->Gdopt("hide", "on");
+    } else {
+       gMC->Gdopt("hide", "off");
+    }
+
+    if (fShadow) {
+       gMC->Gdopt("shad", "on");
+       gMC->Gsatt("*", "fill", fFill);
+    } else {
+       gMC->Gdopt("shad", "off");
+    }
+
+       gMC->SetClipBox(".");
+    if (fClip) {
+       gMC->SetClipBox("*", fClipXmin, fClipXmax, 
+                       fClipYmin, fClipYmax, fClipZmin, fClipZmax);
+    } else {
+       gMC->SetClipBox(".");
+    }
+    
+
+    gMC->Gdraw(fName, fTheta, fPhi, fPsi, fU, fV, fUscale, fVscale);
+    THIGZ *higz = (THIGZ*)gROOT->GetListOfCanvases()->FindObject("higz");
+    if (higz) higz->Update();
+}
+
+void AliG3Volume::DrawSpec()
+{
+// Wraps the Geant DrawSpec
+    gMC->Gsatt(fName,"seen", fSeen);
+    
+    if (fHide) {
+       gMC->Gdopt("hide", "on");
+    } else {
+       gMC->Gdopt("hide", "off");
+    }
+
+    if (fShadow) {
+       gMC->Gdopt("shad", "on");
+       gMC->Gsatt("*", "fill", fFill);
+    } else {
+       gMC->Gdopt("shad", "off");
+    }
+
+    gMC->SetClipBox(".");
+    if (fClip) {
+       gMC->SetClipBox("*", fClipXmin, fClipXmax, fClipYmin, fClipYmax, fClipZmin, fClipZmax);
+    } else {
+       gMC->SetClipBox(".");
+    }
+    
+
+    ((TGeant3*) gMC)->DrawOneSpec(fName);
+    THIGZ *higz = (THIGZ*)gROOT->GetListOfCanvases()->FindObject("higz");
+    if (higz) higz->Update();
+}
+
+void AliG3Volume::SetParam(Int_t ip, Float_t param)
+{
+// Set drawing parameters
+    switch (ip) {
+    case kTheta:
+       fTheta=param;
+       break;
+    case kPhi:
+       fPhi=param;
+       break;
+    case kPsi:
+       fPsi=param;
+       break;
+    case kU:
+       fU=param;
+       break;
+    case kV:
+       fV=param;
+       break;
+    case kUscale:
+       fUscale=param;
+       break;
+    case kVscale:
+       fVscale=param;
+       break;
+    case kHide:
+       fHide=Int_t(param);
+       break;
+    case kShadow:
+       fShadow=Int_t(param);
+       break;
+    case kFill:
+       fFill=Int_t(param);
+       break;
+    case kSeen:
+       fSeen=Int_t(param);
+       break;
+    case kClip:
+       fClip=Int_t(param);
+       break;
+    case kClipXmin:
+       fClipXmin=param;
+       break;
+    case kClipXmax:
+       fClipXmax=param;
+       break;
+    case kClipYmin:
+       fClipYmin=param;
+       break;
+    case kClipYmax:
+       fClipYmax=param;
+       break;
+    case kClipZmin:
+       fClipZmin=param;
+       break;
+    case kClipZmax:
+       fClipZmax=param;
+       break;
+    }
+}
+
+Float_t  AliG3Volume::GetParam(Int_t ip)
+{
+// Get drawing parameters
+    switch (ip) {
+    case kTheta:
+       return fTheta;
+    case kPhi:
+       return fPhi;
+    case kPsi:
+       return fPsi;
+    case kU:
+       return fU;
+    case kV:
+       return fV;
+    case kUscale:
+       return fUscale;
+    case kVscale:
+       return fVscale;
+    case kHide:
+       return Float_t(fHide);
+    case kShadow:
+       return Float_t(fShadow);
+    case kFill:
+       return Float_t(fFill);
+    case kSeen:
+       return Float_t(fSeen);
+    case kClip:
+       return Float_t(fClip);
+    case kClipXmin:
+       return fClipXmin;
+    case kClipXmax:
+       return fClipXmax;
+    case kClipYmin:
+       return fClipYmin;
+    case kClipYmax:
+       return fClipYmax;
+    case kClipZmin:
+       return fClipZmin;
+    case kClipZmax:
+       return fClipZmax;
+    default:
+       return 0.;
+    }
+    return 0.;
+}
+
+void  AliG3Volume::AddCopy(AliG3Volume* volume)
+{
+    volume->SetIdMaterial(Material());
+    fCopies->Add(volume);
+    fNCopies++;
+}
+
+AliG3Volume* AliG3Volume::Copy(Int_t i)
+{
+    return (AliG3Volume*) fCopies->At(i);
+}
+
+
+TArrayF AliG3Volume::Position(Int_t i) const
+{
+//
+// Get position for volume copy i 
+//
+    if (i==0) {
+       return fPosition;
+    } else {
+       return ((AliG3Volume*) fCopies->At(i-1))->Position(0);
+    }
+}
+
+void AliG3Volume::SetPosition(Float_t x, Float_t y, Float_t z)
+{
+//
+// Set position
+//
+  fPosition[0] = x;
+  fPosition[1] = y;
+  fPosition[2] = z;
+}
+
+
+void  AliG3Volume::SetParameters(Int_t np, Float_t* param) 
+{
+//
+// Set parameters 
+//
+    fParameters.Set(np);
+    for (Int_t j=0; j<np; j++) fParameters[j]=param[j];
+    fNParam = np;
+}
+    
+
+void  AliG3Volume::Parameters(Int_t i, TArrayF& param) const
+{
+//
+// Get parameters for volume copy i 
+//
+    TArrayF p;
+    if (i==0) {
+       p = fParameters;
+    } else {
+       ((AliG3Volume*) (fCopies->At(i-1)))->Parameters(0, p);
+    }
+    Int_t np = fNParam;
+    param.Set(np);
+    for (Int_t j=0; j<np; j++) {
+       param[j] = p.At(j);
+    }
+}
+    
+
+void AliG3Volume::CreateTShape(char* nameV, TMaterial* mat)
+{
+//
+// Create a root volume from G3 volume
+//
+    Int_t   ip;
+    
+    Float_t kRadDeg = 180./TMath::Pi();
+    Float_t theta, phi, alpha1, alpha2;
+    Float_t p1, p2;
+    
+    TShape* nShape=0;
+    const char* tmp = mat->GetName();
+    char nameM[21];
+    strncpy(nameM, tmp, 20);
+    nameM[20]='\0';
+    switch(fShape)
+    {
+    case 1:
+// BOX
+       nShape = new TBRIK(nameV,"BRIK",nameM,fParameters[0], fParameters[1], fParameters[2]);
+       break;
+       
+    case 2:
+// TRD1          
+       nShape = new TTRD1(nameV, "TRD1", nameM, fParameters[0], fParameters[1], fParameters[2],
+                          fParameters[3]);
+       break;
+       
+    case 3:
+// TRD2
+       nShape = new TTRD2(nameV, "TRD2", nameM, fParameters[0], fParameters[1], fParameters[2], 
+                          fParameters[3], fParameters[4]);
+       break;
+       
+    case 4:
+// TRAP
+       p1     = fParameters[1];
+       p2     = fParameters[2];
+       
+       theta  = TMath::ATan(TMath::Sqrt(p1*p1+p2*p2))*kRadDeg;
+       phi    = TMath::ATan2(p2,p1)*kRadDeg;
+       alpha1 = fParameters[6 ]*kRadDeg;
+       alpha2 = fParameters[10]*kRadDeg;
+
+       if (theta < 0.) theta+=180.;
+       
+       nShape =  new TTRAP(nameV, "TRAP", nameM, fParameters[0], 
+                           theta, phi,
+                           fParameters[3], fParameters[4], fParameters[5], 
+                           alpha1, 
+                           fParameters[7], fParameters[8], fParameters[9], 
+                           alpha2);
+       break;
+       
+    case 5:
+// TUBE
+       nShape =  new TTUBE(nameV,"TUBE",nameM,fParameters[0], fParameters[1], fParameters[2]);
+       break;
+       
+    case 6:
+// TUBS
+       nShape =  new TTUBS(nameV,"TUBS",nameM,fParameters[0], fParameters[1], fParameters[2], 
+                           fParameters[3], fParameters[4]);
+       break;
+       
+    case 7:
+// CONE
+       nShape =  new TCONE(nameV, "CONE", nameM, fParameters[0], fParameters[1], fParameters[2], 
+                           fParameters[3], fParameters[4]);
+       break;
+       
+    case 8:
+       
+// CONS
+       nShape =  new TCONS(nameV, "CONS", nameM, fParameters[0], fParameters[1], fParameters[2], 
+                           fParameters[3], fParameters[4], fParameters[5], fParameters[6]);
+       break;
+       
+    case 9:
+// SPHE
+       
+       nShape =  new TSPHE(nameV, "SPHE", nameM, fParameters[0], fParameters[1], fParameters[2], 
+                           fParameters[3], fParameters[4], fParameters[5]);
+       break;
+       
+    case 10:
+// PARA
+       alpha1 = fParameters[3]*kRadDeg;
+       p1     = fParameters[4];
+       p2     = fParameters[5];
+       theta  = TMath::ATan(TMath::Sqrt(p1*p1+p2*p2))*kRadDeg;
+       phi    = TMath::ATan2(p2,p1)*kRadDeg;
+
+       nShape =  new TPARA(nameV, "PARA", nameM, fParameters[0], fParameters[1], fParameters[2], 
+                                   alpha1, theta, phi);
+       break;
+       
+    case 11:
+// PGON
+       nShape =  new TPGON(nameV, "PGON", nameM, fParameters[0], fParameters[1], Int_t(fParameters[2]), 
+                           Int_t(fParameters[3]));
+       for (ip=0; ip<Int_t(fParameters[3]); ip++) {
+           ((TPGON*) nShape)->DefineSection(ip, fParameters[4+3*ip], fParameters[4+3*ip+1], 
+                                            fParameters[4+3*ip+2]);
+       }
+       break;
+       
+    case 12:
+// PCON
+       nShape = new TPCON(nameV, "PCON", nameM, fParameters[0], fParameters[1], Int_t(fParameters[2]));
+       for (ip=0; ip<Int_t(fParameters[2]); ip++) {
+           ((TPCON*) nShape)->DefineSection(ip, fParameters[3+3*ip], fParameters[3+3*ip+1], 
+                                            fParameters[3+3*ip+2]);
+       }
+       break;
+       
+    case 13:
+// ELTU  
+       nShape = new TELTU(nameV,"ELTU",nameM,fParameters[0], fParameters[1], fParameters[2]);
+       break;
+       
+    case 14:
+// HYPE
+       nShape = new THYPE(nameV,"HYPE",nameM,fParameters[0], fParameters[1], fParameters[2], 
+                          fParameters[3]);
+       break;
+       
+    case 15:
+// GTRA
+       nShape = new TGTRA(nameV, "GTRA", nameM, fParameters[0], fParameters[1], fParameters[2], 
+                          fParameters[3], fParameters[4], fParameters[5], fParameters[6], 
+                          fParameters[7], fParameters[8], fParameters[9], fParameters[10], 
+                          fParameters[11]);
+       break;
+       
+    case 16:
+// CTUB
+       nShape = new TCTUB(nameV, "CTUB", nameM, fParameters[0], fParameters[1], fParameters[2], 
+                          fParameters[3], fParameters[4], fParameters[5], fParameters[6], 
+                          fParameters[7], fParameters[8], fParameters[9], fParameters[10]);
+       break;
+    default:
+       break;
+    }
+    if (nShape) {
+       Float_t density = mat->GetDensity();
+       if (density < 0.01) {
+           nShape->SetVisibility(0);
+       } else {
+           nShape->SetVisibility(1);
+       }
+       
+       Int_t color = Int_t(density/20.*100.);
+       nShape->SetLineColor(color);
+    }
+}
+
+void   AliG3Volume::SetDivision(Int_t ndiv, Int_t axis, Float_t start, Float_t step)
+{
+    fNdiv   = ndiv;
+    fAxis   = axis;
+    fStartC = start;
+    fStep   = step;
+}
+
+void   AliG3Volume::Division(Int_t& ndiv, Int_t& axis, Float_t& start, Float_t& step) const
+{
+    ndiv  = fNdiv;
+    axis  = fAxis;
+    start = fStartC;
+    step  = fStep;
+}
diff --git a/AliGeant3/AliG3Volume.h b/AliGeant3/AliG3Volume.h
new file mode 100644 (file)
index 0000000..6a8747d
--- /dev/null
@@ -0,0 +1,153 @@
+#ifndef ALIG3VOLUME_H
+#define ALIG3VOLUME_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+
+#include <TGListTree.h>
+#include "TROOT.h"
+
+#include "THIGZ.h"
+#include "TGeant3.h"
+#include "TArrayF.h"
+#include "TNamed.h"
+#include "TList.h"
+
+class TShape;
+class TMaterial;
+
+class AliG3Volume : public TNamed 
+{
+public:
+    AliG3Volume() {;}
+    AliG3Volume(const char* name);
+    virtual ~AliG3Volume(){;}
+    // G3 the volume
+    virtual void    Draw(Option_t * option =0);
+    // G3 volume specs
+    virtual void    DrawSpec();
+    // Set volume parameter i
+    virtual void    SetParam(Int_t i, Float_t param);
+    // Get volume parameters i
+    virtual Float_t GetParam(Int_t i);
+    // Set volume id
+    virtual void  SetIdVolume(Int_t id) {fIdVolume = id;}
+    // Set volume copy number
+    virtual void  SetIdCopy(Int_t id)   {fIdCopy = id;}
+    // Set volume medium number
+    virtual void  SetIdMedium(Int_t id)   {fIdMedium = id;}
+    // Set volume material number
+    virtual void  SetIdMaterial(Int_t id) {fIdMaterial = id;}
+    // Get volume id
+    virtual Int_t GetIdVolume() const {return fIdVolume;}
+    // Get copy number
+    virtual Int_t GetIdCopy() const {return fIdCopy;}
+    // Get medium number
+    virtual Int_t Medium() const  {return fIdMedium;}
+    // Get material number
+    virtual Int_t Material() const {return fIdMaterial;}
+    // Increase copy number by one
+    virtual void  AddCopy() {fIdCopy ++;}
+    // Set link to ListTree Item 
+    virtual void  SetItem(TObject *item) {fItem = item;}
+    // Get link to ListTree Item
+    virtual void  SetPosition(Float_t x, Float_t y, Float_t z);
+    virtual TArrayF Position(Int_t i) const;
+    
+    virtual void  SetRotMatrix(Int_t irot) {fRotMatrix = irot;}
+    virtual Int_t RotMatrix() const {return fRotMatrix;}
+    virtual void  SetShape(Int_t shape) {fShape = shape;}
+    virtual Int_t Shape() const {return fShape;}
+    virtual void  SetParameters(Int_t np, Float_t* param);
+    virtual Int_t NParam() const {return fNParam;} 
+    virtual void  Parameters(Int_t i, TArrayF& param) const;
+    virtual TList* Copies() const {return fCopies;}
+    virtual void  AddCopy(AliG3Volume* volume);
+    virtual AliG3Volume* Copy(Int_t i);
+    
+    virtual Int_t  NCopies() const {return fNCopies;}
+    virtual Bool_t Posp() const {return fPosp;}
+    virtual void   SetPosp(Bool_t flag) {fPosp = flag;}
+    virtual void   CreateTShape(char* nameV, TMaterial* mat);
+    virtual void   SetDivision(Int_t ndiv, Int_t axis, Float_t start, Float_t step);
+    virtual void   Division(Int_t& ndiv, Int_t& axis, Float_t& start, Float_t& step) const;
+    virtual Int_t   Axis()   {return fAxis;}
+    virtual Int_t   Ndiv()   {return fNdiv;}
+    virtual Float_t Step()   {return fStep;}
+    virtual Float_t StartC() {return fStartC;}
+    
+           
+           
+    virtual TObject* GetItem() {return fItem;}
+
+    AliG3Volume(const AliG3Volume&);
+    
+
+private:
+    
+    TArrayF  fPosition;     // position with respect to mother volume
+    TArrayF  fParameters;   // volume parameters
+    TList*   fCopies;       // volume copies
+    Bool_t   fPosp;         // flag for G3 POSP
+    Int_t    fNCopies;      // number of copies
+    Int_t    fRotMatrix;    // rotation with respect to mother volume
+    Int_t    fNParam;       // number of volume parameters
+    Int_t    fAxis;         // division axis
+    Int_t    fNdiv;         // number of divisions
+    Float_t  fStep;         // number of steps
+    Float_t  fStartC;       // start coordinate
+    Int_t    fShape;       // G3 volume shape
+    Float_t  fTheta;       // theta-angle for drawing
+    Float_t  fPhi;         // phi-angle   for drawing
+    Float_t  fPsi;         // psi-angle   for drawing 
+    Float_t  fU;           // u-position
+    Float_t  fV;           // v-position
+    Float_t  fUscale;      // u-scaling factor
+    Float_t  fVscale;      // v-scaling factor
+    Bool_t   fHide;        // hide flag
+    Bool_t   fShadow;      // shadow flag
+    Int_t    fFill;        // fill option 1-6
+    Int_t    fSeen;        // seen option -2 - 1
+    Bool_t   fClip;        // clipping flag
+    Float_t  fClipXmin;    // clip box range xmin
+    Float_t  fClipXmax;    // clip box range xmax
+    Float_t  fClipYmin;    // clip box range ymin
+    Float_t  fClipYmax;    // clip box range ymax
+    Float_t  fClipZmin;    // clip box range zmin
+    Float_t  fClipZmax;    // clip box range zmax
+    Int_t    fIdVolume;    // geant volume id
+    Int_t    fIdMedium;    // geant medium id
+    Int_t    fIdMaterial;  // geant material id    
+    Int_t    fIdCopy;      // copy flag
+    TObject* fItem;        //!current item
+    AliG3Volume & operator=(const AliG3Volume&) {return *this;}
+
+    ClassDef(AliG3Volume,1) // Volume Object for Drawing 
+};
+
+//
+// Drawing parameter tags
+enum AliDrawParamId {
+   kTheta,
+   kPhi,
+   kPsi,
+   kU,
+   kV,
+   kUscale,
+   kVscale,
+   kShadow,
+   kHide,
+   kFill,
+   kSeen,
+   kClip,
+   kClipXmin,
+   kClipXmax,
+   kClipYmin,
+   kClipYmax,
+   kClipZmin,
+   kClipZmax
+};
+
+
+#endif
diff --git a/AliGeant3/AliG3toRoot.cxx b/AliGeant3/AliG3toRoot.cxx
new file mode 100644 (file)
index 0000000..ad2e7f9
--- /dev/null
@@ -0,0 +1,633 @@
+/* *************************************************************************
+ * 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.3  2002/03/19 09:36:17  morsch
+Unnecessary includes removes, one included. (Jacek M. Holeczek)
+
+Revision 1.2  2001/08/30 09:32:30  hristov
+The operator[] is replaced by At() or AddAt() in case of TObjArray.
+
+Revision 1.1  2001/07/09 11:43:01  morsch
+Class Responsible for G3 -> Root geometry conversion.
+
+*/
+
+
+#include "AliG3toRoot.h"
+#include "AliG3Volume.h"
+#include "AliG3Medium.h"
+#include "AliG3Material.h"
+#include "AliNode.h"
+
+#include <TClonesArray.h>
+#include <TList.h>
+#include <TObjArray.h>
+#include <TFolder.h>
+#include <TRotMatrix.h>
+#include <TFile.h>
+#include <TGeometry.h>
+#include <TBRIK.h>
+
+ClassImp(AliG3toRoot)
+    AliG3toRoot::AliG3toRoot() 
+{
+//  Constructor
+    TFolder* top = gROOT->GetRootFolder ()->AddFolder ("G3toRoot", "Geometry Tree");
+    fTopFolder=top->AddFolder("ALIC", "Top Volume");
+    gROOT->GetListOfBrowsables ()->Add (top, "G3toRoot Folders");
+
+//
+    fVolumes   = new TClonesArray("AliG3Volume",1000);
+    fMaterials = new TClonesArray("AliG3Material",1000);
+    fMedia     = new TClonesArray("AliG3Medium",1000);
+    fRotations = 0;
+    fExpand    = 0;
+    
+//  Store local copy of zebra bank entries
+    TGeant3 *geant3 = (TGeant3*) gMC;
+    if (geant3) {
+       fZlq=geant3->Lq();
+       fZq=geant3->Q();
+       fZiq=geant3->Iq();
+       fGclink=geant3->Gclink();
+       fGcnum=geant3->Gcnum();
+    }
+// Geometry
+    fGeometry = new TGeometry("AliceGeom","Detailed Geometry");
+}
+void AliG3toRoot::G3toRoot()
+{
+    ReadGeometryTree();
+    ReadMaterials();
+    ReadRotations();
+    ConvertToRootShapes();
+
+//
+    TFolder* topFolder = gROOT->GetRootFolder ()->AddFolder ("G3", "G3");
+    TFolder* geoFolder = topFolder->AddFolder("G3toRoot Shapes", "  ");
+    geoFolder->Add(fGeometry);
+    gROOT->GetListOfBrowsables ()->Add(geoFolder, "G3toRoot Shapes");
+
+    TFile* file = new TFile("g3toRootShapes.root", "recreate");
+    geoFolder->Write();
+    file->Close();
+
+    file = new TFile("g3toRootFolders.root", "recreate");
+    fTopFolder->Write();
+    file->Close();
+
+}
+
+void AliG3toRoot::ReadGeometryTree()
+{
+//
+// Copy zebra volume tree into ROOT LisTree
+//
+    char *vname;
+    char /* *namec, */ *tmp;
+    char namec[30];
+
+    AliG3Volume  *volume;
+
+    Int_t nst=0;
+    Int_t nlevel=1;
+    Int_t newlevel=nlevel;
+    Float_t mpar[3] = {2000., 2000., 2000.};
+    
+    
+    volume = new AliG3Volume("ALIC");
+    volume->SetIdVolume(((TGeant3*)gMC)->VolId("ALIC"));
+    volume->SetIdCopy(0);
+    volume->SetShape(1);
+    volume->SetPosition(0.,0.,0.);
+    volume->SetParameters(3,mpar);
+    volume->SetItem(fTopFolder);
+    (*fVolumes)[0]=volume;
+//
+//  Loop over volumes for which information has been collected
+    while(nlevel>nst) {
+       for (Int_t i=nst; i<nlevel; i++) 
+       {
+           TFolder *itemi, *item2;
+// GEANT3 volume number
+           Int_t ivol=TMath::Abs(Volume(i)->GetIdVolume());
+// Copy number
+// icopy=1 normal positioning
+// icopy>1 positioning with parposp
+// icopy<0 division
+           Int_t icopy = Volume(i)->GetIdCopy();
+// Medium and material number, handle special case of divisions
+           Int_t imat, imed;
+           
+           if (icopy <0) {
+               imed=Medium(-ivol);
+               imat=Material(-ivol);
+           } else {
+               imed=Medium(ivol);
+               imat=Material(ivol);
+           }
+
+           TArrayF pos;
+           pos = Volume(i)->Position(0);
+           
+//
+// Number of children
+           Int_t nch = NChildren(ivol);
+           strcpy(namec,((TGeant3*)gMC)->VolName(ivol));
+           if (nch >= 0) {
+               printf("\n %s has %d children  \n ", namec,  nch);
+           } else {
+               printf("\n %s has  divisions \n ", namec);
+           }
+//
+// Name to be used in ListTree
+           vname = new char[5];
+           strncpy(vname,namec, 4);
+           vname[4]='\0';
+
+           if (icopy >1) {
+               sprintf(namec,"%s*%3dPos",namec,icopy);
+           } else if (icopy <0) {
+               sprintf(namec,"%s*%3dDiv",namec,-icopy);
+           }
+           if (i>0) {
+               itemi=(TFolder*) Volume(i)->GetItem();
+           } else {
+               itemi=fTopFolder;
+           }
+           Volume(i)->SetName(namec);
+           Volume(i)->SetIdMedium(imed);
+           Volume(i)->SetIdMaterial(imat);
+           
+//
+// Add volume to list tree
+           
+           if (i>0) {
+               item2 = AddVolume(new AliG3Volume(*Volume(i)), itemi, namec);
+           } else {
+               item2 = fTopFolder;
+               fTopFolder->Add(new AliG3Volume(*Volume(i)));
+           }
+//
+// Collect children information
+//
+// nch < 0: Children by division           
+           if (nch < 0) {
+//
+// Geant volume number
+               Int_t icvol=Child(ivol,1);
+// Name
+               strcpy(namec,((TGeant3*)gMC)->VolName(-icvol));
+               tmp = new char[4];
+               strncpy(tmp,(char *) &namec, 4);
+               volume = new AliG3Volume(namec);
+               volume->SetIdVolume(-icvol);
+
+               Int_t jvo  = fZlq[fGclink->jvolum-ivol];
+               Int_t jdiv = fZlq[jvo-1];
+// Axis
+               Int_t iaxe = Int_t (fZq[jdiv+1]);
+// System volume number
+//             Int_t ivin = Int_t (fZq[jdiv+2]);
+// Number of divisions
+               Int_t ndiv = Int_t (fZq[jdiv+3]);
+// Start value
+               Float_t startc =    fZq[jdiv+4];
+// Step    
+               Float_t step   =    fZq[jdiv+5];
+
+               Int_t ish   = Volume(i)->Shape();
+               Int_t npar  = Volume(i)->NParam();
+// Copy here shape parameters from mother
+// Expand divisions later (when needed)
+               TArrayF apar;
+               apar.Set(npar);
+               Volume(i)->Parameters(0, apar);
+               Float_t* par = new Float_t[npar];
+               for (Int_t jj=0; jj<npar; jj++) par[jj]=apar.At(jj);
+               volume->SetIdCopy(-ndiv);
+               volume->SetDivision(ndiv, iaxe, startc, step);
+               volume->SetParameters(npar, par);
+               volume->SetPosition(0.,0.,0.);
+               volume->SetShape(ish);
+               volume->SetRotMatrix(0);
+// Link to mother
+               volume->SetItem(item2);
+               (*fVolumes)[newlevel]=volume;
+               newlevel++;
+//
+// Children by positioning
+           } else if (nch > 0) {
+               Int_t nnew=0;
+// Loop over children 
+               for (Int_t j=0; j<nch; j++) 
+               {
+                   Int_t jvo  = fZlq[fGclink->jvolum-ivol];
+                   Int_t jin  = fZlq[jvo-j-1];
+                   Int_t ivin = Int_t (fZq[jin + 2 ]);
+                   Int_t jvin = fZlq[fGclink->jvolum - ivin];
+                   Int_t ish  = Int_t (fZq[jvin + 2]);
+                   Int_t irot = Int_t(fZq[jin +4]);
+                   Float_t x    =  fZq[jin +5];
+                   Float_t y    =  fZq[jin +6];
+                   Float_t z    =  fZq[jin +7];
+                   Int_t ndata = Int_t(fZiq[jin-1]);
+                   Int_t npar;
+                   Float_t* par;
+//
+// Get shape parameters
+//
+// parp or normal positioning ?                    
+                   if (ndata == 8) {
+                       npar  = Int_t (fZq[jvin+5]);
+                       par = new Float_t[npar];
+                       if (npar>0) {
+                           for(Int_t jj=0; jj<npar; jj++) 
+                               par[jj] = fZq[jvin+7+jj];
+                       }
+                   } else {
+                       npar =  Int_t (fZq[jin+9]);
+                       par = new Float_t[npar];
+                       for(Int_t jj=0;jj<npar;jj++) 
+                           par[jj]=fZq[jin+10+jj];
+                   }
+//
+// Find out if this volume was already positioned and count copies 
+                   Int_t icvol=Child(ivol,j+1);
+                   icvol = TMath::Abs(icvol);
+                   Bool_t inList=kFALSE;
+                   AliG3Volume* copy0=0;
+                   
+                   for (Int_t k=0; k<nnew; k++) {
+                       if (icvol==
+                           Volume(newlevel-k-1)->GetIdVolume()) 
+                       {
+                           copy0  = Volume(newlevel-k-1);
+                           Volume(newlevel-k-1)->AddCopy();
+                           inList=kTRUE;
+                       }
+                   }
+//
+// New child
+//
+// Name
+                   strcpy(namec,((TGeant3*)gMC)->VolName(icvol));
+                   tmp = new char[4];
+                   strncpy(tmp,(char *) &namec, 4);
+                   volume = new AliG3Volume(namec);
+                   volume->SetPosition(x,y,z);
+                   volume->SetShape(ish);
+                   volume->SetParameters(npar, par);
+                   volume->SetRotMatrix(irot);
+                   if (ndata != 8) volume->SetPosp(kTRUE);
+                   volume->SetIdVolume(icvol);
+                   volume->SetIdCopy(1);
+// Link to mother
+                   volume->SetItem(item2);
+                   if (!inList) {
+                       (*fVolumes)[newlevel]=volume;
+                       newlevel++;
+                       nnew++;
+                   } else {
+                       copy0->AddCopy(volume);
+                   }
+               }
+           }
+       }
+// Move one level deaper
+       nst=nlevel;
+       nlevel=newlevel;
+    }
+}
+
+void AliG3toRoot::ReadMaterials()
+{
+//
+// Puts media and material names into ComboBox and 
+// collects material information
+// 
+    Float_t a, z, dens, radl, absl;
+    a=z=dens=radl=absl=-1;
+    Int_t npar=0;
+    Int_t imat, isvol, ifield;
+    Float_t fieldm, tmaxfd, stemax, deemax, epsil, stmin;
+    Float_t par[50];
+    Float_t ubuf[50];
+    Int_t nwbuf;
+    
+    char natmed[21], namate[21];
+//
+// Loop over media
+    Int_t nEntries=0;
+    
+    for(Int_t itm=1;itm<=fGcnum->ntmed;itm++) {
+       Int_t jtm  = fZlq[fGclink->jtmed-itm];
+       if (jtm > 0) {
+           nEntries++;
+// 
+// Get medium parameters
+           ((TGeant3*)(gMC))->
+               Gftmed(itm, natmed, imat, isvol, ifield, fieldm, 
+                      tmaxfd, stemax, deemax, epsil, stmin, ubuf, &nwbuf);
+           strncpy(natmed,(char*)&fZiq[jtm+1],20);
+           natmed[20]='\0';
+//
+// Create new medium object 
+           AliG3Medium * medium = 
+               new AliG3Medium(itm, imat, natmed, isvol, ifield, fieldm, 
+                                     tmaxfd, stemax, deemax, epsil, stmin);
+           (*fMedia)[nEntries-1]=medium;
+        { //Begin local scope for j
+          for (Int_t j=1; j<=22; j++) {
+            medium->SetPar(j,Cut(itm,j));
+          }
+        } //End local scope for j
+        { //Begin local scope for j
+          for (Int_t j=23; j<=26; j++) {
+            medium->SetPar(j,Cut(itm,j+3));
+          }
+        } //End local scope for j
+        { //Begin local scope for j
+          for (Int_t j=27; j<=29; j++) {
+            medium->SetPar(j,Cut(itm,j+4));
+          }
+        } //End local scope for j
+//
+// Associated material
+           imat =  Int_t (fZq[jtm+6]);
+           Int_t jma  =  Int_t (fZlq[fGclink->jmate-imat]);
+//
+// Get material parameters
+           ((TGeant3*)(gMC))->Gfmate (imat,namate,a,z,dens,radl,absl,par,npar);
+           strncpy(namate,(char *)&fZiq[jma+1],20);
+           namate[20]='\0';
+//
+// Create new material object
+           AliG3Material* material = new AliG3Material(namate, " ", a,z,dens,radl,absl);
+           material->SetId(imat);
+           
+           (*fMaterials)[nEntries-1] = material;
+           material->Dump();
+       }
+    }
+}
+
+void AliG3toRoot::ReadRotations()
+{
+// Read rotation matrices
+    Int_t nrot = 0;
+    Int_t irm, jrm;
+    char name[9];
+    if(fGclink->jrotm) nrot = Int_t(fZiq[fGclink->jrotm-2]);
+    if (nrot) {
+        fRotations = new TObjArray(nrot);
+        for(irm=1;irm<=nrot;irm++) {
+            jrm  = fZlq[fGclink->jrotm-irm];
+            sprintf(name, "R%d", irm);
+         //PH       (*fRotations)[irm-1] =
+           //PH                 new TRotMatrix(name, "Rotation", fZq[jrm+11], fZq[jrm+12], fZq[jrm+13], 
+           //PH                                fZq[jrm+14], fZq[jrm+15], fZq[jrm+16]);
+            fRotations->AddAt(
+                new TRotMatrix(name, "Rotation", fZq[jrm+11], fZq[jrm+12], fZq[jrm+13], 
+                               fZq[jrm+14], fZq[jrm+15], fZq[jrm+16]), irm-1);
+        }
+    }
+}
+
+Int_t AliG3toRoot::NChildren(Int_t idvol)
+{
+//
+// Return number of children for volume idvol
+    Int_t jvo = fZlq[fGclink->jvolum-idvol];
+    Int_t nin = Int_t(fZq[jvo+3]);
+    return nin;
+}
+
+Int_t AliG3toRoot::Child(Int_t idvol, Int_t idc)
+{
+//
+// Return GEANT id of child number idc of volume idvol
+    Int_t jvo = fZlq[fGclink->jvolum-idvol];
+    Int_t nin=idc;
+    Int_t jin = fZlq[jvo-nin];
+    Int_t numb =  Int_t (fZq[jin +3]);
+    if (numb > 1) {
+       return -Int_t(fZq[jin+2]);
+    } else {
+       return Int_t(fZq[jin+2]);
+    }
+}
+
+Int_t AliG3toRoot::Medium(Int_t idvol)
+{
+//
+// Return medium number for volume idvol.
+// If idvol is negative the volume results from a division.
+    Int_t imed;
+    if (idvol > 0) {
+       Int_t jvo = fZlq[fGclink->jvolum-idvol];
+       imed = Int_t(fZq[jvo+4]);
+    } else {
+       idvol=-idvol;
+       Int_t jdiv = fZlq[fGclink->jvolum-idvol];
+       Int_t ivin = Int_t ( fZq[jdiv+2]);
+       Int_t jvin = fZlq[fGclink->jvolum-ivin];
+       imed = Int_t (fZq[jvin+4]);
+    }
+    return imed;
+}
+
+Int_t AliG3toRoot::Material(Int_t idvol)
+{
+// Return material number for volume idvol.
+// If idvol is negative the volume results from a division.
+
+    Int_t imed=Medium(idvol);
+    Int_t jtm  = fZlq[fGclink->jtmed-imed];
+    return Int_t (fZq[jtm+6]);
+}
+
+
+Float_t AliG3toRoot::Cut(Int_t imed, Int_t icut)
+{
+// Return cuts icut for medium idmed 
+// 
+    Int_t jtm  = fZlq[fGclink->jtmed-imed];
+//
+//  Have the defaults been modified ??
+    Int_t jtmn = fZlq[jtm];
+    if (jtmn >0) {
+       jtm=jtmn;
+       
+    } else {
+       jtm=fGclink->jtmed;
+    }
+    
+    return Float_t (fZq[jtm+icut]);
+}
+
+TFolder* AliG3toRoot::AddVolume(TObject * obj, TFolder *parent, const char* name)
+{
+// Add item to the list tree
+    TFolder* newFolder = parent->AddFolder(name, "volume");
+    newFolder->Add(obj);
+    return newFolder;
+}
+
+AliG3Volume* AliG3toRoot::Volume(Int_t id)
+       
+{
+// Volume at id
+    return (AliG3Volume *) (fVolumes->UncheckedAt(id));
+}
+
+
+void AliG3toRoot::ConvertToRootShapes(TFolder *item, AliNode** node, Int_t nNodes)
+{
+// Convert the geometry represented by TFolders into root shapes
+//
+    AliG3Volume* volume;
+    TArrayF pos;
+    Int_t irot, imat;
+    Int_t npos = 0;
+    Bool_t top=kFALSE;
+    
+    char nameV[20];
+    char nameN[20];
+    
+    if (!item) {
+       item = fTopFolder;
+       top  = kTRUE;
+    }
+    if (nNodes == 0) nNodes = 1;
+    
+    TList* folders = (TList*) item->GetListOfFolders();
+    TIter next(folders);
+    npos = 0;
+    volume = ((AliG3Volume *) item->FindObject(item->GetName()));
+    Int_t ncopy = volume->NCopies();
+    AliNode** newnode = new AliNode*[(ncopy+1)*nNodes];
+
+    for (Int_t ino=0; ino<nNodes; ino++) {
+                   
+       pos    = volume->Position(0);
+       irot   = volume->RotMatrix();
+       imat   = volume->Material();
+       
+       sprintf(nameV,"v%s%d", volume->GetName(), npos);
+       sprintf(nameN,"%s%d" , volume->GetName(), npos);
+       
+       
+       imat   = volume->Material();
+       Int_t nmat = fMaterials->GetEntriesFast();
+       AliG3Material* mat=0;
+
+       for (Int_t mati=0; mati<nmat; mati++) {
+           mat = (AliG3Material*) 
+               (fMaterials->UncheckedAt(mati));
+           if ((mat->Id())==imat) break;
+       }
+           
+
+       volume->CreateTShape(nameV, mat);
+
+       if (!top) {
+           node[ino]->cd();
+           newnode[npos] = new AliNode(nameN," ",nameV, pos[0], pos[1], pos[2]);
+           newnode[npos]->SetDivision(volume->Ndiv(), volume->Axis(), 
+                                      volume->Step(), volume->StartC());
+           if (irot > 0) newnode[npos]->SetMatrix((TRotMatrix*) (*fRotations)[irot-1]);
+           npos++;
+               
+       } else {
+           new TMaterial("void","Vacuum",0,0,0);  //Everything is void
+           TBRIK *brik   = new TBRIK("D_alice","alice volume",
+                                     "void",2000,2000,3000);
+           brik->SetVisibility(0);
+           newnode[npos] = new AliNode("alice","alice","D_alice");
+           npos++;
+       }
+       
+       if (ncopy) {
+           for (Int_t icop = 0; icop < ncopy; icop++) {
+               AliG3Volume* copy = volume->Copy(icop);
+               
+               sprintf(nameN,"%s%d" , volume->GetName(), icop+1);
+               if (copy->Posp()) {
+                   sprintf(nameV,"v%s%d", volume->GetName(), icop+1);
+                   volume->CreateTShape(nameV, mat);
+               }
+               node[ino]->cd();
+               pos    = copy->Position(0);
+               irot   = copy->RotMatrix();
+               newnode[npos] = new AliNode(nameN," ",nameV, pos[0], pos[1], pos[2]);
+               newnode[npos]->SetDivision(volume->Ndiv(), volume->Axis(), 
+                                          volume->Step(), volume->StartC());
+               if (irot >0) newnode[npos]->SetMatrix((TRotMatrix*) (*fRotations)[irot-1]);
+               npos++;
+           } // copy loop
+       } // copies exist
+    } // node loop
+    TObject* obj;
+    
+    while ((obj = next()))
+    {
+       if ((AliG3Volume*) obj == volume) continue;
+       item = (TFolder*) obj;
+       
+       ConvertToRootShapes(item, newnode, npos);
+    }
+
+//  Expand divisions of demand
+    if (fExpand) ExpandDivisions();
+}
+
+void AliG3toRoot::ExpandDivisions(AliNode* node)
+{
+// Expand volume divisions
+//
+
+    Bool_t top = kFALSE;
+    
+    if (!node) {
+       node = (AliNode*) fGeometry->GetNode("alice");
+       top = kTRUE;
+    }
+    if (!top && node->Ndiv() > 0 && node->Axis()>0) {
+       
+       node->ExpandDivisions();
+       node->GetParent()->RecursiveRemove(node);
+       ExpandDivisions();
+
+    } else {
+       TList* sons = node->GetListOfNodes();
+       TIter next(sons);
+       AliNode* son=0;
+
+       while((son = (AliNode*)next())) {
+           ExpandDivisions(son);
+       }  
+    }
+} 
+
+
+
+
+
+
+
diff --git a/AliGeant3/AliG3toRoot.h b/AliGeant3/AliG3toRoot.h
new file mode 100644 (file)
index 0000000..9311579
--- /dev/null
@@ -0,0 +1,78 @@
+#ifndef ALIG3toRoot_H
+#define ALIG3toRoot_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+
+#include <TObject.h>
+#include <TGeant3.h>
+
+class TClonesArray;
+class TObjArray;
+class TGPicture;
+class TFolder;
+class TGeometry;
+
+class AliG3Volume;
+class AliNode;
+
+
+class AliG3toRoot : public TObject 
+{
+ public:
+    AliG3toRoot();
+    virtual ~AliG3toRoot(){}
+    virtual void G3toRoot();
+    void ConvertToRootShapes(TFolder *item=0, AliNode** node=0,
+                            Int_t nNodes=1);
+    // Setters
+    virtual void SetExpandDivisions(Int_t flag = 1)
+       {fExpand = flag;}
+    // Getters
+    TFolder*      GetTopFolder() {return fTopFolder;}
+    TClonesArray* GetMaterials() {return fMaterials;}    
+    TClonesArray* GetMedia()     {return fMedia;}
+ private:
+    void ExpandDivisions(AliNode* node=0);
+    void ReadGeometryTree();
+    void ReadMaterials();    
+    void ReadRotations();
+    TFolder* AddVolume(TObject * obj, TFolder *parent, const char* name);
+    virtual AliG3Volume* Volume(Int_t id);
+    Int_t Medium(Int_t idvol);
+    Int_t Material(Int_t idvol);
+    Float_t Cut(Int_t imed, Int_t icut);
+    // Return number of children for volume idvol
+    Int_t NChildren(Int_t idvol);
+    // Return child number idc of volume idvol
+    Int_t Child(Int_t idvol, Int_t idc);
+    AliG3toRoot &operator=(const AliG3toRoot &) {return *this;}
+ private:
+    TClonesArray   *fVolumes;    //! array of volumes  
+    TClonesArray   *fMaterials;  //! array of materials
+    TClonesArray   *fMedia;      //! array of materials
+    TObjArray      *fRotations;  //! Rotation Matrices
+    // Zebra bank related information  
+    Int_t*     fZlq;              //! pointer to Zebra bank lq
+    Float_t*   fZq;               //! pointer to Zebra bank q
+    Int_t*     fZiq;              //! pointer to Zebra bank iq
+    Gclink_t*  fGclink;           //! pointer to Geant common block 
+    Gcnum_t*   fGcnum;            //! pointer to Geant common block
+    // List Tree
+    TFolder*   fTopFolder;        //! Folder structure containing volumes
+    TGeometry* fGeometry;         //  Pointer to geometry
+    Int_t      fExpand;           //  Flag for division expansion
+    
+    ClassDef(AliG3toRoot,1) // Material Object for GUI 
+};
+
+#endif
+
+
+
+
+
+
+
+
diff --git a/AliGeant3/AliGUISliders.cxx b/AliGeant3/AliGUISliders.cxx
new file mode 100644 (file)
index 0000000..a780be4
--- /dev/null
@@ -0,0 +1,175 @@
+/* *************************************************************************
+ * 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.2  2001/07/09 11:48:47  morsch
+Use AliG3Volume, AliG3Medium, AliG3Material
+
+Revision 1.1  2000/07/13 16:19:10  fca
+Mainly coding conventions + some small bug fixes
+
+Revision 1.8  2000/07/12 08:56:32  fca
+Coding convention correction and warning removal
+
+Revision 1.7  2000/06/28 21:27:45  morsch
+Most coding rule violations corrected.
+Still to do: Split the file (on file per class) ? Avoid the global variables.
+Copy constructors and assignment operators (dummy ?)
+
+Revision 1.6  2000/04/14 11:07:46  morsch
+Correct volume to medium assignment in case several media are asigned to the
+same material.
+
+Revision 1.5  2000/03/20 15:11:03  fca
+Mods to make the code compile on HP
+
+Revision 1.4  2000/01/18 16:12:08  morsch
+Bug in calculation of number of volume divisions and number of positionings corrected
+Browser for Material and Media properties added
+
+Revision 1.3  1999/11/14 14:31:14  fca
+Correct small error and remove compilation warnings on HP
+
+Revision 1.2  1999/11/10 16:53:35  fca
+The new geometry viewer from A.Morsch
+
+*/
+
+#include <stdlib.h>
+
+#include "AliGUISliders.h"
+#include "AliG3Volume.h"
+
+static Text_t* kLabelText[7]  = 
+{"Theta  ", "Phi    ", "Psi    ", "U      ", "V      ", "UScale", "VScale"};
+static Int_t   IRangeMin[7]  = {    0,     0,     0,    0,    0,   0,   0};
+static Int_t   IRangeMax[7]  = {36000, 36000, 36000, 2000, 2000, 10, 10};
+static Int_t   DefaultPos[7] = { 3000,  4000,     0, 1000, 1000,   1,   1};
+
+AliGUISliders::AliGUISliders(const TGWindow *p, const TGWindow *,
+                         UInt_t w, UInt_t h) :
+    TGCompositeFrame(p, w, h,kVerticalFrame)
+{
+// Constructor
+    ChangeOptions((GetOptions() & ~kHorizontalFrame) | kVerticalFrame);
+   //--- layout for buttons: top align, equally expand horizontally
+    fBly = new TGLayoutHints(kLHintsTop | kLHintsExpandY, 5, 5, 5, 5);
+
+   //--- layout for the frame: place at bottom, right aligned
+    fBfly1 = new TGLayoutHints(kLHintsLeft | kLHintsExpandX );
+//
+// Frames
+
+   for (Int_t i=0; i<7; i++) {
+       Int_t idT=i+1;
+       Int_t idS=i+8;       
+       fHframe[i] = new TGHorizontalFrame(this, 400, 100, kFixedWidth);
+       fTbh[i] = new TGTextBuffer(10);
+       fTeh[i] = new TGTextEntry(fHframe[i], fTbh[i],idT);
+       char buf[10];
+       sprintf(buf, "%6.2f", Float_t(DefaultPos[i])/100);
+       fTbh[i]->AddText(0, buf);
+       fTeh[i]->Associate(this);
+       
+       fHslider[i] = new TGHSlider(fHframe[i], 400, kSlider1 | kScaleBoth, idS);
+       fHslider[i]->Associate(this);
+       fHslider[i]->SetRange(IRangeMin[i], IRangeMax[i]);
+       fHslider[i]->SetPosition(DefaultPos[i]);
+
+       fLabel[i] = new TGLabel(fHframe[i], kLabelText[i]);
+       
+       
+       fHframe[i]->AddFrame(fLabel[i], fBfly1);
+       fHframe[i]->AddFrame(fTeh[i], fBfly1);
+       fHframe[i]->AddFrame(fHslider[i], fBfly1);
+       AddFrame(fHframe[i], fBly);
+   }
+}
+
+AliGUISliders::~AliGUISliders()
+{
+// Destructor
+    delete fBfly1; delete fBly;
+   // Delete dialog.
+    for (Int_t i=1; i<7; i++) {
+       delete fHframe[i];
+       delete fHslider[i];
+       delete fTeh[i];
+       delete fTbh[i]; 
+    }
+}
+
+void AliGUISliders::Update()
+{
+// Update sliders
+    char buf[10];
+    
+    for (Int_t i=0; i<7; i++) {
+       Float_t param = gCurrentVolume->GetParam(i);
+//
+       fHslider[i]->SetPosition(Int_t(param*100.));
+       gClient->NeedRedraw(fHslider[i]);
+//
+       sprintf(buf, "%6.2f", param);
+       fTbh[i]->Clear();
+       fTbh[i]->AddText(0, buf);
+       gClient->NeedRedraw(fTeh[i]);
+//
+    }
+
+    
+}
+
+void AliGUISliders::CloseWindow()
+{
+   // Called when window is closed via the window manager.
+
+   delete this;
+}
+
+Bool_t AliGUISliders::ProcessMessage(Long_t msg, Long_t parm1, Long_t parm2)
+{
+   // Process slider messages.
+
+   char buf[10];
+
+   switch (GET_MSG(msg)) {
+   case kC_TEXTENTRY:
+       switch (GET_SUBMSG(msg)) {
+       case kTE_TEXTCHANGED:
+          Int_t idT=Int_t(parm1)-1;
+          fHslider[idT]->SetPosition((Int_t)atof(fTbh[idT]->GetString())*100);
+          gClient->NeedRedraw(fHslider[idT]);
+          gCurrentVolume->SetParam(idT,atof(fTbh[idT]->GetString()));
+          gCurrentVolume->Draw();
+       }
+       break;
+   case kC_HSLIDER:
+       switch (GET_SUBMSG(msg)) {
+       case kSL_POS:
+          sprintf(buf, "%6.2f", Float_t(parm2)/100);
+          Int_t idS=Int_t(parm1)-8;
+          fTbh[idS]->Clear();
+          fTbh[idS]->AddText(0, buf);
+          gClient->NeedRedraw(fTeh[idS]);
+          gCurrentVolume->SetParam(idS, Float_t(parm2)/100.);
+          gCurrentVolume->Draw();
+       }
+       break;
+   }
+   return kTRUE;
+}
+
diff --git a/AliGeant3/AliGUISliders.h b/AliGeant3/AliGUISliders.h
new file mode 100644 (file)
index 0000000..5c55fb5
--- /dev/null
@@ -0,0 +1,43 @@
+#ifndef ALIGUISLIDERS_H
+#define ALIGUISLIDERS_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+
+#include "TGFrame.h"
+#include "TGSlider.h"
+#include "TGTextEntry.h"
+#include "TGTextBuffer.h"
+#include "TGLabel.h"
+
+class AliG3Volume;
+
+class AliGUISliders : public  TGCompositeFrame {
+public:
+   AliGUISliders(const TGWindow *p, const TGWindow *main, UInt_t w, UInt_t h);
+   virtual ~AliGUISliders();
+   virtual void CloseWindow();
+   virtual Bool_t ProcessMessage(Long_t msg, Long_t parm1, Long_t parm2);
+   virtual void Update();
+private:
+//
+    TGHorizontalFrame *fHframe[8];       // 8 Horizontal frames for sliders
+    TGLayoutHints     *fBly, *fBfly1;    // Lay-out hints
+    TGHSlider         *fHslider[8];      // 8 Sliders
+    TGTextEntry       *fTeh[8];          // Text entries for slider position
+    TGTextBuffer      *fTbh[8];          // Text buffer  
+    TGLabel           *fLabel[8];        // Slider labels
+    Text_t            fLabelText[8];     // Label text 
+
+  AliGUISliders(const AliGUISliders &gs) :
+    TGCompositeFrame((const TGCompositeFrame&) gs) {}
+  AliGUISliders & operator=(const AliGUISliders &) {return *this;}
+  
+      
+   //   ClassDef(AliGUISliders,1)  // Window containing sliders 
+};
+
+R__EXTERN AliG3Volume  *gCurrentVolume;
+
+#endif
diff --git a/AliGeant3/AliGeant3.cxx.orig b/AliGeant3/AliGeant3.cxx.orig
new file mode 100644 (file)
index 0000000..a709319
--- /dev/null
@@ -0,0 +1,893 @@
+/**************************************************************************
+ * 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.21  2002/03/19 09:36:17  morsch
+Unnecessary includes removes, one included. (Jacek M. Holeczek)
+
+Revision 1.20  2001/10/03 10:19:13  morsch
+gudcay(): previous problem fixed by correct checking of indices.
+
+Revision 1.19  2001/10/03 08:39:03  morsch
+Bug in user decay routine leading to segmentation violation corrected.
+
+Revision 1.18  2001/07/19 09:10:23  morsch
+In decays with AliDecayer put long-lived particles undecayed on the stack.
+
+Revision 1.17  2001/06/15 09:31:23  morsch
+In gudcay: write only first generation decay products to stack to respect the possibility of secondary, tertiary, ... vertices during tracking.
+
+Revision 1.16  2001/05/16 14:57:23  alibrary
+New files for folders and Stack
+
+Revision 1.15  2001/03/20 06:28:49  alibrary
+New detector loop split in 2
+
+Revision 1.14  2000/12/20 08:39:39  fca
+Support for Cerenkov and process list in Virtual MC
+
+Revision 1.13  2000/11/30 07:12:54  alibrary
+Introducing new Rndm and QA classes
+
+Revision 1.12  2000/11/06 11:35:46  morsch
+Call BuildGeometry() after Init() to be able to share common detector parameters.
+
+Revision 1.11  2000/10/04 16:30:22  fca
+Add include for exit()
+
+Revision 1.10  2000/10/02 21:28:16  fca
+Removal of useless dependecies via forward declarations
+
+Revision 1.9  2000/09/12 14:36:17  morsch
+In gudcay(): call ForceDecay() before Decay()
+
+Revision 1.8  2000/09/06 14:56:34  morsch
+gudcay() method implemented.
+Decays are performed using  the AliDecayer interface. The pointer to the instance of AliDecayer
+is obtained from geant3 (will be gMC once it has been implemented for Geant4).
+
+Revision 1.7  2000/07/13 16:19:10  fca
+Mainly coding conventions + some small bug fixes
+
+Revision 1.6  2000/07/11 18:24:59  fca
+Coding convention corrections + few minor bug fixes
+
+Revision 1.5  2000/05/20 14:49:48  fca
+Call gdebug at the end of gustep
+
+Revision 1.4  2000/04/26 10:17:32  fca
+Changes in Lego for G4 compatibility
+
+Revision 1.3  2000/04/07 11:12:35  fca
+G4 compatibility changes
+
+Revision 1.2  2000/02/29 19:11:17  fca
+Move gucode into AliGeant3.cxx
+
+Revision 1.1  2000/02/23 16:25:25  fca
+AliVMC and AliGeant3 classes introduced
+ReadEuclid moved from AliRun to AliModule
+
+*/
+
+#include <stdlib.h>
+
+#include <TParticle.h>
+#include <TStopwatch.h>
+#include <TClonesArray.h> 
+
+#include "AliDecayer.h"
+#include "AliGeant3.h"
+#include "AliRun.h"
+#include "TGeant3.h"
+#include "AliCallf77.h" 
+#include "AliModule.h"
+#include "AliMagF.h"
+#include "AliGenerator.h"
+
+#ifndef WIN32
+
+# define rxgtrak rxgtrak_
+# define rxouth  rxouth_
+# define rxinh   rxinh_
+#else
+
+# define rxgtrak RXGTRAK 
+# define rxouth  RXOUTH
+# define rxinh   RXINH
+#endif
+
+ClassImp(AliGeant3)
+
+AliGeant3::AliGeant3(const char *title) : 
+  TGeant3(title) {}
+
+//____________________________________________________________________________
+void AliGeant3::FinishGeometry()
+{
+  //
+  // Finalise geometry construction
+  //
+  TGeant3::FinishGeometry();
+  //Create the color table
+  SetColors();
+}
+
+//____________________________________________________________________________
+void AliGeant3::Init()
+{
+    //
+    //=================Create Materials and geometry
+    //
+    TStopwatch stw;
+    TObjArray *modules = gAlice->Modules();
+    TIter next(modules);
+    AliModule *detector;
+    printf("Geometry creation:\n");
+    while((detector = (AliModule*)next())) {
+      stw.Start();
+      // Initialise detector materials and geometry
+      detector->CreateMaterials();
+      detector->CreateGeometry();
+      printf("%10s R:%.2fs C:%.2fs\n",
+            detector->GetName(),stw.RealTime(),stw.CpuTime());
+    }
+    //Terminate building of geometry
+    FinishGeometry();
+    
+    printf("Initialisation:\n");
+    next.Reset();
+    while((detector = (AliModule*)next())) {
+      stw.Start();
+      // Initialise detector and display geometry
+      detector->Init();
+      detector->BuildGeometry();
+      printf("%10s R:%.2fs C:%.2fs\n",
+            detector->GetName(),stw.RealTime(),stw.CpuTime());
+    }
+
+}
+
+//____________________________________________________________________________
+void AliGeant3::ProcessRun(Int_t nevent)
+{
+  //
+  // Process the run
+  //
+  Int_t todo = TMath::Abs(nevent);
+  for (Int_t i=0; i<todo; i++) {
+  // Process one run (one run = one event)
+     gAlice->BeginEvent();
+     ProcessEvent();
+     gAlice->FinishEvent();
+  }
+}
+
+//_____________________________________________________________________________
+void AliGeant3::ProcessEvent()
+{
+  //
+  // Process one event
+  //
+  Gtrigi();
+  Gtrigc();
+  Gtrig();
+}
+
+//_____________________________________________________________________________
+void AliGeant3::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);
+  }
+}
+
+//_____________________________________________________________________________
+//
+//                 Interfaces to Fortran
+//
+//_____________________________________________________________________________
+
+extern "C" void type_of_call  rxgtrak (Int_t &mtrack, Int_t &ipart, Float_t *pmom, 
+                                      Float_t &e, Float_t *vpos, Float_t *polar,
+                                      Float_t &tof)
+{
+  //
+  //     Fetches next track from the ROOT stack for transport. Called by the
+  //     modified version of GTREVE.
+  //
+  //              Track number in the ROOT stack. If MTRACK=0 no
+  //      mtrack  more tracks are left in the stack to be
+  //              transported.
+  //      ipart   Particle code in the GEANT conventions.
+  //      pmom[3] Particle momentum in GeV/c
+  //      e       Particle energy in GeV
+  //      vpos[3] Particle position
+  //      tof     Particle time of flight in seconds
+  //
+  Int_t pdg;
+  gAlice->GetNextTrack(mtrack, pdg, pmom, e, vpos, polar, tof);
+  ipart = gMC->IdFromPDG(pdg);
+  mtrack++;
+}
+
+//_____________________________________________________________________________
+extern "C" void type_of_call  rxouth ()
+{
+  //
+  // Called by Gtreve at the end of each primary track
+  //
+  gAlice->FinishPrimary();
+}
+
+//_____________________________________________________________________________
+extern "C" void type_of_call  rxinh ()
+{
+  //
+  // Called by Gtreve at the beginning of each primary track
+  //
+  gAlice->BeginPrimary();
+}
+
+#ifndef WIN32
+#  define gudigi gudigi_
+#  define guhadr guhadr_
+#  define guout  guout_
+#  define guphad guphad_
+#  define gudcay gudcay_
+#  define guiget guiget_
+#  define guinme guinme_
+#  define guinti guinti_
+#  define gunear gunear_
+#  define guskip guskip_
+#  define guview guview_
+#  define gupara gupara_
+#  define gudtim gudtim_
+#  define guplsh guplsh_
+#  define gutrev gutrev_
+#  define gutrak gutrak_
+#  define guswim guswim_
+#  define gufld  gufld_
+#  define gustep gustep_
+#  define gukine gukine_
+#  define uglast uglast_
+
+#  define gheish gheish_
+#  define flufin flufin_
+#  define gfmfin gfmfin_
+#  define gpghei gpghei_
+#  define fldist fldist_
+#  define gfmdis gfmdis_
+#  define ghelx3 ghelx3_
+#  define ghelix ghelix_
+#  define grkuta grkuta_
+#  define gtrack gtrack_
+#  define gtreveroot gtreveroot_
+#  define glast  glast_
+
+#else
+#  define gudigi GUDIGI
+#  define guhadr GUHADR
+#  define guout  GUOUT
+#  define guphad GUPHAD
+#  define gudcay GUDCAY
+#  define guiget GUIGET
+#  define guinme GUINME
+#  define guinti GUINTI
+#  define gunear GUNEAR
+#  define guskip GUSKIP
+#  define guview GUVIEW
+#  define gupara GUPARA
+#  define gudtim GUDTIM
+#  define guplsh GUPLSH
+#  define gutrev GUTREV
+#  define gutrak GUTRAK
+#  define guswim GUSWIM
+#  define gufld  GUFLD
+#  define gustep GUSTEP
+#  define gukine GUKINE
+#  define uglast UGLAST
+
+#  define gheish GHEISH
+#  define flufin FLUFIN
+#  define gfmfin GFMFIN
+#  define gpghei GPGHEI
+#  define fldist FLDIST
+#  define gfmdis GFMDIS
+#  define ghelx3 GHELX3
+#  define ghelix GHELIX
+#  define grkuta GRKUTA
+#  define gtrack GTRACK
+#  define gtreveroot GTREVEROOT
+#  define glast  GLAST
+
+#endif
+
+extern "C" type_of_call void gheish();
+extern "C" type_of_call void flufin();
+extern "C" type_of_call void gfmfin();
+extern "C" type_of_call void gpghei();
+extern "C" type_of_call void fldist();
+extern "C" type_of_call void gfmdis();
+extern "C" type_of_call void ghelx3(Float_t&, Float_t&, Float_t*, Float_t*);
+extern "C" type_of_call void ghelix(Float_t&, Float_t&, Float_t*, Float_t*);
+extern "C" type_of_call void grkuta(Float_t&, Float_t&, Float_t*, Float_t*);
+extern "C" type_of_call void gtrack();
+extern "C" type_of_call void gtreveroot();
+extern "C" type_of_call void glast();
+
+extern "C" type_of_call {
+
+//______________________________________________________________________
+void gudigi() 
+{
+//
+//    ******************************************************************
+//    *                                                                *
+//    *       User routine to digitize one event                       *
+//    *                                                                *
+//    *    ==>Called by : GTRIG                                        *
+//    *                                                                *
+//    ******************************************************************
+
+}
+
+
+//______________________________________________________________________
+void guhadr()
+{
+//
+//    ******************************************************************
+//    *                                                                *
+//    *       User routine to generate one hadronic interaction        *
+//    *                                                                *
+//    *    ==>Called by : GTHADR,GTNEUT                                *
+//    *                                                                *
+//    ******************************************************************
+//
+//
+//    ------------------------------------------------------------------
+//
+      TGeant3* geant3 = (TGeant3*) gMC;
+      Int_t ihadr=geant3->Gcphys()->ihadr;
+      if (ihadr<4)       gheish();
+      else if (ihadr==4) flufin();
+      else               gfmfin();
+}
+
+//______________________________________________________________________
+void guout()
+{
+//
+//    ******************************************************************
+//    *                                                                *
+//    *       User routine called at the end of each event             *
+//    *                                                                *
+//    *    ==>Called by : GTRIG                                        *
+//    *                                                                *
+//    ******************************************************************
+//
+//
+//    ------------------------------------------------------------------
+//
+}
+
+//______________________________________________________________________
+void guphad()
+{
+//
+//    ******************************************************************
+//    *                                                                *
+//    *       User routine to compute Hadron. inter. probabilities     *
+//    *                                                                *
+//    *    ==>Called by : GTHADR,GTNEUT                                *
+//    *                                                                *
+//    ******************************************************************
+//
+//
+//    ------------------------------------------------------------------
+//
+      TGeant3* geant3 = (TGeant3*) gMC;
+      Int_t ihadr=geant3->Gcphys()->ihadr;
+      if (ihadr<4)       gpghei();
+      else if (ihadr==4) fldist();
+      else               gfmdis();
+}
+
+//______________________________________________________________________
+void gudcay()
+{
+//
+//    ******************************************************************
+//    *                                                                *
+//    *       User routine to decay particles                          *
+//    *                                                                *
+//    *    ==>Called by : GDECAY                                       *
+//    *                                                                *
+//    ******************************************************************
+//
+//
+//    ------------------------------------------------------------------
+//
+    
+    TGeant3* geant3=(TGeant3*) gMC;
+    // set decay table
+    gMC->Decayer()->ForceDecay();
+
+// Initialize 4-momentum vector    
+    Int_t ipart = geant3->Gckine()->ipart;
+    TLorentzVector p;
+    
+    p[0]=geant3->Gctrak()->vect[3];
+    p[1]=geant3->Gctrak()->vect[4];
+    p[2]=geant3->Gctrak()->vect[5];
+    p[3]=geant3->Gctrak()->vect[6];    
+    
+// Convert from geant to lund particle code
+    Int_t iplund=gMC->PDGFromId(ipart);
+// Particle list
+    static TClonesArray *particles;
+    if(!particles) particles=new TClonesArray("TParticle",1000);
+// Decay
+    gMC->Decayer()->Decay(iplund, &p);
+    
+// Fetch Particles
+    Int_t np = geant3->Decayer()->ImportParticles(particles);
+    if (np <=1) return;
+
+    TParticle *  iparticle = (TParticle *) particles->At(0);
+    Int_t ipF = 0, ipL = 0 ;
+    Int_t i,j;
+
+// Array to flag deselected particles
+    Int_t*  pFlag = new Int_t[np];
+    for (i=0; i<np; i++) pFlag[i]=0;
+// Particle loop
+    for (i=1; i < np; i++) 
+    {
+       iparticle = (TParticle *) particles->At(i);
+       ipF = iparticle->GetFirstDaughter();
+       ipL = iparticle->GetLastDaughter();     
+       Int_t kf = iparticle->GetPdgCode();
+       Int_t ks = iparticle->GetStatusCode();
+//
+// Deselect daughters of deselected particles
+// and jump skip the current particle
+       if (pFlag[i] == 1) {
+           if (ipF > 0) for (j=ipF-1; j<ipL; j++) pFlag[j]=1;
+           continue;
+       } // deselected ??
+// Particles with long life-time are put on the stack for further tracking
+// Decay products are deselected
+//     
+       if (ks != 1) { 
+           Double_t lifeTime = gMC->Decayer()->GetLifetime(kf);
+           if (lifeTime > (Double_t) 1.e-15) {
+               if (ipF > 0) for (j=ipF-1; j<ipL; j++) pFlag[j]=1;
+           } else{
+               continue;
+           }
+       } // ks==1 ?
+// Skip neutrinos
+       if (kf==12 || kf ==-12) continue;
+       if (kf==14 || kf ==-14) continue;
+       if (kf==16 || kf ==-16) continue;
+       
+       Int_t index=geant3->Gcking()->ngkine;
+// Put particle on geant stack
+// momentum vector
+       
+       (geant3->Gcking()->gkin[index][0]) = iparticle->Px();
+       (geant3->Gcking()->gkin[index][1]) = iparticle->Py();
+       (geant3->Gcking()->gkin[index][2]) = iparticle->Pz();
+       (geant3->Gcking()->gkin[index][3]) = iparticle->Energy();
+       Int_t ilu = gMC->IdFromPDG(kf);
+
+// particle type       
+       (geant3->Gcking()->gkin[index][4]) = Float_t(ilu);
+// position
+       (geant3->Gckin3()->gpos[index][0]) = geant3->Gctrak()->vect[0];
+       (geant3->Gckin3()->gpos[index][1]) = geant3->Gctrak()->vect[1];
+       (geant3->Gckin3()->gpos[index][2]) = geant3->Gctrak()->vect[2];
+// time of flight offset (mm)
+       (geant3->Gcking()->tofd[index])    = 0.;
+// increase stack counter
+       (geant3->Gcking()->ngkine)=index+1;
+    }
+    delete[] pFlag;
+}
+
+//______________________________________________________________________
+void guiget(Int_t&, Int_t&, Int_t&)
+{
+//
+//    ******************************************************************
+//    *                                                                *
+//    *       User routine for interactive control of GEANT            *
+//    *                                                                *
+//    *    ==>Called by : <GXINT>, GINCOM                              *
+//    *                                                                *
+//    ******************************************************************
+//
+//
+//    ------------------------------------------------------------------
+//
+}
+
+//______________________________________________________________________
+void guinme(Float_t*, Int_t&, Float_t*, Int_t& IYES)
+{
+//
+//    **********************************************
+//    *                                            *
+//    *    USER ROUTINE TO PROVIDE GINME FUNCTION  *
+//    *    FOR ALL USER SHAPES IDENTIFIED BY THE   *
+//    *    SHAPE NUMBER SH. POINT IS GIVEN IN X    *
+//    *    THE PARAMETERS ARE GIVEN IN P. IYES IS  *
+//    *    RETURNED 1 IF POINT IS IN, 0 IF POINT   *
+//    *    IS OUT AND LESS THAN ZERO IF SHAPE      *
+//    *    NUMBER IS NOT SUPPORTED.                *
+//    *                                            *
+//    *    ==>Called by : GINME                    *
+//    *                                            *
+//    **********************************************
+//
+      IYES=-1;
+}
+
+//______________________________________________________________________
+void guinti()
+{
+//
+//    ******************************************************************
+//    *                                                                *
+//    *       User routine for interactive version                     *
+//    *                                                                *
+//    *    ==>Called by : <GXINT>,  GINTRI                             *
+//    *                                                                *
+//    ******************************************************************
+//
+//
+//    ------------------------------------------------------------------
+//
+}
+
+//______________________________________________________________________
+void gunear(Int_t&, Int_t&, Float_t*, Int_t&)
+{
+//
+//    ******************************************************************
+//    *                                                                *
+//    *    User search                                                 *
+//    *       ISEARC to identify the given volume                      *
+//    *       ICALL  to identify the calling routine                   *
+//    *              1 GMEDIA like                                     *
+//    *              2 GNEXT like                                      *
+//    *       X      coordinates (+direction for ICALL=2)              *
+//    *       JNEAR  address of default list of neighbours             *
+//    *              (list to be overwriten by user)                   *
+//    *                                                                *
+//    *    Called by : GFTRAC, GINVOL, GTMEDI, GTNEXT, GNEXT, GMEDIA   *
+//    *                                                                *
+//    ******************************************************************
+//
+//
+//    ------------------------------------------------------------------
+//
+}
+
+//______________________________________________________________________
+void guskip(Int_t& ISKIP)
+{
+//
+//    ******************************************************************
+//    *                                                                *
+//    *   User routine to skip unwanted tracks                         *
+//    *                                                                *
+//    *   Called by : GSSTAK                                           *
+//    *   Author    : F.Bruyant                                        *
+//    *                                                                *
+//    ******************************************************************
+//
+//
+//    ------------------------------------------------------------------
+//
+      ISKIP = 0;
+}
+
+//______________________________________________________________________
+void guswim(Float_t& CHARGE, Float_t& STEP, Float_t* VECT, Float_t* VOUT)
+{
+//
+//    ******************************************************************
+//    *                                                                *
+//    *       User routine to control tracking of one track            *
+//    *       in a magnetic field                                      *
+//    *                                                                *
+//    *    ==>Called by : GTELEC,GTHADR,GTMUON                         *
+//    *                                                                *
+//    ******************************************************************
+//
+//
+//    ------------------------------------------------------------------
+//
+  TGeant3* geant3 = (TGeant3*) gMC;
+  Int_t ifield=geant3->Gctmed()->ifield;
+  Float_t fieldm=geant3->Gctmed()->fieldm;
+
+  if (ifield==3) {
+    Float_t fldcharge = fieldm*CHARGE;
+    ghelx3(fldcharge,STEP,VECT,VOUT);
+  }
+  else if (ifield==2) ghelix(CHARGE,STEP,VECT,VOUT);
+  else                grkuta(CHARGE,STEP,VECT,VOUT);
+}
+
+//______________________________________________________________________
+void guview(Int_t&, Int_t&, DEFCHARD, Int_t& DEFCHARL)
+{
+//
+//    ******************************************************************
+//    *                                                                *
+//    *       User routine for interactive version                     *
+//    *                                                                *
+//    *    ==>Called by : <GXINT>, GINC1                               *
+//    *                                                                *
+//    ******************************************************************
+//
+//
+//    ------------------------------------------------------------------
+//
+}
+
+//______________________________________________________________________
+void gupara()
+{
+//
+//    ******************************************************************
+//    *                                                                *
+//    *       User routine called every time a particle falls below    *
+//    *       parametrization threshold. This routine should create    *
+//    *       the parametrization stack, and, when this is full,       *
+//    *       parametrize the shower and track the geantinos.          *
+//    *                                                                *
+//    *    ==>Called by : GTRACK                                       *
+//    *                                                                *
+//    ******************************************************************
+//
+//
+//    ------------------------------------------------------------------
+//
+}
+
+//______________________________________________________________________
+Float_t gudtim(Float_t&, Float_t&, Int_t&, Int_t&)
+{
+//
+//    ******************************************************************
+//    *                                                                *
+//    *       User function called by GCDRIF to return drift time      *
+//    *                                                                *
+//    *    ==>Called by : GCDRIF                                       *
+//    *                                                                *
+//    ******************************************************************
+//
+//
+//    ------------------------------------------------------------------
+//
+      return 0;
+}
+
+
+//______________________________________________________________________
+Float_t guplsh(Int_t&, Int_t&)
+{
+//
+//    ******************************************************************
+//    *                                                                *
+//    *                                                                *
+//    *    ==>Called by : GLISUR                                       *
+//    *                                                                *
+//    ******************************************************************
+//
+//
+//    ------------------------------------------------------------------
+//
+//
+//*** By default this defines perfect smoothness
+      return 1;
+}
+
+//______________________________________________________________________
+void gutrak()
+{
+//
+//    ******************************************************************
+//    *                                                                *
+//    *       User routine to control tracking of one track            *
+//    *                                                                *
+//    *    ==>Called by : GTREVE                                       *
+//    *                                                                *
+//    ******************************************************************
+//
+//
+//    ------------------------------------------------------------------
+//
+     gAlice->PreTrack();
+
+     gtrack();
+
+     gAlice->PostTrack();
+}
+
+//______________________________________________________________________
+void gutrev()
+{
+//
+//    ******************************************************************
+//    *                                                                *
+//    *       User routine to control tracking of one event            *
+//    *                                                                *
+//    *    ==>Called by : GTRIG                                        *
+//    *                                                                *
+//    ******************************************************************
+//
+//
+//    ------------------------------------------------------------------
+//
+  gtreveroot();
+}
+
+
+//______________________________________________________________________
+void gufld(Float_t *x, Float_t *b)
+{
+      if(gAlice->Field()) {
+         gAlice->Field()->Field(x,b);
+      } else {
+         printf("No mag field defined!\n");
+         b[0]=b[1]=b[2]=0;
+      }
+}
+
+//______________________________________________________________________
+void gustep()
+{
+//
+//    ******************************************************************
+//    *                                                                *
+//    *       User routine called at the end of each tracking step     *
+//    *       INWVOL is different from 0 when the track has reached    *
+//    *              a volume boundary                                 *
+//    *       ISTOP is different from 0 if the track has stopped       *
+//    *                                                                *
+//    *    ==>Called by : GTRACK                                       *
+//    *                                                                *
+//    ******************************************************************
+//
+
+
+  TLorentzVector x;
+  Float_t r;
+  Int_t ipp, jk, id, nt;
+  Float_t polar[3]={0,0,0};
+  Float_t mom[3];
+  AliMCProcess pProc;
+
+  
+  TGeant3* geant3 = (TGeant3*) gMC;
+  //     Stop particle if outside user defined tracking region 
+  gMC->TrackPosition(x);
+  r=TMath::Sqrt(x[0]*x[0]+x[1]*x[1]);
+  if (r > gAlice->TrackingRmax() || TMath::Abs(x[2]) > gAlice->TrackingZmax()) {
+       gMC->StopTrack();
+  }
+
+  // --- Add new created particles 
+  if (gMC->NSecondaries() > 0) {
+    pProc=gMC->ProdProcess(0);
+    for (jk = 0; jk < geant3->Gcking()->ngkine; ++jk) {
+      ipp = Int_t (geant3->Gcking()->gkin[jk][4]+0.5);
+      // --- Skip neutrinos! 
+      if (ipp != 4) {
+       gAlice->SetTrack(1,gAlice->CurrentTrack(),gMC->PDGFromId(ipp), geant3->Gcking()->gkin[jk], 
+                        geant3->Gckin3()->gpos[jk], polar,geant3->Gctrak()->tofg, pProc, nt);
+      }
+    }
+  }
+  // Cherenkov photons here
+  if ( geant3->Gckin2()->ngphot ) {
+    for (jk = 0; jk < geant3->Gckin2()->ngphot; ++jk) {
+      mom[0]=geant3->Gckin2()->xphot[jk][3]*geant3->Gckin2()->xphot[jk][6];
+      mom[1]=geant3->Gckin2()->xphot[jk][4]*geant3->Gckin2()->xphot[jk][6];
+      mom[2]=geant3->Gckin2()->xphot[jk][5]*geant3->Gckin2()->xphot[jk][6];
+      gAlice->SetTrack(1, gAlice->CurrentTrack(), gMC->PDGFromId(50),
+                      mom,                             //momentum
+                      geant3->Gckin2()->xphot[jk],     //position
+                      &geant3->Gckin2()->xphot[jk][7], //polarisation
+                      geant3->Gckin2()->xphot[jk][10], //time of flight
+                      kPCerenkov, nt);
+      }
+  }
+  // --- Particle leaving the setup ?
+  if (!gMC->IsTrackOut()) 
+    if ((id=gAlice->DetFromMate(geant3->Gctmed()->numed)) >= 0) gAlice->StepManager(id);
+
+  // --- Standard GEANT debug routine 
+  if(geant3->Gcflag()->idebug) geant3->Gdebug();
+}
+
+//______________________________________________________________________
+void gukine ()
+{
+//
+//    ******************************************************************
+//    *                                                                *
+//    *       Read or Generates Kinematics for primary tracks          *
+//    *                                                                *
+//    *    ==>Called by : GTRIG                                        *
+//    *                                                                *
+//    ******************************************************************
+//
+//
+//    ------------------------------------------------------------------
+//
+  gAlice->Generator()->Generate();
+}
+
+
+//______________________________________________________________________
+void uglast()
+{
+//
+//    ******************************************************************
+//    *                                                                *
+//    *       User routine called at the end of the run                *
+//    *                                                                *
+//    *    ==>Called by : GRUN                                         *
+//    *                                                                *
+//    ******************************************************************
+//
+//
+}
+}
+
diff --git a/AliGeant3/AliGeant3.h.orig b/AliGeant3/AliGeant3.h.orig
new file mode 100644 (file)
index 0000000..c961626
--- /dev/null
@@ -0,0 +1,44 @@
+#ifndef ALIGEANT3_H
+#define ALIGEANT3_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+
+///////////////////////////////////////////////////////////////////////////////
+//                                                                           //
+//                                                                           //
+//    Generic interface to MC for AliRoot                                    //
+//                                                                           //
+//                                                                           //
+///////////////////////////////////////////////////////////////////////////////
+
+#include <TGeant3.h>
+
+class AliGeant3 : public TGeant3
+{
+
+public:
+  AliGeant3(const char *title);
+  AliGeant3() {}
+  virtual ~AliGeant3() {}
+
+  void   SetColors();
+
+  //
+  //
+  // Control Methods
+
+  virtual void Init();
+  virtual void FinishGeometry();
+  virtual void ProcessEvent();
+  virtual void ProcessRun(Int_t nevent);
+
+private:
+
+  ClassDef(AliGeant3,1) //Generic MonteCarlo Class
+
+};
+
+#endif
+
diff --git a/AliGeant3/AliGeant3Cint.cxx b/AliGeant3/AliGeant3Cint.cxx
new file mode 100644 (file)
index 0000000..9c164af
--- /dev/null
@@ -0,0 +1,3117 @@
+//
+// File generated by rootcint at Thu Apr 25 16:42:33 2002.
+// Do NOT change. Changes will be lost next time file is generated
+//
+#include "AliGeant3Cint.h"
+
+#include "TClass.h"
+#include "TBuffer.h"
+#include "TMemberInspector.h"
+#include "TError.h"
+
+#ifndef G__ROOT
+#define G__ROOT
+#endif
+
+//______________________________________________________________________________
+TBuffer &operator>>(TBuffer &buf, AliG3Medium *&obj)
+{
+   // Read a pointer to an object of class AliG3Medium.
+
+   obj = (AliG3Medium *) buf.ReadObject(AliG3Medium::Class());
+   return buf;
+}
+
+//______________________________________________________________________________
+TBuffer &operator>>(TBuffer &buf, AliG3Material *&obj)
+{
+   // Read a pointer to an object of class AliG3Material.
+
+   obj = (AliG3Material *) buf.ReadObject(AliG3Material::Class());
+   return buf;
+}
+
+//______________________________________________________________________________
+TBuffer &operator>>(TBuffer &buf, AliG3Volume *&obj)
+{
+   // Read a pointer to an object of class AliG3Volume.
+
+   obj = (AliG3Volume *) buf.ReadObject(AliG3Volume::Class());
+   return buf;
+}
+
+//______________________________________________________________________________
+TBuffer &operator>>(TBuffer &buf, AliNode *&obj)
+{
+   // Read a pointer to an object of class AliNode.
+
+   obj = (AliNode *) buf.ReadObject(AliNode::Class());
+   return buf;
+}
+
+//______________________________________________________________________________
+TBuffer &operator>>(TBuffer &buf, AliGuiGeomMain *&obj)
+{
+   // Read a pointer to an object of class AliGuiGeomMain.
+
+   obj = (AliGuiGeomMain *) buf.ReadObject(AliGuiGeomMain::Class());
+   return buf;
+}
+
+//______________________________________________________________________________
+TBuffer &operator>>(TBuffer &buf, AliGeant3GeometryGUI *&obj)
+{
+   // Read a pointer to an object of class AliGeant3GeometryGUI.
+
+   obj = (AliGeant3GeometryGUI *) buf.ReadObject(AliGeant3GeometryGUI::Class());
+   return buf;
+}
+
+//______________________________________________________________________________
+TBuffer &operator>>(TBuffer &buf, AliG3toRoot *&obj)
+{
+   // Read a pointer to an object of class AliG3toRoot.
+
+   obj = (AliG3toRoot *) buf.ReadObject(AliG3toRoot::Class());
+   return buf;
+}
+
+//______________________________________________________________________________
+void R__AliGuiGeomMain_fComboMaterialEntries(TBuffer &R__b, void *R__p, int)
+{
+   TClonesArray** fComboMaterialEntries = (TClonesArray**)R__p;
+   if (R__b.IsReading()) {
+      R__b >> *fComboMaterialEntries;
+   } else {
+      R__b << (TObject*)*fComboMaterialEntries;
+   }
+}
+
+//______________________________________________________________________________
+void R__AliGuiGeomMain_fComboMediaEntries(TBuffer &R__b, void *R__p, int)
+{
+   TClonesArray** fComboMediaEntries = (TClonesArray**)R__p;
+   if (R__b.IsReading()) {
+      R__b >> *fComboMediaEntries;
+   } else {
+      R__b << (TObject*)*fComboMediaEntries;
+   }
+}
+
+//______________________________________________________________________________
+void AliGuiGeomMain::ShowMembers(TMemberInspector &R__insp, char *R__parent)
+{
+   // Inspect the data members of an object of class AliGuiGeomMain.
+
+   TClass *R__cl  = AliGuiGeomMain::IsA();
+   Int_t   R__ncp = strlen(R__parent);
+   if (R__ncp || R__cl || R__insp.IsA()) { }
+   R__insp.Inspect(R__cl, R__parent, "*fTab", &fTab);
+   R__insp.Inspect(R__cl, R__parent, "*fCanvasWindow", &fCanvasWindow);
+   R__insp.Inspect(R__cl, R__parent, "*fF2", &fF2);
+   R__insp.Inspect(R__cl, R__parent, "*fF21", &fF21);
+   R__insp.Inspect(R__cl, R__parent, "*fF3", &fF3);
+   R__insp.Inspect(R__cl, R__parent, "*fF31", &fF31);
+   R__insp.Inspect(R__cl, R__parent, "*fF4", &fF4);
+   R__insp.Inspect(R__cl, R__parent, "*fF5", &fF5);
+   R__insp.Inspect(R__cl, R__parent, "*fF6", &fF6);
+   R__insp.Inspect(R__cl, R__parent, "*fF61", &fF61);
+   R__insp.Inspect(R__cl, R__parent, "*fF62", &fF62);
+   R__insp.Inspect(R__cl, R__parent, "*fF63", &fF63);
+   R__insp.Inspect(R__cl, R__parent, "*fLt", &fLt);
+   R__insp.Inspect(R__cl, R__parent, "*fMenuBar", &fMenuBar);
+   R__insp.Inspect(R__cl, R__parent, "*fMenuFile", &fMenuFile);
+   R__insp.Inspect(R__cl, R__parent, "*fMenuTest", &fMenuTest);
+   R__insp.Inspect(R__cl, R__parent, "*fMenuHelp", &fMenuHelp);
+   R__insp.Inspect(R__cl, R__parent, "*fMenuBarItemLayout", &fMenuBarItemLayout);
+   R__insp.Inspect(R__cl, R__parent, "*fMenuBarHelpLayout", &fMenuBarHelpLayout);
+   R__insp.Inspect(R__cl, R__parent, "*fMenuBarLayout", &fMenuBarLayout);
+   R__insp.Inspect(R__cl, R__parent, "fLTab", &fLTab);
+   fLTab.ShowMembers(R__insp, strcat(R__parent,"fLTab.")); R__parent[R__ncp] = 0;
+   R__insp.Inspect(R__cl, R__parent, "*fL2", &fL2);
+   R__insp.Inspect(R__cl, R__parent, "*fDialog", &fDialog);
+   R__insp.Inspect(R__cl, R__parent, "*fMaterialCombo", &fMaterialCombo);
+   R__insp.Inspect(R__cl, R__parent, "*fMechanismCombo", &fMechanismCombo);
+   R__insp.Inspect(R__cl, R__parent, "*fMediaCombo", &fMediaCombo);
+   R__insp.Inspect(R__cl, R__parent, "*fParticleCombo", &fParticleCombo);
+   R__insp.Inspect(R__cl, R__parent, "*fProcessLB", &fProcessLB);
+   R__insp.Inspect(R__cl, R__parent, "*fCutsLB", &fCutsLB);
+   R__insp.Inspect(R__cl, R__parent, "*fComboMaterialEntries", &fComboMaterialEntries);
+   R__cl->SetStreamer("*fComboMaterialEntries",R__AliGuiGeomMain_fComboMaterialEntries);
+   R__insp.Inspect(R__cl, R__parent, "*fComboMediaEntries", &fComboMediaEntries);
+   R__cl->SetStreamer("*fComboMediaEntries",R__AliGuiGeomMain_fComboMediaEntries);
+   R__insp.Inspect(R__cl, R__parent, "*fHframe[6]", &fHframe);
+   R__insp.Inspect(R__cl, R__parent, "*fHframeM[8]", &fHframeM);
+   R__insp.Inspect(R__cl, R__parent, "*fTbh[6]", &fTbh);
+   R__insp.Inspect(R__cl, R__parent, "*fTbhM[8]", &fTbhM);
+   R__insp.Inspect(R__cl, R__parent, "*fTbh61", &fTbh61);
+   R__insp.Inspect(R__cl, R__parent, "*fTbh62", &fTbh62);
+   R__insp.Inspect(R__cl, R__parent, "*fTbh63", &fTbh63);
+   R__insp.Inspect(R__cl, R__parent, "*fTeh[6]", &fTeh);
+   R__insp.Inspect(R__cl, R__parent, "*fTehM[8]", &fTehM);
+   R__insp.Inspect(R__cl, R__parent, "*fTeh61", &fTeh61);
+   R__insp.Inspect(R__cl, R__parent, "*fTeh62", &fTeh62);
+   R__insp.Inspect(R__cl, R__parent, "*fTeh63", &fTeh63);
+   R__insp.Inspect(R__cl, R__parent, "*fLabel[6]", &fLabel);
+   R__insp.Inspect(R__cl, R__parent, "*fLabelM[8]", &fLabelM);
+   R__insp.Inspect(R__cl, R__parent, "*fSLabel61", &fSLabel61);
+   R__insp.Inspect(R__cl, R__parent, "*fPlotButton", &fPlotButton);
+   R__insp.Inspect(R__cl, R__parent, "fEmin", &fEmin);
+   R__insp.Inspect(R__cl, R__parent, "fEmax", &fEmax);
+   R__insp.Inspect(R__cl, R__parent, "fNbins", &fNbins);
+   TGMainFrame::ShowMembers(R__insp, R__parent);
+}
+
+//______________________________________________________________________________
+const char *AliGuiGeomMain::Class_Name()
+{
+   // Return the class name for AliGuiGeomMain.
+   return "AliGuiGeomMain";
+}
+
+// Static variable to hold initialization object
+static AliGuiGeomMain::R__Init __gR__InitAliGuiGeomMain(1);
+
+//______________________________________________________________________________
+void R__AliG3Volume_fPosition(TBuffer &R__b, void *R__p, int)
+{
+   TArrayF &fPosition = *(TArrayF *)R__p;
+   if (R__b.IsReading()) {
+      fPosition.Streamer(R__b);
+   } else {
+      fPosition.Streamer(R__b);
+   }
+}
+
+//______________________________________________________________________________
+void R__AliG3Volume_fParameters(TBuffer &R__b, void *R__p, int)
+{
+   TArrayF &fParameters = *(TArrayF *)R__p;
+   if (R__b.IsReading()) {
+      fParameters.Streamer(R__b);
+   } else {
+      fParameters.Streamer(R__b);
+   }
+}
+
+//______________________________________________________________________________
+void R__AliG3Volume_fCopies(TBuffer &R__b, void *R__p, int)
+{
+   TList** fCopies = (TList**)R__p;
+   if (R__b.IsReading()) {
+      R__b >> *fCopies;
+   } else {
+      R__b << (TObject*)*fCopies;
+   }
+}
+
+//______________________________________________________________________________
+void AliG3Volume::Streamer(TBuffer &R__b)
+{
+   // Stream an object of class AliG3Volume.
+
+   if (R__b.IsReading()) {
+      AliG3Volume::Class()->ReadBuffer(R__b, this);
+   } else {
+      AliG3Volume::Class()->WriteBuffer(R__b, this);
+   }
+}
+
+//______________________________________________________________________________
+void AliG3Volume::ShowMembers(TMemberInspector &R__insp, char *R__parent)
+{
+   // Inspect the data members of an object of class AliG3Volume.
+
+   TClass *R__cl  = AliG3Volume::IsA();
+   Int_t   R__ncp = strlen(R__parent);
+   if (R__ncp || R__cl || R__insp.IsA()) { }
+   R__insp.Inspect(R__cl, R__parent, "fPosition", &fPosition);
+   fPosition.ShowMembers(R__insp, strcat(R__parent,"fPosition.")); R__parent[R__ncp] = 0;
+   R__cl->SetStreamer("fPosition",R__AliG3Volume_fPosition);
+   R__insp.Inspect(R__cl, R__parent, "fParameters", &fParameters);
+   fParameters.ShowMembers(R__insp, strcat(R__parent,"fParameters.")); R__parent[R__ncp] = 0;
+   R__cl->SetStreamer("fParameters",R__AliG3Volume_fParameters);
+   R__insp.Inspect(R__cl, R__parent, "*fCopies", &fCopies);
+   R__cl->SetStreamer("*fCopies",R__AliG3Volume_fCopies);
+   R__insp.Inspect(R__cl, R__parent, "fPosp", &fPosp);
+   R__insp.Inspect(R__cl, R__parent, "fNCopies", &fNCopies);
+   R__insp.Inspect(R__cl, R__parent, "fRotMatrix", &fRotMatrix);
+   R__insp.Inspect(R__cl, R__parent, "fNParam", &fNParam);
+   R__insp.Inspect(R__cl, R__parent, "fAxis", &fAxis);
+   R__insp.Inspect(R__cl, R__parent, "fNdiv", &fNdiv);
+   R__insp.Inspect(R__cl, R__parent, "fStep", &fStep);
+   R__insp.Inspect(R__cl, R__parent, "fStartC", &fStartC);
+   R__insp.Inspect(R__cl, R__parent, "fShape", &fShape);
+   R__insp.Inspect(R__cl, R__parent, "fTheta", &fTheta);
+   R__insp.Inspect(R__cl, R__parent, "fPhi", &fPhi);
+   R__insp.Inspect(R__cl, R__parent, "fPsi", &fPsi);
+   R__insp.Inspect(R__cl, R__parent, "fU", &fU);
+   R__insp.Inspect(R__cl, R__parent, "fV", &fV);
+   R__insp.Inspect(R__cl, R__parent, "fUscale", &fUscale);
+   R__insp.Inspect(R__cl, R__parent, "fVscale", &fVscale);
+   R__insp.Inspect(R__cl, R__parent, "fHide", &fHide);
+   R__insp.Inspect(R__cl, R__parent, "fShadow", &fShadow);
+   R__insp.Inspect(R__cl, R__parent, "fFill", &fFill);
+   R__insp.Inspect(R__cl, R__parent, "fSeen", &fSeen);
+   R__insp.Inspect(R__cl, R__parent, "fClip", &fClip);
+   R__insp.Inspect(R__cl, R__parent, "fClipXmin", &fClipXmin);
+   R__insp.Inspect(R__cl, R__parent, "fClipXmax", &fClipXmax);
+   R__insp.Inspect(R__cl, R__parent, "fClipYmin", &fClipYmin);
+   R__insp.Inspect(R__cl, R__parent, "fClipYmax", &fClipYmax);
+   R__insp.Inspect(R__cl, R__parent, "fClipZmin", &fClipZmin);
+   R__insp.Inspect(R__cl, R__parent, "fClipZmax", &fClipZmax);
+   R__insp.Inspect(R__cl, R__parent, "fIdVolume", &fIdVolume);
+   R__insp.Inspect(R__cl, R__parent, "fIdMedium", &fIdMedium);
+   R__insp.Inspect(R__cl, R__parent, "fIdMaterial", &fIdMaterial);
+   R__insp.Inspect(R__cl, R__parent, "fIdCopy", &fIdCopy);
+   R__insp.Inspect(R__cl, R__parent, "*fItem", &fItem);
+   TNamed::ShowMembers(R__insp, R__parent);
+}
+
+//______________________________________________________________________________
+const char *AliG3Volume::Class_Name()
+{
+   // Return the class name for AliG3Volume.
+   return "AliG3Volume";
+}
+
+// Static variable to hold initialization object
+static AliG3Volume::R__Init __gR__InitAliG3Volume(4);
+
+//______________________________________________________________________________
+void R__AliGeant3GeometryGUI_fPanel(TBuffer &R__b, void *R__p, int)
+{
+   AliGuiGeomMain** fPanel = (AliGuiGeomMain**)R__p;
+   if (R__b.IsReading()) {
+      R__b >> *fPanel;
+   } else {
+      R__b << (TObject*)*fPanel;
+   }
+}
+
+//______________________________________________________________________________
+void R__AliGeant3GeometryGUI_fVolumes(TBuffer &R__b, void *R__p, int)
+{
+   TClonesArray** fVolumes = (TClonesArray**)R__p;
+   if (R__b.IsReading()) {
+      R__b >> *fVolumes;
+   } else {
+      R__b << (TObject*)*fVolumes;
+   }
+}
+
+//______________________________________________________________________________
+void R__AliGeant3GeometryGUI_fMaterials(TBuffer &R__b, void *R__p, int)
+{
+   TClonesArray** fMaterials = (TClonesArray**)R__p;
+   if (R__b.IsReading()) {
+      R__b >> *fMaterials;
+   } else {
+      R__b << (TObject*)*fMaterials;
+   }
+}
+
+//______________________________________________________________________________
+void R__AliGeant3GeometryGUI_fMedia(TBuffer &R__b, void *R__p, int)
+{
+   TClonesArray** fMedia = (TClonesArray**)R__p;
+   if (R__b.IsReading()) {
+      R__b >> *fMedia;
+   } else {
+      R__b << (TObject*)*fMedia;
+   }
+}
+
+//______________________________________________________________________________
+void R__AliGeant3GeometryGUI_fRotations(TBuffer &R__b, void *R__p, int)
+{
+   TObjArray** fRotations = (TObjArray**)R__p;
+   if (R__b.IsReading()) {
+      R__b >> *fRotations;
+   } else {
+      R__b << (TObject*)*fRotations;
+   }
+}
+
+//______________________________________________________________________________
+void AliGeant3GeometryGUI::ShowMembers(TMemberInspector &R__insp, char *R__parent)
+{
+   // Inspect the data members of an object of class AliGeant3GeometryGUI.
+
+   TClass *R__cl  = AliGeant3GeometryGUI::IsA();
+   Int_t   R__ncp = strlen(R__parent);
+   if (R__ncp || R__cl || R__insp.IsA()) { }
+   R__insp.Inspect(R__cl, R__parent, "*fPanel", &fPanel);
+   R__cl->SetStreamer("*fPanel",R__AliGeant3GeometryGUI_fPanel);
+   R__insp.Inspect(R__cl, R__parent, "fNstack", &fNstack);
+   R__insp.Inspect(R__cl, R__parent, "*fVolumes", &fVolumes);
+   R__cl->SetStreamer("*fVolumes",R__AliGeant3GeometryGUI_fVolumes);
+   R__insp.Inspect(R__cl, R__parent, "fNMaterials", &fNMaterials);
+   R__insp.Inspect(R__cl, R__parent, "*fMaterials", &fMaterials);
+   R__cl->SetStreamer("*fMaterials",R__AliGeant3GeometryGUI_fMaterials);
+   R__insp.Inspect(R__cl, R__parent, "*fMedia", &fMedia);
+   R__cl->SetStreamer("*fMedia",R__AliGeant3GeometryGUI_fMedia);
+   R__insp.Inspect(R__cl, R__parent, "*fRotations", &fRotations);
+   R__cl->SetStreamer("*fRotations",R__AliGeant3GeometryGUI_fRotations);
+   TObject::ShowMembers(R__insp, R__parent);
+}
+
+//______________________________________________________________________________
+const char *AliGeant3GeometryGUI::Class_Name()
+{
+   // Return the class name for AliGeant3GeometryGUI.
+   return "AliGeant3GeometryGUI";
+}
+
+// Static variable to hold initialization object
+static AliGeant3GeometryGUI::R__Init __gR__InitAliGeant3GeometryGUI(1);
+
+//______________________________________________________________________________
+void AliG3Material::Streamer(TBuffer &R__b)
+{
+   // Stream an object of class AliG3Material.
+
+   if (R__b.IsReading()) {
+      AliG3Material::Class()->ReadBuffer(R__b, this);
+   } else {
+      AliG3Material::Class()->WriteBuffer(R__b, this);
+   }
+}
+
+//______________________________________________________________________________
+void AliG3Material::ShowMembers(TMemberInspector &R__insp, char *R__parent)
+{
+   // Inspect the data members of an object of class AliG3Material.
+
+   TClass *R__cl  = AliG3Material::IsA();
+   Int_t   R__ncp = strlen(R__parent);
+   if (R__ncp || R__cl || R__insp.IsA()) { }
+   R__insp.Inspect(R__cl, R__parent, "fId", &fId);
+   TMaterial::ShowMembers(R__insp, R__parent);
+}
+
+//______________________________________________________________________________
+const char *AliG3Material::Class_Name()
+{
+   // Return the class name for AliG3Material.
+   return "AliG3Material";
+}
+
+// Static variable to hold initialization object
+static AliG3Material::R__Init __gR__InitAliG3Material(4);
+
+//______________________________________________________________________________
+void AliG3Medium::ShowMembers(TMemberInspector &R__insp, char *R__parent)
+{
+   // Inspect the data members of an object of class AliG3Medium.
+
+   TClass *R__cl  = AliG3Medium::IsA();
+   Int_t   R__ncp = strlen(R__parent);
+   if (R__ncp || R__cl || R__insp.IsA()) { }
+   R__insp.Inspect(R__cl, R__parent, "fPars[33]", fPars);
+   R__insp.Inspect(R__cl, R__parent, "fId", &fId);
+   R__insp.Inspect(R__cl, R__parent, "fIdMat", &fIdMat);
+   R__insp.Inspect(R__cl, R__parent, "fIsvol", &fIsvol);
+   R__insp.Inspect(R__cl, R__parent, "fIfield", &fIfield);
+   R__insp.Inspect(R__cl, R__parent, "fFieldm", &fFieldm);
+   R__insp.Inspect(R__cl, R__parent, "fTmaxfd", &fTmaxfd);
+   R__insp.Inspect(R__cl, R__parent, "fStemax", &fStemax);
+   R__insp.Inspect(R__cl, R__parent, "fDeemax", &fDeemax);
+   R__insp.Inspect(R__cl, R__parent, "fEpsil", &fEpsil);
+   R__insp.Inspect(R__cl, R__parent, "fStmin", &fStmin);
+   R__insp.Inspect(R__cl, R__parent, "fItem", &fItem);
+   TNamed::ShowMembers(R__insp, R__parent);
+}
+
+//______________________________________________________________________________
+const char *AliG3Medium::Class_Name()
+{
+   // Return the class name for AliG3Medium.
+   return "AliG3Medium";
+}
+
+// Static variable to hold initialization object
+static AliG3Medium::R__Init __gR__InitAliG3Medium(1);
+
+//______________________________________________________________________________
+void AliNode::Streamer(TBuffer &R__b)
+{
+   // Stream an object of class AliNode.
+
+   if (R__b.IsReading()) {
+      AliNode::Class()->ReadBuffer(R__b, this);
+   } else {
+      AliNode::Class()->WriteBuffer(R__b, this);
+   }
+}
+
+//______________________________________________________________________________
+void AliNode::ShowMembers(TMemberInspector &R__insp, char *R__parent)
+{
+   // Inspect the data members of an object of class AliNode.
+
+   TClass *R__cl  = AliNode::IsA();
+   Int_t   R__ncp = strlen(R__parent);
+   if (R__ncp || R__cl || R__insp.IsA()) { }
+   R__insp.Inspect(R__cl, R__parent, "fAxis", &fAxis);
+   R__insp.Inspect(R__cl, R__parent, "fNDivision", &fNDivision);
+   R__insp.Inspect(R__cl, R__parent, "fStep", &fStep);
+   R__insp.Inspect(R__cl, R__parent, "fStartC", &fStartC);
+   TNode::ShowMembers(R__insp, R__parent);
+}
+
+//______________________________________________________________________________
+const char *AliNode::Class_Name()
+{
+   // Return the class name for AliNode.
+   return "AliNode";
+}
+
+// Static variable to hold initialization object
+static AliNode::R__Init __gR__InitAliNode(4);
+
+//______________________________________________________________________________
+void AliG3toRoot::Streamer(TBuffer &R__b)
+{
+   // Stream an object of class AliG3toRoot.
+
+   if (R__b.IsReading()) {
+      AliG3toRoot::Class()->ReadBuffer(R__b, this);
+   } else {
+      AliG3toRoot::Class()->WriteBuffer(R__b, this);
+   }
+}
+
+//______________________________________________________________________________
+void AliG3toRoot::ShowMembers(TMemberInspector &R__insp, char *R__parent)
+{
+   // Inspect the data members of an object of class AliG3toRoot.
+
+   TClass *R__cl  = AliG3toRoot::IsA();
+   Int_t   R__ncp = strlen(R__parent);
+   if (R__ncp || R__cl || R__insp.IsA()) { }
+   R__insp.Inspect(R__cl, R__parent, "*fVolumes", &fVolumes);
+   R__insp.Inspect(R__cl, R__parent, "*fMaterials", &fMaterials);
+   R__insp.Inspect(R__cl, R__parent, "*fMedia", &fMedia);
+   R__insp.Inspect(R__cl, R__parent, "*fRotations", &fRotations);
+   R__insp.Inspect(R__cl, R__parent, "*fZlq", &fZlq);
+   R__insp.Inspect(R__cl, R__parent, "*fZq", &fZq);
+   R__insp.Inspect(R__cl, R__parent, "*fZiq", &fZiq);
+   R__insp.Inspect(R__cl, R__parent, "*fGclink", &fGclink);
+   R__insp.Inspect(R__cl, R__parent, "*fGcnum", &fGcnum);
+   R__insp.Inspect(R__cl, R__parent, "*fTopFolder", &fTopFolder);
+   R__insp.Inspect(R__cl, R__parent, "*fGeometry", &fGeometry);
+   R__insp.Inspect(R__cl, R__parent, "fExpand", &fExpand);
+   TObject::ShowMembers(R__insp, R__parent);
+}
+
+//______________________________________________________________________________
+const char *AliG3toRoot::Class_Name()
+{
+   // Return the class name for AliG3toRoot.
+   return "AliG3toRoot";
+}
+
+// Static variable to hold initialization object
+static AliG3toRoot::R__Init __gR__InitAliG3toRoot(4);
+
+/********************************************************
+* AliGeant3Cint.cxx
+********************************************************/
+
+#ifdef G__MEMTEST
+#undef malloc
+#undef free
+#endif
+
+extern "C" void G__cpp_reset_tagtableAliGeant3Cint();
+
+extern "C" void G__set_cpp_environmentAliGeant3Cint() {
+  G__add_compiledheader("TROOT.h");
+  G__add_compiledheader("TMemberInspector.h");
+  G__add_compiledheader("AliG3Medium.h");
+  G__add_compiledheader("AliG3Material.h");
+  G__add_compiledheader("AliG3Volume.h");
+  G__add_compiledheader("AliGUISliders.h");
+  G__add_compiledheader("AliGuiGeomDialog.h");
+  G__add_compiledheader("AliGuiGeomMain.h");
+  G__add_compiledheader("AliGeant3GeometryGUI.h");
+  G__add_compiledheader("AliNode.h");
+  G__add_compiledheader("AliG3toRoot.h");
+  G__cpp_reset_tagtableAliGeant3Cint();
+}
+class G__AliGeant3CintdOcxx_tag {};
+
+void* operator new(size_t size,G__AliGeant3CintdOcxx_tag* p) {
+  if(p && G__PVOID!=G__getgvp()) return((void*)p);
+#ifndef G__ROOT
+  return(malloc(size));
+#else
+  return(::operator new(size));
+#endif
+}
+
+/* dummy, for exception */
+#ifdef G__EH_DUMMY_DELETE
+void operator delete(void *p,G__AliGeant3CintdOcxx_tag* x) {
+  if((long)p==G__getgvp() && G__PVOID!=G__getgvp()) return;
+#ifndef G__ROOT
+  free(p);
+#else
+  ::operator delete(p);
+#endif
+}
+#endif
+
+static void G__operator_delete(void *p) {
+  if((long)p==G__getgvp() && G__PVOID!=G__getgvp()) return;
+#ifndef G__ROOT
+  free(p);
+#else
+  ::operator delete(p);
+#endif
+}
+
+void G__DELDMY_AliGeant3CintdOcxx() { G__operator_delete(0); }
+
+extern "C" int G__cpp_dllrevAliGeant3Cint() { return(30051515); }
+
+/*********************************************************
+* Member function Interface Method
+*********************************************************/
+
+/* AliG3Medium */
+static int G__AliG3Medium_AliG3Medium_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+   AliG3Medium *p=NULL;
+   if(G__getaryconstruct()) p=new AliG3Medium[G__getaryconstruct()];
+   else                    p=new AliG3Medium;
+      result7->obj.i = (long)p;
+      result7->ref = (long)p;
+      result7->type = 'u';
+      result7->tagnum = G__get_linked_tagnum(&G__AliGeant3CintLN_AliG3Medium);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Medium_AliG3Medium_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+   AliG3Medium *p=NULL;
+      p = new AliG3Medium(
+(Int_t)G__int(libp->para[0]),(Int_t)G__int(libp->para[1])
+,(const char*)G__int(libp->para[2]),(Int_t)G__int(libp->para[3])
+,(Int_t)G__int(libp->para[4]),(Float_t)G__double(libp->para[5])
+,(Float_t)G__double(libp->para[6]),(Float_t)G__double(libp->para[7])
+,(Float_t)G__double(libp->para[8]),(Float_t)G__double(libp->para[9])
+,(Float_t)G__double(libp->para[10]));
+      result7->obj.i = (long)p;
+      result7->ref = (long)p;
+      result7->type = 'u';
+      result7->tagnum = G__get_linked_tagnum(&G__AliGeant3CintLN_AliG3Medium);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Medium_Dump_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliG3Medium*)(G__getstructoffset()))->Dump();
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Medium_Id_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,105,(long)((AliG3Medium*)(G__getstructoffset()))->Id());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Medium_IdMat_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,105,(long)((AliG3Medium*)(G__getstructoffset()))->IdMat());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Medium_Isvol_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,105,(long)((AliG3Medium*)(G__getstructoffset()))->Isvol());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Medium_Ifield_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,105,(long)((AliG3Medium*)(G__getstructoffset()))->Ifield());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Medium_Fieldm_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letdouble(result7,102,(double)((AliG3Medium*)(G__getstructoffset()))->Fieldm());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Medium_Tmaxfd_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letdouble(result7,102,(double)((AliG3Medium*)(G__getstructoffset()))->Tmaxfd());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Medium_Stemax_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letdouble(result7,102,(double)((AliG3Medium*)(G__getstructoffset()))->Stemax());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Medium_Deemax_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letdouble(result7,102,(double)((AliG3Medium*)(G__getstructoffset()))->Deemax());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Medium_Epsil_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letdouble(result7,102,(double)((AliG3Medium*)(G__getstructoffset()))->Epsil());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Medium_Stmin_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letdouble(result7,102,(double)((AliG3Medium*)(G__getstructoffset()))->Stmin());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Medium_SetPar_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliG3Medium*)(G__getstructoffset()))->SetPar((Int_t)G__int(libp->para[0]),(Float_t)G__double(libp->para[1]));
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Medium_GetPar_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letdouble(result7,102,(double)((AliG3Medium*)(G__getstructoffset()))->GetPar((Int_t)G__int(libp->para[0])));
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Medium_ItemId_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,105,(long)((AliG3Medium*)(G__getstructoffset()))->ItemId());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Medium_SetItemId_7_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliG3Medium*)(G__getstructoffset()))->SetItemId((Int_t)G__int(libp->para[0]));
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Medium_Class_0_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,85,(long)((AliG3Medium*)(G__getstructoffset()))->Class());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Medium_Class_Name_1_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,67,(long)((AliG3Medium*)(G__getstructoffset()))->Class_Name());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Medium_Class_Version_2_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,115,(long)((AliG3Medium*)(G__getstructoffset()))->Class_Version());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Medium_Dictionary_3_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliG3Medium*)(G__getstructoffset()))->Dictionary();
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Medium_IsA_4_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,85,(long)((const AliG3Medium*)(G__getstructoffset()))->IsA());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Medium_ShowMembers_5_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliG3Medium*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Medium_Streamer_6_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliG3Medium*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Medium_StreamerNVirtual_7_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliG3Medium*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Medium_DeclFileName_8_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,67,(long)((AliG3Medium*)(G__getstructoffset()))->DeclFileName());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Medium_DeclFileLine_9_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,105,(long)((AliG3Medium*)(G__getstructoffset()))->DeclFileLine());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Medium_ImplFileName_0_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,67,(long)((AliG3Medium*)(G__getstructoffset()))->ImplFileName());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Medium_ImplFileLine_1_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,105,(long)((AliG3Medium*)(G__getstructoffset()))->ImplFileLine());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+// automatic destructor
+typedef AliG3Medium G__TAliG3Medium;
+static int G__AliG3Medium_wAAliG3Medium_2_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+   if(0==G__getstructoffset()) return(1);
+   if(G__getaryconstruct())
+     if(G__PVOID==G__getgvp())
+       delete[] (AliG3Medium *)(G__getstructoffset());
+     else
+       for(int i=G__getaryconstruct()-1;i>=0;i--)
+         delete (AliG3Medium *)((G__getstructoffset())+sizeof(AliG3Medium)*i);
+   else  delete (AliG3Medium *)(G__getstructoffset());
+      G__setnull(result7);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+
+/* AliG3Material */
+static int G__AliG3Material_AliG3Material_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+   AliG3Material *p=NULL;
+   if(G__getaryconstruct()) p=new AliG3Material[G__getaryconstruct()];
+   else                    p=new AliG3Material;
+      result7->obj.i = (long)p;
+      result7->ref = (long)p;
+      result7->type = 'u';
+      result7->tagnum = G__get_linked_tagnum(&G__AliGeant3CintLN_AliG3Material);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Material_AliG3Material_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+   AliG3Material *p=NULL;
+      p = new AliG3Material(
+(char*)G__int(libp->para[0]),(char*)G__int(libp->para[1])
+,(Float_t)G__double(libp->para[2]),(Float_t)G__double(libp->para[3])
+,(Float_t)G__double(libp->para[4]),(Float_t)G__double(libp->para[5])
+,(Float_t)G__double(libp->para[6]));
+      result7->obj.i = (long)p;
+      result7->ref = (long)p;
+      result7->type = 'u';
+      result7->tagnum = G__get_linked_tagnum(&G__AliGeant3CintLN_AliG3Material);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Material_Dump_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliG3Material*)(G__getstructoffset()))->Dump();
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Material_Id_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,105,(long)((AliG3Material*)(G__getstructoffset()))->Id());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Material_SetId_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliG3Material*)(G__getstructoffset()))->SetId((Int_t)G__int(libp->para[0]));
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Material_Class_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,85,(long)((AliG3Material*)(G__getstructoffset()))->Class());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Material_Class_Name_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,67,(long)((AliG3Material*)(G__getstructoffset()))->Class_Name());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Material_Class_Version_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,115,(long)((AliG3Material*)(G__getstructoffset()))->Class_Version());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Material_Dictionary_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliG3Material*)(G__getstructoffset()))->Dictionary();
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Material_IsA_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,85,(long)((const AliG3Material*)(G__getstructoffset()))->IsA());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Material_ShowMembers_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliG3Material*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Material_Streamer_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliG3Material*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Material_StreamerNVirtual_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliG3Material*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Material_DeclFileName_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,67,(long)((AliG3Material*)(G__getstructoffset()))->DeclFileName());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Material_DeclFileLine_7_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,105,(long)((AliG3Material*)(G__getstructoffset()))->DeclFileLine());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Material_ImplFileName_8_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,67,(long)((AliG3Material*)(G__getstructoffset()))->ImplFileName());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Material_ImplFileLine_9_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,105,(long)((AliG3Material*)(G__getstructoffset()))->ImplFileLine());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+// automatic destructor
+typedef AliG3Material G__TAliG3Material;
+static int G__AliG3Material_wAAliG3Material_0_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+   if(0==G__getstructoffset()) return(1);
+   if(G__getaryconstruct())
+     if(G__PVOID==G__getgvp())
+       delete[] (AliG3Material *)(G__getstructoffset());
+     else
+       for(int i=G__getaryconstruct()-1;i>=0;i--)
+         delete (AliG3Material *)((G__getstructoffset())+sizeof(AliG3Material)*i);
+   else  delete (AliG3Material *)(G__getstructoffset());
+      G__setnull(result7);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+
+/* AliG3Volume */
+static int G__AliG3Volume_AliG3Volume_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+   AliG3Volume *p=NULL;
+   if(G__getaryconstruct()) p=new AliG3Volume[G__getaryconstruct()];
+   else                    p=new AliG3Volume;
+      result7->obj.i = (long)p;
+      result7->ref = (long)p;
+      result7->type = 'u';
+      result7->tagnum = G__get_linked_tagnum(&G__AliGeant3CintLN_AliG3Volume);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Volume_AliG3Volume_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+   AliG3Volume *p=NULL;
+      p = new AliG3Volume((const char*)G__int(libp->para[0]));
+      result7->obj.i = (long)p;
+      result7->ref = (long)p;
+      result7->type = 'u';
+      result7->tagnum = G__get_linked_tagnum(&G__AliGeant3CintLN_AliG3Volume);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Volume_Draw_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+   switch(libp->paran) {
+   case 1:
+      G__setnull(result7);
+      ((AliG3Volume*)(G__getstructoffset()))->Draw((Option_t*)G__int(libp->para[0]));
+      break;
+   case 0:
+      G__setnull(result7);
+      ((AliG3Volume*)(G__getstructoffset()))->Draw();
+      break;
+   }
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Volume_DrawSpec_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliG3Volume*)(G__getstructoffset()))->DrawSpec();
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Volume_SetParam_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliG3Volume*)(G__getstructoffset()))->SetParam((Int_t)G__int(libp->para[0]),(Float_t)G__double(libp->para[1]));
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Volume_GetParam_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letdouble(result7,102,(double)((AliG3Volume*)(G__getstructoffset()))->GetParam((Int_t)G__int(libp->para[0])));
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Volume_SetIdVolume_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliG3Volume*)(G__getstructoffset()))->SetIdVolume((Int_t)G__int(libp->para[0]));
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Volume_SetIdCopy_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliG3Volume*)(G__getstructoffset()))->SetIdCopy((Int_t)G__int(libp->para[0]));
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Volume_SetIdMedium_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliG3Volume*)(G__getstructoffset()))->SetIdMedium((Int_t)G__int(libp->para[0]));
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Volume_SetIdMaterial_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliG3Volume*)(G__getstructoffset()))->SetIdMaterial((Int_t)G__int(libp->para[0]));
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Volume_GetIdVolume_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,105,(long)((const AliG3Volume*)(G__getstructoffset()))->GetIdVolume());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Volume_GetIdCopy_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,105,(long)((const AliG3Volume*)(G__getstructoffset()))->GetIdCopy());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Volume_Medium_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,105,(long)((const AliG3Volume*)(G__getstructoffset()))->Medium());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Volume_Material_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,105,(long)((const AliG3Volume*)(G__getstructoffset()))->Material());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Volume_AddCopy_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliG3Volume*)(G__getstructoffset()))->AddCopy();
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Volume_SetItem_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliG3Volume*)(G__getstructoffset()))->SetItem((TObject*)G__int(libp->para[0]));
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Volume_SetPosition_7_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliG3Volume*)(G__getstructoffset()))->SetPosition((Float_t)G__double(libp->para[0]),(Float_t)G__double(libp->para[1])
+,(Float_t)G__double(libp->para[2]));
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Volume_Position_8_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      {
+const         TArrayF *pobj,xobj=((const AliG3Volume*)(G__getstructoffset()))->Position((Int_t)G__int(libp->para[0]));
+        pobj=new TArrayF(xobj);
+        result7->obj.i=(long)((void*)pobj); result7->ref=result7->obj.i;
+        G__store_tempobject(*result7);
+      }
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Volume_SetRotMatrix_9_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliG3Volume*)(G__getstructoffset()))->SetRotMatrix((Int_t)G__int(libp->para[0]));
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Volume_RotMatrix_0_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,105,(long)((const AliG3Volume*)(G__getstructoffset()))->RotMatrix());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Volume_SetShape_1_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliG3Volume*)(G__getstructoffset()))->SetShape((Int_t)G__int(libp->para[0]));
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Volume_Shape_2_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,105,(long)((const AliG3Volume*)(G__getstructoffset()))->Shape());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Volume_SetParameters_3_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliG3Volume*)(G__getstructoffset()))->SetParameters((Int_t)G__int(libp->para[0]),(Float_t*)G__int(libp->para[1]));
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Volume_NParam_4_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,105,(long)((const AliG3Volume*)(G__getstructoffset()))->NParam());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Volume_Parameters_5_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((const AliG3Volume*)(G__getstructoffset()))->Parameters((Int_t)G__int(libp->para[0]),*(TArrayF*)libp->para[1].ref);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Volume_Copies_6_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,85,(long)((const AliG3Volume*)(G__getstructoffset()))->Copies());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Volume_AddCopy_7_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliG3Volume*)(G__getstructoffset()))->AddCopy((AliG3Volume*)G__int(libp->para[0]));
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Volume_Copy_8_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,85,(long)((AliG3Volume*)(G__getstructoffset()))->Copy((Int_t)G__int(libp->para[0])));
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Volume_NCopies_9_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,105,(long)((const AliG3Volume*)(G__getstructoffset()))->NCopies());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Volume_Posp_0_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,103,(long)((const AliG3Volume*)(G__getstructoffset()))->Posp());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Volume_SetPosp_1_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliG3Volume*)(G__getstructoffset()))->SetPosp((Bool_t)G__int(libp->para[0]));
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Volume_CreateTShape_2_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliG3Volume*)(G__getstructoffset()))->CreateTShape((char*)G__int(libp->para[0]),(TMaterial*)G__int(libp->para[1]));
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Volume_SetDivision_3_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliG3Volume*)(G__getstructoffset()))->SetDivision((Int_t)G__int(libp->para[0]),(Int_t)G__int(libp->para[1])
+,(Float_t)G__double(libp->para[2]),(Float_t)G__double(libp->para[3]));
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Volume_Division_4_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((const AliG3Volume*)(G__getstructoffset()))->Division(*(Int_t*)G__Intref(&libp->para[0]),*(Int_t*)G__Intref(&libp->para[1])
+,*(Float_t*)G__Floatref(&libp->para[2]),*(Float_t*)G__Floatref(&libp->para[3]));
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Volume_Axis_5_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,105,(long)((AliG3Volume*)(G__getstructoffset()))->Axis());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Volume_Ndiv_6_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,105,(long)((AliG3Volume*)(G__getstructoffset()))->Ndiv());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Volume_Step_7_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letdouble(result7,102,(double)((AliG3Volume*)(G__getstructoffset()))->Step());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Volume_StartC_8_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letdouble(result7,102,(double)((AliG3Volume*)(G__getstructoffset()))->StartC());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Volume_GetItem_9_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,85,(long)((AliG3Volume*)(G__getstructoffset()))->GetItem());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Volume_AliG3Volume_0_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+   AliG3Volume *p=NULL;
+      p = new AliG3Volume(*(AliG3Volume*)libp->para[0].ref);
+      result7->obj.i = (long)p;
+      result7->ref = (long)p;
+      result7->type = 'u';
+      result7->tagnum = G__get_linked_tagnum(&G__AliGeant3CintLN_AliG3Volume);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Volume_Class_2_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,85,(long)((AliG3Volume*)(G__getstructoffset()))->Class());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Volume_Class_Name_3_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,67,(long)((AliG3Volume*)(G__getstructoffset()))->Class_Name());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Volume_Class_Version_4_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,115,(long)((AliG3Volume*)(G__getstructoffset()))->Class_Version());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Volume_Dictionary_5_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliG3Volume*)(G__getstructoffset()))->Dictionary();
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Volume_IsA_6_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,85,(long)((const AliG3Volume*)(G__getstructoffset()))->IsA());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Volume_ShowMembers_7_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliG3Volume*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Volume_Streamer_8_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliG3Volume*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Volume_StreamerNVirtual_9_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliG3Volume*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Volume_DeclFileName_0_5(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,67,(long)((AliG3Volume*)(G__getstructoffset()))->DeclFileName());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Volume_DeclFileLine_1_5(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,105,(long)((AliG3Volume*)(G__getstructoffset()))->DeclFileLine());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Volume_ImplFileName_2_5(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,67,(long)((AliG3Volume*)(G__getstructoffset()))->ImplFileName());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3Volume_ImplFileLine_3_5(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,105,(long)((AliG3Volume*)(G__getstructoffset()))->ImplFileLine());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+// automatic destructor
+typedef AliG3Volume G__TAliG3Volume;
+static int G__AliG3Volume_wAAliG3Volume_4_5(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+   if(0==G__getstructoffset()) return(1);
+   if(G__getaryconstruct())
+     if(G__PVOID==G__getgvp())
+       delete[] (AliG3Volume *)(G__getstructoffset());
+     else
+       for(int i=G__getaryconstruct()-1;i>=0;i--)
+         delete (AliG3Volume *)((G__getstructoffset())+sizeof(AliG3Volume)*i);
+   else  delete (AliG3Volume *)(G__getstructoffset());
+      G__setnull(result7);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+
+/* AliNode */
+static int G__AliNode_AliNode_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+   AliNode *p=NULL;
+   if(G__getaryconstruct()) p=new AliNode[G__getaryconstruct()];
+   else                    p=new AliNode;
+      result7->obj.i = (long)p;
+      result7->ref = (long)p;
+      result7->type = 'u';
+      result7->tagnum = G__get_linked_tagnum(&G__AliGeant3CintLN_AliNode);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliNode_AliNode_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+   AliNode *p=NULL;
+   switch(libp->paran) {
+   case 8:
+      p = new AliNode(
+(const char*)G__int(libp->para[0]),(const char*)G__int(libp->para[1])
+,(const char*)G__int(libp->para[2]),(Double_t)G__double(libp->para[3])
+,(Double_t)G__double(libp->para[4]),(Double_t)G__double(libp->para[5])
+,(const char*)G__int(libp->para[6]),(Option_t*)G__int(libp->para[7]));
+      break;
+   case 7:
+      p = new AliNode(
+(const char*)G__int(libp->para[0]),(const char*)G__int(libp->para[1])
+,(const char*)G__int(libp->para[2]),(Double_t)G__double(libp->para[3])
+,(Double_t)G__double(libp->para[4]),(Double_t)G__double(libp->para[5])
+,(const char*)G__int(libp->para[6]));
+      break;
+   case 6:
+      p = new AliNode(
+(const char*)G__int(libp->para[0]),(const char*)G__int(libp->para[1])
+,(const char*)G__int(libp->para[2]),(Double_t)G__double(libp->para[3])
+,(Double_t)G__double(libp->para[4]),(Double_t)G__double(libp->para[5]));
+      break;
+   case 5:
+      p = new AliNode(
+(const char*)G__int(libp->para[0]),(const char*)G__int(libp->para[1])
+,(const char*)G__int(libp->para[2]),(Double_t)G__double(libp->para[3])
+,(Double_t)G__double(libp->para[4]));
+      break;
+   case 4:
+      p = new AliNode(
+(const char*)G__int(libp->para[0]),(const char*)G__int(libp->para[1])
+,(const char*)G__int(libp->para[2]),(Double_t)G__double(libp->para[3]));
+      break;
+   case 3:
+      p = new AliNode(
+(const char*)G__int(libp->para[0]),(const char*)G__int(libp->para[1])
+,(const char*)G__int(libp->para[2]));
+      break;
+   }
+      result7->obj.i = (long)p;
+      result7->ref = (long)p;
+      result7->type = 'u';
+      result7->tagnum = G__get_linked_tagnum(&G__AliGeant3CintLN_AliNode);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliNode_AliNode_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+   AliNode *p=NULL;
+   switch(libp->paran) {
+   case 8:
+      p = new AliNode(
+(const char*)G__int(libp->para[0]),(const char*)G__int(libp->para[1])
+,(TShape*)G__int(libp->para[2]),(Double_t)G__double(libp->para[3])
+,(Double_t)G__double(libp->para[4]),(Double_t)G__double(libp->para[5])
+,(TRotMatrix*)G__int(libp->para[6]),(Option_t*)G__int(libp->para[7]));
+      break;
+   case 7:
+      p = new AliNode(
+(const char*)G__int(libp->para[0]),(const char*)G__int(libp->para[1])
+,(TShape*)G__int(libp->para[2]),(Double_t)G__double(libp->para[3])
+,(Double_t)G__double(libp->para[4]),(Double_t)G__double(libp->para[5])
+,(TRotMatrix*)G__int(libp->para[6]));
+      break;
+   case 6:
+      p = new AliNode(
+(const char*)G__int(libp->para[0]),(const char*)G__int(libp->para[1])
+,(TShape*)G__int(libp->para[2]),(Double_t)G__double(libp->para[3])
+,(Double_t)G__double(libp->para[4]),(Double_t)G__double(libp->para[5]));
+      break;
+   case 5:
+      p = new AliNode(
+(const char*)G__int(libp->para[0]),(const char*)G__int(libp->para[1])
+,(TShape*)G__int(libp->para[2]),(Double_t)G__double(libp->para[3])
+,(Double_t)G__double(libp->para[4]));
+      break;
+   case 4:
+      p = new AliNode(
+(const char*)G__int(libp->para[0]),(const char*)G__int(libp->para[1])
+,(TShape*)G__int(libp->para[2]),(Double_t)G__double(libp->para[3]));
+      break;
+   case 3:
+      p = new AliNode(
+(const char*)G__int(libp->para[0]),(const char*)G__int(libp->para[1])
+,(TShape*)G__int(libp->para[2]));
+      break;
+   }
+      result7->obj.i = (long)p;
+      result7->ref = (long)p;
+      result7->type = 'u';
+      result7->tagnum = G__get_linked_tagnum(&G__AliGeant3CintLN_AliNode);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliNode_AliNode_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+   AliNode *p=NULL;
+      p = new AliNode(*(AliNode*)libp->para[0].ref,(AliNode*)G__int(libp->para[1]));
+      result7->obj.i = (long)p;
+      result7->ref = (long)p;
+      result7->type = 'u';
+      result7->tagnum = G__get_linked_tagnum(&G__AliGeant3CintLN_AliNode);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliNode_SetDivision_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliNode*)(G__getstructoffset()))->SetDivision((Int_t)G__int(libp->para[0]),(Int_t)G__int(libp->para[1])
+,(Float_t)G__double(libp->para[2]),(Float_t)G__double(libp->para[3]));
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliNode_ExpandDivisions_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliNode*)(G__getstructoffset()))->ExpandDivisions();
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliNode_Axis_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,105,(long)((const AliNode*)(G__getstructoffset()))->Axis());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliNode_Ndiv_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,105,(long)((const AliNode*)(G__getstructoffset()))->Ndiv());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliNode_Step_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letdouble(result7,102,(double)((const AliNode*)(G__getstructoffset()))->Step());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliNode_StartC_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letdouble(result7,102,(double)((const AliNode*)(G__getstructoffset()))->StartC());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliNode_AddSons_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliNode*)(G__getstructoffset()))->AddSons((TList*)G__int(libp->para[0]));
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliNode_AddSon_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliNode*)(G__getstructoffset()))->AddSon((AliNode*)G__int(libp->para[0]));
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliNode_Class_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,85,(long)((AliNode*)(G__getstructoffset()))->Class());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliNode_Class_Name_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,67,(long)((AliNode*)(G__getstructoffset()))->Class_Name());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliNode_Class_Version_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,115,(long)((AliNode*)(G__getstructoffset()))->Class_Version());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliNode_Dictionary_7_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliNode*)(G__getstructoffset()))->Dictionary();
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliNode_IsA_8_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,85,(long)((const AliNode*)(G__getstructoffset()))->IsA());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliNode_ShowMembers_9_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliNode*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliNode_Streamer_0_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliNode*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliNode_StreamerNVirtual_1_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliNode*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliNode_DeclFileName_2_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,67,(long)((AliNode*)(G__getstructoffset()))->DeclFileName());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliNode_DeclFileLine_3_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,105,(long)((AliNode*)(G__getstructoffset()))->DeclFileLine());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliNode_ImplFileName_4_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,67,(long)((AliNode*)(G__getstructoffset()))->ImplFileName());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliNode_ImplFileLine_5_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,105,(long)((AliNode*)(G__getstructoffset()))->ImplFileLine());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+// automatic copy constructor
+static int G__AliNode_AliNode_6_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
+{
+   AliNode *p;
+   p=new AliNode(*(AliNode*)G__int(libp->para[0]));
+   result7->obj.i = (long)p;
+   result7->ref = (long)p;
+   result7->type = 'u';
+   result7->tagnum = G__get_linked_tagnum(&G__AliGeant3CintLN_AliNode);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+// automatic destructor
+typedef AliNode G__TAliNode;
+static int G__AliNode_wAAliNode_7_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+   if(0==G__getstructoffset()) return(1);
+   if(G__getaryconstruct())
+     if(G__PVOID==G__getgvp())
+       delete[] (AliNode *)(G__getstructoffset());
+     else
+       for(int i=G__getaryconstruct()-1;i>=0;i--)
+         delete (AliNode *)((G__getstructoffset())+sizeof(AliNode)*i);
+   else  delete (AliNode *)(G__getstructoffset());
+      G__setnull(result7);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+
+/* AliGuiGeomMain */
+static int G__AliGuiGeomMain_AliGuiGeomMain_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+   AliGuiGeomMain *p=NULL;
+      p = new AliGuiGeomMain(
+(const TGWindow*)G__int(libp->para[0]),(UInt_t)G__int(libp->para[1])
+,(UInt_t)G__int(libp->para[2]));
+      result7->obj.i = (long)p;
+      result7->ref = (long)p;
+      result7->type = 'u';
+      result7->tagnum = G__get_linked_tagnum(&G__AliGeant3CintLN_AliGuiGeomMain);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliGuiGeomMain_CloseWindow_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliGuiGeomMain*)(G__getstructoffset()))->CloseWindow();
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliGuiGeomMain_AddItem_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,85,(long)((AliGuiGeomMain*)(G__getstructoffset()))->AddItem((TObject*)G__int(libp->para[0]),(TGListTreeItem*)G__int(libp->para[1])
+,(const char*)G__int(libp->para[2]),(const TGPicture*)G__int(libp->para[3])
+,(const TGPicture*)G__int(libp->para[4])));
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliGuiGeomMain_AddMaterial_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliGuiGeomMain*)(G__getstructoffset()))->AddMaterial((AliG3Material*)G__int(libp->para[0]),(Int_t)G__int(libp->para[1]));
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliGuiGeomMain_AddMedium_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliGuiGeomMain*)(G__getstructoffset()))->AddMedium((AliG3Medium*)G__int(libp->para[0]),(Int_t)G__int(libp->para[1]));
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliGuiGeomMain_ProcessMessage_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,103,(long)((AliGuiGeomMain*)(G__getstructoffset()))->ProcessMessage((Long_t)G__int(libp->para[0]),(Long_t)G__int(libp->para[1])
+,(Long_t)G__int(libp->para[2])));
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliGuiGeomMain_Update_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliGuiGeomMain*)(G__getstructoffset()))->Update();
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliGuiGeomMain_UpdateCombo_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliGuiGeomMain*)(G__getstructoffset()))->UpdateCombo();
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliGuiGeomMain_UpdateListBox_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliGuiGeomMain*)(G__getstructoffset()))->UpdateListBox();
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliGuiGeomMain_SetMaterialComboEntries_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliGuiGeomMain*)(G__getstructoffset()))->SetMaterialComboEntries((TClonesArray*)G__int(libp->para[0]));
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliGuiGeomMain_SetMediaComboEntries_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliGuiGeomMain*)(G__getstructoffset()))->SetMediaComboEntries((TClonesArray*)G__int(libp->para[0]));
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliGuiGeomMain_AddFoldersRecursively_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+   switch(libp->paran) {
+   case 2:
+      G__setnull(result7);
+      ((AliGuiGeomMain*)(G__getstructoffset()))->AddFoldersRecursively((TFolder*)G__int(libp->para[0]),(TGListTreeItem*)G__int(libp->para[1]));
+      break;
+   case 1:
+      G__setnull(result7);
+      ((AliGuiGeomMain*)(G__getstructoffset()))->AddFoldersRecursively((TFolder*)G__int(libp->para[0]));
+      break;
+   case 0:
+      G__setnull(result7);
+      ((AliGuiGeomMain*)(G__getstructoffset()))->AddFoldersRecursively();
+      break;
+   }
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliGuiGeomMain_Plot_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliGuiGeomMain*)(G__getstructoffset()))->Plot();
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliGuiGeomMain_Class_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,85,(long)((AliGuiGeomMain*)(G__getstructoffset()))->Class());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliGuiGeomMain_Class_Name_7_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,67,(long)((AliGuiGeomMain*)(G__getstructoffset()))->Class_Name());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliGuiGeomMain_Class_Version_8_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,115,(long)((AliGuiGeomMain*)(G__getstructoffset()))->Class_Version());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliGuiGeomMain_Dictionary_9_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliGuiGeomMain*)(G__getstructoffset()))->Dictionary();
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliGuiGeomMain_IsA_0_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,85,(long)((const AliGuiGeomMain*)(G__getstructoffset()))->IsA());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliGuiGeomMain_ShowMembers_1_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliGuiGeomMain*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliGuiGeomMain_Streamer_2_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliGuiGeomMain*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliGuiGeomMain_StreamerNVirtual_3_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliGuiGeomMain*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliGuiGeomMain_DeclFileName_4_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,67,(long)((AliGuiGeomMain*)(G__getstructoffset()))->DeclFileName());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliGuiGeomMain_DeclFileLine_5_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,105,(long)((AliGuiGeomMain*)(G__getstructoffset()))->DeclFileLine());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliGuiGeomMain_ImplFileName_6_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,67,(long)((AliGuiGeomMain*)(G__getstructoffset()))->ImplFileName());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliGuiGeomMain_ImplFileLine_7_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,105,(long)((AliGuiGeomMain*)(G__getstructoffset()))->ImplFileLine());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+// automatic destructor
+typedef AliGuiGeomMain G__TAliGuiGeomMain;
+static int G__AliGuiGeomMain_wAAliGuiGeomMain_8_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+   if(0==G__getstructoffset()) return(1);
+   if(G__getaryconstruct())
+     if(G__PVOID==G__getgvp())
+       delete[] (AliGuiGeomMain *)(G__getstructoffset());
+     else
+       for(int i=G__getaryconstruct()-1;i>=0;i--)
+         delete (AliGuiGeomMain *)((G__getstructoffset())+sizeof(AliGuiGeomMain)*i);
+   else  delete (AliGuiGeomMain *)(G__getstructoffset());
+      G__setnull(result7);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+
+/* AliGeant3GeometryGUI */
+static int G__AliGeant3GeometryGUI_AliGeant3GeometryGUI_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+   AliGeant3GeometryGUI *p=NULL;
+   switch(libp->paran) {
+   case 1:
+      p = new AliGeant3GeometryGUI((const char*)G__int(libp->para[0]));
+      break;
+   case 0:
+   if(G__getaryconstruct()) p=new AliGeant3GeometryGUI[G__getaryconstruct()];
+   else                    p=new AliGeant3GeometryGUI;
+      break;
+   }
+      result7->obj.i = (long)p;
+      result7->ref = (long)p;
+      result7->type = 'u';
+      result7->tagnum = G__get_linked_tagnum(&G__AliGeant3CintLN_AliGeant3GeometryGUI);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliGeant3GeometryGUI_Class_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,85,(long)((AliGeant3GeometryGUI*)(G__getstructoffset()))->Class());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliGeant3GeometryGUI_Class_Name_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,67,(long)((AliGeant3GeometryGUI*)(G__getstructoffset()))->Class_Name());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliGeant3GeometryGUI_Class_Version_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,115,(long)((AliGeant3GeometryGUI*)(G__getstructoffset()))->Class_Version());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliGeant3GeometryGUI_Dictionary_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliGeant3GeometryGUI*)(G__getstructoffset()))->Dictionary();
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliGeant3GeometryGUI_IsA_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,85,(long)((const AliGeant3GeometryGUI*)(G__getstructoffset()))->IsA());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliGeant3GeometryGUI_ShowMembers_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliGeant3GeometryGUI*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliGeant3GeometryGUI_Streamer_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliGeant3GeometryGUI*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliGeant3GeometryGUI_StreamerNVirtual_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliGeant3GeometryGUI*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliGeant3GeometryGUI_DeclFileName_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,67,(long)((AliGeant3GeometryGUI*)(G__getstructoffset()))->DeclFileName());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliGeant3GeometryGUI_DeclFileLine_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,105,(long)((AliGeant3GeometryGUI*)(G__getstructoffset()))->DeclFileLine());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliGeant3GeometryGUI_ImplFileName_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,67,(long)((AliGeant3GeometryGUI*)(G__getstructoffset()))->ImplFileName());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliGeant3GeometryGUI_ImplFileLine_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,105,(long)((AliGeant3GeometryGUI*)(G__getstructoffset()))->ImplFileLine());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+// automatic destructor
+typedef AliGeant3GeometryGUI G__TAliGeant3GeometryGUI;
+static int G__AliGeant3GeometryGUI_wAAliGeant3GeometryGUI_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+   if(0==G__getstructoffset()) return(1);
+   if(G__getaryconstruct())
+     if(G__PVOID==G__getgvp())
+       delete[] (AliGeant3GeometryGUI *)(G__getstructoffset());
+     else
+       for(int i=G__getaryconstruct()-1;i>=0;i--)
+         delete (AliGeant3GeometryGUI *)((G__getstructoffset())+sizeof(AliGeant3GeometryGUI)*i);
+   else  delete (AliGeant3GeometryGUI *)(G__getstructoffset());
+      G__setnull(result7);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+
+/* AliG3toRoot */
+static int G__AliG3toRoot_AliG3toRoot_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+   AliG3toRoot *p=NULL;
+   if(G__getaryconstruct()) p=new AliG3toRoot[G__getaryconstruct()];
+   else                    p=new AliG3toRoot;
+      result7->obj.i = (long)p;
+      result7->ref = (long)p;
+      result7->type = 'u';
+      result7->tagnum = G__get_linked_tagnum(&G__AliGeant3CintLN_AliG3toRoot);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3toRoot_G3toRoot_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliG3toRoot*)(G__getstructoffset()))->G3toRoot();
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3toRoot_ConvertToRootShapes_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+   switch(libp->paran) {
+   case 3:
+      G__setnull(result7);
+      ((AliG3toRoot*)(G__getstructoffset()))->ConvertToRootShapes((TFolder*)G__int(libp->para[0]),(AliNode**)G__int(libp->para[1])
+,(Int_t)G__int(libp->para[2]));
+      break;
+   case 2:
+      G__setnull(result7);
+      ((AliG3toRoot*)(G__getstructoffset()))->ConvertToRootShapes((TFolder*)G__int(libp->para[0]),(AliNode**)G__int(libp->para[1]));
+      break;
+   case 1:
+      G__setnull(result7);
+      ((AliG3toRoot*)(G__getstructoffset()))->ConvertToRootShapes((TFolder*)G__int(libp->para[0]));
+      break;
+   case 0:
+      G__setnull(result7);
+      ((AliG3toRoot*)(G__getstructoffset()))->ConvertToRootShapes();
+      break;
+   }
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3toRoot_SetExpandDivisions_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+   switch(libp->paran) {
+   case 1:
+      G__setnull(result7);
+      ((AliG3toRoot*)(G__getstructoffset()))->SetExpandDivisions((Int_t)G__int(libp->para[0]));
+      break;
+   case 0:
+      G__setnull(result7);
+      ((AliG3toRoot*)(G__getstructoffset()))->SetExpandDivisions();
+      break;
+   }
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3toRoot_GetTopFolder_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,85,(long)((AliG3toRoot*)(G__getstructoffset()))->GetTopFolder());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3toRoot_GetMaterials_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,85,(long)((AliG3toRoot*)(G__getstructoffset()))->GetMaterials());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3toRoot_GetMedia_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,85,(long)((AliG3toRoot*)(G__getstructoffset()))->GetMedia());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3toRoot_Class_0_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,85,(long)((AliG3toRoot*)(G__getstructoffset()))->Class());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3toRoot_Class_Name_1_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,67,(long)((AliG3toRoot*)(G__getstructoffset()))->Class_Name());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3toRoot_Class_Version_2_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,115,(long)((AliG3toRoot*)(G__getstructoffset()))->Class_Version());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3toRoot_Dictionary_3_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliG3toRoot*)(G__getstructoffset()))->Dictionary();
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3toRoot_IsA_4_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,85,(long)((const AliG3toRoot*)(G__getstructoffset()))->IsA());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3toRoot_ShowMembers_5_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliG3toRoot*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3toRoot_Streamer_6_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliG3toRoot*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3toRoot_StreamerNVirtual_7_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliG3toRoot*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3toRoot_DeclFileName_8_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,67,(long)((AliG3toRoot*)(G__getstructoffset()))->DeclFileName());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3toRoot_DeclFileLine_9_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,105,(long)((AliG3toRoot*)(G__getstructoffset()))->DeclFileLine());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3toRoot_ImplFileName_0_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,67,(long)((AliG3toRoot*)(G__getstructoffset()))->ImplFileName());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliG3toRoot_ImplFileLine_1_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,105,(long)((AliG3toRoot*)(G__getstructoffset()))->ImplFileLine());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+// automatic copy constructor
+static int G__AliG3toRoot_AliG3toRoot_2_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
+{
+   AliG3toRoot *p;
+   p=new AliG3toRoot(*(AliG3toRoot*)G__int(libp->para[0]));
+   result7->obj.i = (long)p;
+   result7->ref = (long)p;
+   result7->type = 'u';
+   result7->tagnum = G__get_linked_tagnum(&G__AliGeant3CintLN_AliG3toRoot);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+// automatic destructor
+typedef AliG3toRoot G__TAliG3toRoot;
+static int G__AliG3toRoot_wAAliG3toRoot_3_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+   if(0==G__getstructoffset()) return(1);
+   if(G__getaryconstruct())
+     if(G__PVOID==G__getgvp())
+       delete[] (AliG3toRoot *)(G__getstructoffset());
+     else
+       for(int i=G__getaryconstruct()-1;i>=0;i--)
+         delete (AliG3toRoot *)((G__getstructoffset())+sizeof(AliG3toRoot)*i);
+   else  delete (AliG3toRoot *)(G__getstructoffset());
+      G__setnull(result7);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+
+/* Setting up global function */
+
+/*********************************************************
+* Member function Stub
+*********************************************************/
+
+/* AliG3Medium */
+
+/* AliG3Material */
+
+/* AliG3Volume */
+
+/* AliNode */
+
+/* AliGuiGeomMain */
+
+/* AliGeant3GeometryGUI */
+
+/* AliG3toRoot */
+
+/*********************************************************
+* Global function Stub
+*********************************************************/
+
+/*********************************************************
+* Get size of pointer to member function
+*********************************************************/
+class G__Sizep2memfuncAliGeant3Cint {
+ public:
+  G__Sizep2memfuncAliGeant3Cint() {p=&G__Sizep2memfuncAliGeant3Cint::sizep2memfunc;}
+    size_t sizep2memfunc() { return(sizeof(p)); }
+  private:
+    size_t (G__Sizep2memfuncAliGeant3Cint::*p)();
+};
+
+size_t G__get_sizep2memfuncAliGeant3Cint()
+{
+  G__Sizep2memfuncAliGeant3Cint a;
+  G__setsizep2memfunc((int)a.sizep2memfunc());
+  return((size_t)a.sizep2memfunc());
+}
+
+
+/*********************************************************
+* virtual base class offset calculation interface
+*********************************************************/
+
+   /* Setting up class inheritance */
+
+/*********************************************************
+* Inheritance information setup/
+*********************************************************/
+extern "C" void G__cpp_setup_inheritanceAliGeant3Cint() {
+
+   /* Setting up class inheritance */
+   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__AliGeant3CintLN_AliG3Medium))) {
+     AliG3Medium *G__Lderived;
+     G__Lderived=(AliG3Medium*)0x1000;
+     {
+       TNamed *G__Lpbase=(TNamed*)G__Lderived;
+       G__inheritance_setup(G__get_linked_tagnum(&G__AliGeant3CintLN_AliG3Medium),G__get_linked_tagnum(&G__AliGeant3CintLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
+     }
+     {
+       TObject *G__Lpbase=(TObject*)G__Lderived;
+       G__inheritance_setup(G__get_linked_tagnum(&G__AliGeant3CintLN_AliG3Medium),G__get_linked_tagnum(&G__AliGeant3CintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
+     }
+   }
+   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__AliGeant3CintLN_AliG3Material))) {
+     AliG3Material *G__Lderived;
+     G__Lderived=(AliG3Material*)0x1000;
+     {
+       TMaterial *G__Lpbase=(TMaterial*)G__Lderived;
+       G__inheritance_setup(G__get_linked_tagnum(&G__AliGeant3CintLN_AliG3Material),G__get_linked_tagnum(&G__AliGeant3CintLN_TMaterial),(long)G__Lpbase-(long)G__Lderived,1,1);
+     }
+     {
+       TNamed *G__Lpbase=(TNamed*)G__Lderived;
+       G__inheritance_setup(G__get_linked_tagnum(&G__AliGeant3CintLN_AliG3Material),G__get_linked_tagnum(&G__AliGeant3CintLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
+     }
+     {
+       TObject *G__Lpbase=(TObject*)G__Lderived;
+       G__inheritance_setup(G__get_linked_tagnum(&G__AliGeant3CintLN_AliG3Material),G__get_linked_tagnum(&G__AliGeant3CintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
+     }
+     {
+       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
+       G__inheritance_setup(G__get_linked_tagnum(&G__AliGeant3CintLN_AliG3Material),G__get_linked_tagnum(&G__AliGeant3CintLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
+     }
+   }
+   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__AliGeant3CintLN_AliG3Volume))) {
+     AliG3Volume *G__Lderived;
+     G__Lderived=(AliG3Volume*)0x1000;
+     {
+       TNamed *G__Lpbase=(TNamed*)G__Lderived;
+       G__inheritance_setup(G__get_linked_tagnum(&G__AliGeant3CintLN_AliG3Volume),G__get_linked_tagnum(&G__AliGeant3CintLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
+     }
+     {
+       TObject *G__Lpbase=(TObject*)G__Lderived;
+       G__inheritance_setup(G__get_linked_tagnum(&G__AliGeant3CintLN_AliG3Volume),G__get_linked_tagnum(&G__AliGeant3CintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
+     }
+   }
+   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__AliGeant3CintLN_AliNode))) {
+     AliNode *G__Lderived;
+     G__Lderived=(AliNode*)0x1000;
+     {
+       TNode *G__Lpbase=(TNode*)G__Lderived;
+       G__inheritance_setup(G__get_linked_tagnum(&G__AliGeant3CintLN_AliNode),G__get_linked_tagnum(&G__AliGeant3CintLN_TNode),(long)G__Lpbase-(long)G__Lderived,1,1);
+     }
+     {
+       TNamed *G__Lpbase=(TNamed*)G__Lderived;
+       G__inheritance_setup(G__get_linked_tagnum(&G__AliGeant3CintLN_AliNode),G__get_linked_tagnum(&G__AliGeant3CintLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
+     }
+     {
+       TObject *G__Lpbase=(TObject*)G__Lderived;
+       G__inheritance_setup(G__get_linked_tagnum(&G__AliGeant3CintLN_AliNode),G__get_linked_tagnum(&G__AliGeant3CintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
+     }
+     {
+       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
+       G__inheritance_setup(G__get_linked_tagnum(&G__AliGeant3CintLN_AliNode),G__get_linked_tagnum(&G__AliGeant3CintLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
+     }
+     {
+       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
+       G__inheritance_setup(G__get_linked_tagnum(&G__AliGeant3CintLN_AliNode),G__get_linked_tagnum(&G__AliGeant3CintLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
+     }
+     {
+       TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
+       G__inheritance_setup(G__get_linked_tagnum(&G__AliGeant3CintLN_AliNode),G__get_linked_tagnum(&G__AliGeant3CintLN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,0);
+     }
+   }
+   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__AliGeant3CintLN_AliGuiGeomMain))) {
+     AliGuiGeomMain *G__Lderived;
+     G__Lderived=(AliGuiGeomMain*)0x1000;
+     {
+       TGMainFrame *G__Lpbase=(TGMainFrame*)G__Lderived;
+       G__inheritance_setup(G__get_linked_tagnum(&G__AliGeant3CintLN_AliGuiGeomMain),G__get_linked_tagnum(&G__AliGeant3CintLN_TGMainFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
+     }
+     {
+       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
+       G__inheritance_setup(G__get_linked_tagnum(&G__AliGeant3CintLN_AliGuiGeomMain),G__get_linked_tagnum(&G__AliGeant3CintLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
+     }
+     {
+       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
+       G__inheritance_setup(G__get_linked_tagnum(&G__AliGeant3CintLN_AliGuiGeomMain),G__get_linked_tagnum(&G__AliGeant3CintLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
+     }
+     {
+       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
+       G__inheritance_setup(G__get_linked_tagnum(&G__AliGeant3CintLN_AliGuiGeomMain),G__get_linked_tagnum(&G__AliGeant3CintLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
+     }
+     {
+       TGObject *G__Lpbase=(TGObject*)G__Lderived;
+       G__inheritance_setup(G__get_linked_tagnum(&G__AliGeant3CintLN_AliGuiGeomMain),G__get_linked_tagnum(&G__AliGeant3CintLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
+     }
+     {
+       TObject *G__Lpbase=(TObject*)G__Lderived;
+       G__inheritance_setup(G__get_linked_tagnum(&G__AliGeant3CintLN_AliGuiGeomMain),G__get_linked_tagnum(&G__AliGeant3CintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
+     }
+     {
+       TQObject *G__Lpbase=(TQObject*)G__Lderived;
+       G__inheritance_setup(G__get_linked_tagnum(&G__AliGeant3CintLN_AliGuiGeomMain),G__get_linked_tagnum(&G__AliGeant3CintLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
+     }
+   }
+   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__AliGeant3CintLN_AliGeant3GeometryGUI))) {
+     AliGeant3GeometryGUI *G__Lderived;
+     G__Lderived=(AliGeant3GeometryGUI*)0x1000;
+     {
+       TObject *G__Lpbase=(TObject*)G__Lderived;
+       G__inheritance_setup(G__get_linked_tagnum(&G__AliGeant3CintLN_AliGeant3GeometryGUI),G__get_linked_tagnum(&G__AliGeant3CintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
+     }
+   }
+   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__AliGeant3CintLN_TNode))) {
+     TNode *G__Lderived;
+     G__Lderived=(TNode*)0x1000;
+     {
+       TNamed *G__Lpbase=(TNamed*)G__Lderived;
+       G__inheritance_setup(G__get_linked_tagnum(&G__AliGeant3CintLN_TNode),G__get_linked_tagnum(&G__AliGeant3CintLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
+     }
+     {
+       TObject *G__Lpbase=(TObject*)G__Lderived;
+       G__inheritance_setup(G__get_linked_tagnum(&G__AliGeant3CintLN_TNode),G__get_linked_tagnum(&G__AliGeant3CintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
+     }
+     {
+       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
+       G__inheritance_setup(G__get_linked_tagnum(&G__AliGeant3CintLN_TNode),G__get_linked_tagnum(&G__AliGeant3CintLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,1);
+     }
+     {
+       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
+       G__inheritance_setup(G__get_linked_tagnum(&G__AliGeant3CintLN_TNode),G__get_linked_tagnum(&G__AliGeant3CintLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,1);
+     }
+     {
+       TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
+       G__inheritance_setup(G__get_linked_tagnum(&G__AliGeant3CintLN_TNode),G__get_linked_tagnum(&G__AliGeant3CintLN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,1);
+     }
+   }
+   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__AliGeant3CintLN_AliG3toRoot))) {
+     AliG3toRoot *G__Lderived;
+     G__Lderived=(AliG3toRoot*)0x1000;
+     {
+       TObject *G__Lpbase=(TObject*)G__Lderived;
+       G__inheritance_setup(G__get_linked_tagnum(&G__AliGeant3CintLN_AliG3toRoot),G__get_linked_tagnum(&G__AliGeant3CintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
+     }
+   }
+}
+
+/*********************************************************
+* typedef information setup/
+*********************************************************/
+extern "C" void G__cpp_setup_typetableAliGeant3Cint() {
+
+   /* Setting up typedef entry */
+   G__search_typename2("Char_t",99,-1,0,
+-1);
+   G__setnewtype(-1,"Signed Character 1 byte (char)",0);
+   G__search_typename2("UChar_t",98,-1,0,
+-1);
+   G__setnewtype(-1,"Unsigned Character 1 byte (unsigned char)",0);
+   G__search_typename2("Short_t",115,-1,0,
+-1);
+   G__setnewtype(-1,"Signed Short integer 2 bytes (short)",0);
+   G__search_typename2("UShort_t",114,-1,0,
+-1);
+   G__setnewtype(-1,"Unsigned Short integer 2 bytes (unsigned short)",0);
+   G__search_typename2("Int_t",105,-1,0,
+-1);
+   G__setnewtype(-1,"Signed integer 4 bytes (int)",0);
+   G__search_typename2("UInt_t",104,-1,0,
+-1);
+   G__setnewtype(-1,"Unsigned integer 4 bytes (unsigned int)",0);
+   G__search_typename2("Seek_t",105,-1,0,
+-1);
+   G__setnewtype(-1,"File pointer (int)",0);
+   G__search_typename2("Long_t",108,-1,0,
+-1);
+   G__setnewtype(-1,"Signed long integer 4 bytes (long)",0);
+   G__search_typename2("ULong_t",107,-1,0,
+-1);
+   G__setnewtype(-1,"Unsigned long integer 4 bytes (unsigned long)",0);
+   G__search_typename2("Float_t",102,-1,0,
+-1);
+   G__setnewtype(-1,"Float 4 bytes (float)",0);
+   G__search_typename2("Double_t",100,-1,0,
+-1);
+   G__setnewtype(-1,"Float 8 bytes (double)",0);
+   G__search_typename2("Text_t",99,-1,0,
+-1);
+   G__setnewtype(-1,"General string (char)",0);
+   G__search_typename2("Bool_t",103,-1,0,
+-1);
+   G__setnewtype(-1,"Boolean (0=false, 1=true) (bool)",0);
+   G__search_typename2("Byte_t",98,-1,0,
+-1);
+   G__setnewtype(-1,"Byte (8 bits) (unsigned char)",0);
+   G__search_typename2("Version_t",115,-1,0,
+-1);
+   G__setnewtype(-1,"Class version identifier (short)",0);
+   G__search_typename2("Option_t",99,-1,0,
+-1);
+   G__setnewtype(-1,"Option string (const char)",0);
+   G__search_typename2("Ssiz_t",105,-1,0,
+-1);
+   G__setnewtype(-1,"String size (int)",0);
+   G__search_typename2("Real_t",102,-1,0,
+-1);
+   G__setnewtype(-1,"TVector and TMatrix element type (float)",0);
+   G__search_typename2("Streamer_t",89,-1,0,
+-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("VoidFuncPtr_t",89,-1,0,
+-1);
+   G__setnewtype(-1,"pointer to void function",0);
+   G__search_typename2("FreeHookFun_t",89,-1,0,
+-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("ReAllocFun_t",81,-1,0,
+-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("ReAllocCFun_t",81,-1,0,
+-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("Axis_t",100,-1,0,
+-1);
+   G__setnewtype(-1,"Axis values type (double)",0);
+   G__search_typename2("Stat_t",100,-1,0,
+-1);
+   G__setnewtype(-1,"Statistics type (double)",0);
+   G__search_typename2("Font_t",115,-1,0,
+-1);
+   G__setnewtype(-1,"Font number (short)",0);
+   G__search_typename2("Style_t",115,-1,0,
+-1);
+   G__setnewtype(-1,"Style number (short)",0);
+   G__search_typename2("Marker_t",115,-1,0,
+-1);
+   G__setnewtype(-1,"Marker number (short)",0);
+   G__search_typename2("Width_t",115,-1,0,
+-1);
+   G__setnewtype(-1,"Line width (short)",0);
+   G__search_typename2("Color_t",115,-1,0,
+-1);
+   G__setnewtype(-1,"Color number (short)",0);
+   G__search_typename2("SCoord_t",115,-1,0,
+-1);
+   G__setnewtype(-1,"Screen coordinates (short)",0);
+   G__search_typename2("Coord_t",100,-1,0,
+-1);
+   G__setnewtype(-1,"Pad world coordinates (double)",0);
+   G__search_typename2("Angle_t",102,-1,0,
+-1);
+   G__setnewtype(-1,"Graphics angle (float)",0);
+   G__search_typename2("Size_t",102,-1,0,
+-1);
+   G__setnewtype(-1,"Attribute size (float)",0);
+   G__search_typename2("Handle_t",107,-1,0,
+-1);
+   G__setnewtype(-1,"Generic resource handle",0);
+   G__search_typename2("Display_t",107,-1,0,
+-1);
+   G__setnewtype(-1,"Display handle",0);
+   G__search_typename2("Visual_t",107,-1,0,
+-1);
+   G__setnewtype(-1,"Visual handle",0);
+   G__search_typename2("Window_t",107,-1,0,
+-1);
+   G__setnewtype(-1,"Window handle",0);
+   G__search_typename2("Pixmap_t",107,-1,0,
+-1);
+   G__setnewtype(-1,"Pixmap handle",0);
+   G__search_typename2("Drawable_t",107,-1,0,
+-1);
+   G__setnewtype(-1,"Drawable handle",0);
+   G__search_typename2("Region_t",107,-1,0,
+-1);
+   G__setnewtype(-1,"Region handle",0);
+   G__search_typename2("Colormap_t",107,-1,0,
+-1);
+   G__setnewtype(-1,"Colormap handle",0);
+   G__search_typename2("Cursor_t",107,-1,0,
+-1);
+   G__setnewtype(-1,"Cursor handle",0);
+   G__search_typename2("FontH_t",107,-1,0,
+-1);
+   G__setnewtype(-1,"Font handle (as opposed to Font_t which is an index)",0);
+   G__search_typename2("KeySym_t",107,-1,0,
+-1);
+   G__setnewtype(-1,"Key symbol handle",0);
+   G__search_typename2("Atom_t",107,-1,0,
+-1);
+   G__setnewtype(-1,"WM token",0);
+   G__search_typename2("GContext_t",107,-1,0,
+-1);
+   G__setnewtype(-1,"Graphics context handle",0);
+   G__search_typename2("FontStruct_t",107,-1,0,
+-1);
+   G__setnewtype(-1,"Pointer to font structure",0);
+   G__search_typename2("Mask_t",104,-1,0,
+-1);
+   G__setnewtype(-1,"Structure mask type",0);
+   G__search_typename2("Time_t",107,-1,0,
+-1);
+   G__setnewtype(-1,"Event time",0);
+   G__search_typename2("Int_t (*)(const char*xact, Int_t nb, void**ar, Int_t*iret)",81,-1,0,
+-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("Decay_t",117,G__get_linked_tagnum(&G__AliGeant3CintLN_Decay_t),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("Quest_t",117,G__get_linked_tagnum(&G__AliGeant3CintLN_Quest_t),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("Gcbank_t",117,G__get_linked_tagnum(&G__AliGeant3CintLN_Gcbank_t),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("Gclink_t",117,G__get_linked_tagnum(&G__AliGeant3CintLN_Gclink_t),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("Gcflag_t",117,G__get_linked_tagnum(&G__AliGeant3CintLN_Gcflag_t),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("Gckine_t",117,G__get_linked_tagnum(&G__AliGeant3CintLN_Gckine_t),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("Gcking_t",117,G__get_linked_tagnum(&G__AliGeant3CintLN_Gcking_t),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("Gckin2_t",117,G__get_linked_tagnum(&G__AliGeant3CintLN_Gckin2_t),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("Gckin3_t",117,G__get_linked_tagnum(&G__AliGeant3CintLN_Gckin3_t),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("Gcmate_t",117,G__get_linked_tagnum(&G__AliGeant3CintLN_Gcmate_t),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("Gctmed_t",117,G__get_linked_tagnum(&G__AliGeant3CintLN_Gctmed_t),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("Gctrak_t",117,G__get_linked_tagnum(&G__AliGeant3CintLN_Gctrak_t),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("Gcvolu_t",117,G__get_linked_tagnum(&G__AliGeant3CintLN_Gcvolu_t),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("Gcsets_t",117,G__get_linked_tagnum(&G__AliGeant3CintLN_Gcsets_t),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("Gcnum_t",117,G__get_linked_tagnum(&G__AliGeant3CintLN_Gcnum_t),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("Gccuts_t",117,G__get_linked_tagnum(&G__AliGeant3CintLN_Gccuts_t),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("Gcmulo_t",117,G__get_linked_tagnum(&G__AliGeant3CintLN_Gcmulo_t),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("Gcphys_t",117,G__get_linked_tagnum(&G__AliGeant3CintLN_Gcphys_t),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("Gcphlt_t",117,G__get_linked_tagnum(&G__AliGeant3CintLN_Gcphlt_t),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("Gcopti_t",117,G__get_linked_tagnum(&G__AliGeant3CintLN_Gcopti_t),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("Gctlit_t",117,G__get_linked_tagnum(&G__AliGeant3CintLN_Gctlit_t),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("Gcvdma_t",117,G__get_linked_tagnum(&G__AliGeant3CintLN_Gcvdma_t),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("Gctpol_t",117,G__get_linked_tagnum(&G__AliGeant3CintLN_Gctpol_t),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("Ertrio_t",117,G__get_linked_tagnum(&G__AliGeant3CintLN_Ertrio_t),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("Eropts_t",117,G__get_linked_tagnum(&G__AliGeant3CintLN_Eropts_t),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("Eroptc_t",117,G__get_linked_tagnum(&G__AliGeant3CintLN_Eroptc_t),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("Erwork_t",117,G__get_linked_tagnum(&G__AliGeant3CintLN_Erwork_t),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("X3DBuffer",117,G__get_linked_tagnum(&G__AliGeant3CintLN__x3d_data_),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("Size3D",117,G__get_linked_tagnum(&G__AliGeant3CintLN__x3d_sizeof_),0,-1);
+   G__setnewtype(-1,NULL,0);
+}
+
+/*********************************************************
+* Data Member information setup/
+*********************************************************/
+
+   /* Setting up class,struct,union tag member variable */
+
+   /* AliG3Medium */
+static void G__setup_memvarAliG3Medium(void) {
+   G__tag_memvar_setup(G__get_linked_tagnum(&G__AliGeant3CintLN_AliG3Medium));
+   { AliG3Medium *p; p=(AliG3Medium*)0x1000; if (p) { }
+   G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fPars[33]=",0,"special medium parameters");
+   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fId=",0,"Id number of the Medium");
+   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fIdMat=",0,"Associated material");
+   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fIsvol=",0,"Sensitivity flag ");
+   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fIfield=",0,"Magnetic Field Flag");
+   G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fFieldm=",0,"Maximum Field Strength");
+   G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fTmaxfd=",0,"Max. Ang. Deviation");
+   G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fStemax=",0,"Maximum Step   ");
+   G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fDeemax=",0,"Max. Frac. Energy Loss\",");
+   G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fEpsil=",0,"Crossing Precission ");
+   G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fStmin=",0,"Minimum Step Size");
+   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fItem=",0,"Link to Widget Entry");
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
+   }
+   G__tag_memvar_reset();
+}
+
+
+   /* AliG3Material */
+static void G__setup_memvarAliG3Material(void) {
+   G__tag_memvar_setup(G__get_linked_tagnum(&G__AliGeant3CintLN_AliG3Material));
+   { AliG3Material *p; p=(AliG3Material*)0x1000; if (p) { }
+   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fId=",0,"Id number of the material");
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
+   }
+   G__tag_memvar_reset();
+}
+
+
+   /* AliG3Volume */
+static void G__setup_memvarAliG3Volume(void) {
+   G__tag_memvar_setup(G__get_linked_tagnum(&G__AliGeant3CintLN_AliG3Volume));
+   { AliG3Volume *p; p=(AliG3Volume*)0x1000; if (p) { }
+   G__memvar_setup((void*)NULL,117,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TArrayF),-1,-1,4,"fPosition=",0,"position with respect to mother volume");
+   G__memvar_setup((void*)NULL,117,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TArrayF),-1,-1,4,"fParameters=",0,"volume parameters");
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TList),-1,-1,4,"fCopies=",0,"volume copies");
+   G__memvar_setup((void*)NULL,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fPosp=",0,"flag for G3 POSP");
+   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNCopies=",0,"number of copies");
+   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fRotMatrix=",0,"rotation with respect to mother volume");
+   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNParam=",0,"number of volume parameters");
+   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fAxis=",0,"division axis");
+   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNdiv=",0,"number of divisions");
+   G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fStep=",0,"number of steps");
+   G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fStartC=",0,"start coordinate");
+   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fShape=",0,"G3 volume shape");
+   G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fTheta=",0,"theta-angle for drawing");
+   G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fPhi=",0,"phi-angle   for drawing");
+   G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fPsi=",0,"psi-angle   for drawing ");
+   G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fU=",0,"u-position");
+   G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fV=",0,"v-position");
+   G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fUscale=",0,"u-scaling factor");
+   G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fVscale=",0,"v-scaling factor");
+   G__memvar_setup((void*)NULL,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fHide=",0,"hide flag");
+   G__memvar_setup((void*)NULL,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fShadow=",0,"shadow flag");
+   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fFill=",0,"fill option 1-6");
+   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fSeen=",0,"seen option -2 - 1");
+   G__memvar_setup((void*)NULL,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fClip=",0,"clipping flag");
+   G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fClipXmin=",0,"clip box range xmin");
+   G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fClipXmax=",0,"clip box range xmax");
+   G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fClipYmin=",0,"clip box range ymin");
+   G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fClipYmax=",0,"clip box range ymax");
+   G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fClipZmin=",0,"clip box range zmin");
+   G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fClipZmax=",0,"clip box range zmax");
+   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fIdVolume=",0,"geant volume id");
+   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fIdMedium=",0,"geant medium id");
+   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fIdMaterial=",0,"geant material id    ");
+   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fIdCopy=",0,"copy flag");
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TObject),-1,-1,4,"fItem=",0,"!current item");
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
+   }
+   G__tag_memvar_reset();
+}
+
+
+   /* AliNode */
+static void G__setup_memvarAliNode(void) {
+   G__tag_memvar_setup(G__get_linked_tagnum(&G__AliGeant3CintLN_AliNode));
+   { AliNode *p; p=(AliNode*)0x1000; if (p) { }
+   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fAxis=",0,"division axis");
+   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNDivision=",0,"number of divisions");
+   G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fStep=",0,"number of steps");
+   G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fStartC=",0,"start coordinate");
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
+   }
+   G__tag_memvar_reset();
+}
+
+
+   /* AliGuiGeomMain */
+static void G__setup_memvarAliGuiGeomMain(void) {
+   G__tag_memvar_setup(G__get_linked_tagnum(&G__AliGeant3CintLN_AliGuiGeomMain));
+   { AliGuiGeomMain *p; p=(AliGuiGeomMain*)0x1000; if (p) { }
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TGTab),-1,-1,4,"fTab=",0,"Contains Tab entries: volumes, materials..");
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TGCanvas),-1,-1,4,"fCanvasWindow=",0,"Canvas window for list tree");
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TGCompositeFrame),-1,-1,4,"fF2=",0,(char*)NULL);
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TGCompositeFrame),-1,-1,4,"fF21=",0,(char*)NULL);
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TGCompositeFrame),-1,-1,4,"fF3=",0,(char*)NULL);
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TGCompositeFrame),-1,-1,4,"fF31=",0,(char*)NULL);
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TGCompositeFrame),-1,-1,4,"fF4=",0,(char*)NULL);
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TGCompositeFrame),-1,-1,4,"fF5=",0,"Frames for combos");
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TGCompositeFrame),-1,-1,4,"fF6=",0,(char*)NULL);
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TGCompositeFrame),-1,-1,4,"fF61=",0,(char*)NULL);
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TGCompositeFrame),-1,-1,4,"fF62=",0,(char*)NULL);
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TGCompositeFrame),-1,-1,4,"fF63=",0,"Frames for combos");
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TGListTree),-1,-1,4,"fLt=",0,"Volumes list tree");
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TGMenuBar),-1,-1,4,"fMenuBar=",0,"Menu bar: File, Draw Control ...");
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TGPopupMenu),-1,-1,4,"fMenuFile=",0,(char*)NULL);
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TGPopupMenu),-1,-1,4,"fMenuTest=",0,(char*)NULL);
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TGPopupMenu),-1,-1,4,"fMenuHelp=",0,"Pop-up menus");
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TGLayoutHints),-1,-1,4,"fMenuBarItemLayout=",0,(char*)NULL);
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TGLayoutHints),-1,-1,4,"fMenuBarHelpLayout=",0,(char*)NULL);
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TGLayoutHints),-1,-1,4,"fMenuBarLayout=",0,(char*)NULL);
+   G__memvar_setup((void*)NULL,117,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TGLayoutHints),-1,-1,4,"fLTab=",0,"Lay-out hints");
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TGLayoutHints),-1,-1,4,"fL2=",0,"Lay-out hints");
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_AliGuiGeomDialog),-1,-1,4,"fDialog=",0,"! no output please");
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TGComboBox),-1,-1,4,"fMaterialCombo=",0,"Material  combo box");
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TGComboBox),-1,-1,4,"fMechanismCombo=",0,"Mechanism combo box");
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TGComboBox),-1,-1,4,"fMediaCombo=",0,(char*)NULL);
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TGComboBox),-1,-1,4,"fParticleCombo=",0,"Media and particle combo boxes");
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TGListBox),-1,-1,4,"fProcessLB=",0,(char*)NULL);
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TGListBox),-1,-1,4,"fCutsLB=",0,"List boxes for cuts and processes");
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TClonesArray),-1,-1,4,"fComboMaterialEntries=",0,"List of materials");
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TClonesArray),-1,-1,4,"fComboMediaEntries=",0,"List of media");
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TGHorizontalFrame),-1,-1,4,"fHframe[6]=",0,(char*)NULL);
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TGHorizontalFrame),-1,-1,4,"fHframeM[8]=",0,"sub frames ");
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TGTextBuffer),-1,-1,4,"fTbh[6]=",0,(char*)NULL);
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TGTextBuffer),-1,-1,4,"fTbhM[8]=",0,(char*)NULL);
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TGTextBuffer),-1,-1,4,"fTbh61=",0,(char*)NULL);
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TGTextBuffer),-1,-1,4,"fTbh62=",0,(char*)NULL);
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TGTextBuffer),-1,-1,4,"fTbh63=",0,"text frames");
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TGTextEntry),-1,-1,4,"fTeh[6]=",0,(char*)NULL);
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TGTextEntry),-1,-1,4,"fTehM[8]=",0,(char*)NULL);
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TGTextEntry),-1,-1,4,"fTeh61=",0,(char*)NULL);
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TGTextEntry),-1,-1,4,"fTeh62=",0,(char*)NULL);
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TGTextEntry),-1,-1,4,"fTeh63=",0,"text entries");
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TGLabel),-1,-1,4,"fLabel[6]=",0,(char*)NULL);
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TGLabel),-1,-1,4,"fLabelM[8]=",0,(char*)NULL);
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TGLabel),-1,-1,4,"fSLabel61=",0,"labels");
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TGTextButton),-1,-1,4,"fPlotButton=",0,"Plot-Button");
+   G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fEmin=",0,"minimum energy for de/dx plot");
+   G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fEmax=",0,"maximum energy for de/dx plot");
+   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNbins=",0,"number of bins for de/dx plot");
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
+   }
+   G__tag_memvar_reset();
+}
+
+
+   /* AliGeant3GeometryGUI */
+static void G__setup_memvarAliGeant3GeometryGUI(void) {
+   G__tag_memvar_setup(G__get_linked_tagnum(&G__AliGeant3CintLN_AliGeant3GeometryGUI));
+   { AliGeant3GeometryGUI *p; p=(AliGeant3GeometryGUI*)0x1000; if (p) { }
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_AliGuiGeomMain),-1,-1,4,"fPanel=",0,"the main gui panel");
+   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNstack=",0,"number of volumes");
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TClonesArray),-1,-1,4,"fVolumes=",0,"array of volumes  ");
+   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNMaterials=",0,"number of materials and media");
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TClonesArray),-1,-1,4,"fMaterials=",0,"array of materials");
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TClonesArray),-1,-1,4,"fMedia=",0,"array of materials");
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TObjArray),-1,-1,4,"fRotations=",0,"Rotation Matrices");
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
+   }
+   G__tag_memvar_reset();
+}
+
+
+   /* AliG3toRoot */
+static void G__setup_memvarAliG3toRoot(void) {
+   G__tag_memvar_setup(G__get_linked_tagnum(&G__AliGeant3CintLN_AliG3toRoot));
+   { AliG3toRoot *p; p=(AliG3toRoot*)0x1000; if (p) { }
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TClonesArray),-1,-1,4,"fVolumes=",0,"! array of volumes  ");
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TClonesArray),-1,-1,4,"fMaterials=",0,"! array of materials");
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TClonesArray),-1,-1,4,"fMedia=",0,"! array of materials");
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TObjArray),-1,-1,4,"fRotations=",0,"! Rotation Matrices");
+   G__memvar_setup((void*)NULL,73,0,0,-1,G__defined_typename("Int_t"),-1,4,"fZlq=",0,"! pointer to Zebra bank lq");
+   G__memvar_setup((void*)NULL,70,0,0,-1,G__defined_typename("Float_t"),-1,4,"fZq=",0,"! pointer to Zebra bank q");
+   G__memvar_setup((void*)NULL,73,0,0,-1,G__defined_typename("Int_t"),-1,4,"fZiq=",0,"! pointer to Zebra bank iq");
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_Gclink_t),G__defined_typename("Gclink_t"),-1,4,"fGclink=",0,"! pointer to Geant common block ");
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_Gcnum_t),G__defined_typename("Gcnum_t"),-1,4,"fGcnum=",0,"! pointer to Geant common block");
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TFolder),-1,-1,4,"fTopFolder=",0,"! Folder structure containing volumes");
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TGeometry),-1,-1,4,"fGeometry=",0,"Pointer to geometry");
+   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fExpand=",0,"Flag for division expansion");
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__AliGeant3CintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
+   }
+   G__tag_memvar_reset();
+}
+
+extern "C" void G__cpp_setup_memvarAliGeant3Cint() {
+}
+/***********************************************************
+************************************************************
+************************************************************
+************************************************************
+************************************************************
+************************************************************
+************************************************************
+***********************************************************/
+
+/*********************************************************
+* Member function information setup for each class
+*********************************************************/
+static void G__setup_memfuncAliG3Medium(void) {
+   /* AliG3Medium */
+   G__tag_memfunc_setup(G__get_linked_tagnum(&G__AliGeant3CintLN_AliG3Medium));
+   G__memfunc_setup("AliG3Medium",1009,G__AliG3Medium_AliG3Medium_0_0,105,G__get_linked_tagnum(&G__AliGeant3CintLN_AliG3Medium),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("AliG3Medium",1009,G__AliG3Medium_AliG3Medium_1_0,105,G__get_linked_tagnum(&G__AliGeant3CintLN_AliG3Medium),-1,0,11,1,1,0,
+"i - 'Int_t' 0 - imed i - 'Int_t' 0 - imat "
+"C - - 10 - name i - 'Int_t' 0 - isvol "
+"i - 'Int_t' 0 - ifield f - 'Float_t' 0 - fieldm "
+"f - 'Float_t' 0 - tmaxfd f - 'Float_t' 0 - stemax "
+"f - 'Float_t' 0 - deemax f - 'Float_t' 0 - epsil "
+"f - 'Float_t' 0 - stmin",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("Dump",406,G__AliG3Medium_Dump_3_0,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("Id",173,G__AliG3Medium_Id_4_0,105,-1,G__defined_typename("Int_t"),0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("IdMat",463,G__AliG3Medium_IdMat_5_0,105,-1,G__defined_typename("Int_t"),0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("Isvol",525,G__AliG3Medium_Isvol_6_0,105,-1,G__defined_typename("Int_t"),0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("Ifield",589,G__AliG3Medium_Ifield_7_0,105,-1,G__defined_typename("Int_t"),0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("Fieldm",593,G__AliG3Medium_Fieldm_8_0,102,-1,G__defined_typename("Float_t"),0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("Tmaxfd",612,G__AliG3Medium_Tmaxfd_9_0,102,-1,G__defined_typename("Float_t"),0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("Stemax",626,G__AliG3Medium_Stemax_0_1,102,-1,G__defined_typename("Float_t"),0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("Deemax",596,G__AliG3Medium_Deemax_1_1,102,-1,G__defined_typename("Float_t"),0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("Epsil",509,G__AliG3Medium_Epsil_2_1,102,-1,G__defined_typename("Float_t"),0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("Stmin",523,G__AliG3Medium_Stmin_3_1,102,-1,G__defined_typename("Float_t"),0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("SetPar",591,G__AliG3Medium_SetPar_4_1,121,-1,-1,0,2,1,1,0,
+"i - 'Int_t' 0 - ipar f - 'Float_t' 0 - par",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("GetPar",579,G__AliG3Medium_GetPar_5_1,102,-1,G__defined_typename("Float_t"),0,1,1,1,0,"i - 'Int_t' 0 - ipar",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("ItemId",572,G__AliG3Medium_ItemId_6_1,105,-1,G__defined_typename("Int_t"),0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("SetItemId",872,G__AliG3Medium_SetItemId_7_1,121,-1,-1,0,1,1,1,0,"i - 'Int_t' 0 - id",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("AliG3Medium",1009,(G__InterfaceMethod)NULL,105,G__get_linked_tagnum(&G__AliGeant3CintLN_AliG3Medium),-1,0,1,1,4,0,"u 'AliG3Medium' - 11 - -",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("operator=",937,(G__InterfaceMethod)NULL,117,G__get_linked_tagnum(&G__AliGeant3CintLN_AliG3Medium),-1,1,1,1,4,0,"u 'AliG3Medium' - 11 - -",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("Class",502,G__AliG3Medium_Class_0_2,85,G__get_linked_tagnum(&G__AliGeant3CintLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("Class_Name",982,G__AliG3Medium_Class_Name_1_2,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("Class_Version",1339,G__AliG3Medium_Class_Version_2_2,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("Dictionary",1046,G__AliG3Medium_Dictionary_3_2,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("IsA",253,G__AliG3Medium_IsA_4_2,85,G__get_linked_tagnum(&G__AliGeant3CintLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("ShowMembers",1132,G__AliG3Medium_ShowMembers_5_2,121,-1,-1,0,2,1,1,0,
+"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("Streamer",835,G__AliG3Medium_Streamer_6_2,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("StreamerNVirtual",1656,G__AliG3Medium_StreamerNVirtual_7_2,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("DeclFileName",1145,G__AliG3Medium_DeclFileName_8_2,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("DeclFileLine",1152,G__AliG3Medium_DeclFileLine_9_2,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("ImplFileName",1171,G__AliG3Medium_ImplFileName_0_3,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("ImplFileLine",1178,G__AliG3Medium_ImplFileLine_1_3,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
+   // automatic destructor
+   G__memfunc_setup("~AliG3Medium",1135,G__AliG3Medium_wAAliG3Medium_2_3,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
+   G__tag_memfunc_reset();
+}
+
+static void G__setup_memfuncAliG3Material(void) {
+   /* AliG3Material */
+   G__tag_memfunc_setup(G__get_linked_tagnum(&G__AliGeant3CintLN_AliG3Material));
+   G__memfunc_setup("AliG3Material",1215,G__AliG3Material_AliG3Material_0_0,105,G__get_linked_tagnum(&G__AliGeant3CintLN_AliG3Material),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("AliG3Material",1215,G__AliG3Material_AliG3Material_1_0,105,G__get_linked_tagnum(&G__AliGeant3CintLN_AliG3Material),-1,0,7,1,1,0,
+"C - - 0 - name C - - 0 - title "
+"f - 'Float_t' 0 - a f - 'Float_t' 0 - z "
+"f - 'Float_t' 0 - dens f - 'Float_t' 0 - radl "
+"f - 'Float_t' 0 - intl",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("Dump",406,G__AliG3Material_Dump_3_0,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("Id",173,G__AliG3Material_Id_4_0,105,-1,G__defined_typename("Int_t"),0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("SetId",473,G__AliG3Material_SetId_5_0,121,-1,-1,0,1,1,1,0,"i - 'Int_t' 0 - id",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("AliG3Material",1215,(G__InterfaceMethod)NULL,105,G__get_linked_tagnum(&G__AliGeant3CintLN_AliG3Material),-1,0,1,1,4,0,"u 'AliG3Material' - 11 - -",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("operator=",937,(G__InterfaceMethod)NULL,117,G__get_linked_tagnum(&G__AliGeant3CintLN_AliG3Material),-1,1,1,1,4,0,"u 'AliG3Material' - 11 - -",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("Class",502,G__AliG3Material_Class_8_0,85,G__get_linked_tagnum(&G__AliGeant3CintLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("Class_Name",982,G__AliG3Material_Class_Name_9_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("Class_Version",1339,G__AliG3Material_Class_Version_0_1,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("Dictionary",1046,G__AliG3Material_Dictionary_1_1,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("IsA",253,G__AliG3Material_IsA_2_1,85,G__get_linked_tagnum(&G__AliGeant3CintLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("ShowMembers",1132,G__AliG3Material_ShowMembers_3_1,121,-1,-1,0,2,1,1,0,
+"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("Streamer",835,G__AliG3Material_Streamer_4_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("StreamerNVirtual",1656,G__AliG3Material_StreamerNVirtual_5_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("DeclFileName",1145,G__AliG3Material_DeclFileName_6_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("DeclFileLine",1152,G__AliG3Material_DeclFileLine_7_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("ImplFileName",1171,G__AliG3Material_ImplFileName_8_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("ImplFileLine",1178,G__AliG3Material_ImplFileLine_9_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
+   // automatic destructor
+   G__memfunc_setup("~AliG3Material",1341,G__AliG3Material_wAAliG3Material_0_2,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
+   G__tag_memfunc_reset();
+}
+
+static void G__setup_memfuncAliG3Volume(void) {
+   /* AliG3Volume */
+   G__tag_memfunc_setup(G__get_linked_tagnum(&G__AliGeant3CintLN_AliG3Volume));
+   G__memfunc_setup("AliG3Volume",1032,G__AliG3Volume_AliG3Volume_0_0,105,G__get_linked_tagnum(&G__AliGeant3CintLN_AliG3Volume),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("AliG3Volume",1032,G__AliG3Volume_AliG3Volume_1_0,105,G__get_linked_tagnum(&G__AliGeant3CintLN_AliG3Volume),-1,0,1,1,1,0,"C - - 10 - name",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("Draw",398,G__AliG3Volume_Draw_3_0,121,-1,-1,0,1,1,1,0,"C - 'Option_t' 0 0 option",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("DrawSpec",793,G__AliG3Volume_DrawSpec_4_0,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("SetParam",797,G__AliG3Volume_SetParam_5_0,121,-1,-1,0,2,1,1,0,
+"i - 'Int_t' 0 - i f - 'Float_t' 0 - param",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("GetParam",785,G__AliG3Volume_GetParam_6_0,102,-1,G__defined_typename("Float_t"),0,1,1,1,0,"i - 'Int_t' 0 - i",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("SetIdVolume",1105,G__AliG3Volume_SetIdVolume_7_0,121,-1,-1,0,1,1,1,0,"i - 'Int_t' 0 - id",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("SetIdCopy",884,G__AliG3Volume_SetIdCopy_8_0,121,-1,-1,0,1,1,1,0,"i - 'Int_t' 0 - id",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("SetIdMedium",1082,G__AliG3Volume_SetIdMedium_9_0,121,-1,-1,0,1,1,1,0,"i - 'Int_t' 0 - id",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("SetIdMaterial",1288,G__AliG3Volume_SetIdMaterial_0_1,121,-1,-1,0,1,1,1,0,"i - 'Int_t' 0 - id",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("GetIdVolume",1093,G__AliG3Volume_GetIdVolume_1_1,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("GetIdCopy",872,G__AliG3Volume_GetIdCopy_2_1,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("Medium",609,G__AliG3Volume_Medium_3_1,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("Material",815,G__AliG3Volume_Material_4_1,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("AddCopy",676,G__AliG3Volume_AddCopy_5_1,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("SetItem",699,G__AliG3Volume_SetItem_6_1,121,-1,-1,0,1,1,1,0,"U 'TObject' - 0 - item",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("SetPosition",1153,G__AliG3Volume_SetPosition_7_1,121,-1,-1,0,3,1,1,0,
+"f - 'Float_t' 0 - x f - 'Float_t' 0 - y "
+"f - 'Float_t' 0 - z",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("Position",853,G__AliG3Volume_Position_8_1,117,G__get_linked_tagnum(&G__AliGeant3CintLN_TArrayF),-1,0,1,1,1,8,"i - 'Int_t' 0 - i",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("SetRotMatrix",1238,G__AliG3Volume_SetRotMatrix_9_1,121,-1,-1,0,1,1,1,0,"i - 'Int_t' 0 - irot",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("RotMatrix",938,G__AliG3Volume_RotMatrix_0_2,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("SetShape",797,G__AliG3Volume_SetShape_1_2,121,-1,-1,0,1,1,1,0,"i - 'Int_t' 0 - shape",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("Shape",497,G__AliG3Volume_Shape_2_2,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("SetParameters",1344,G__AliG3Volume_SetParameters_3_2,121,-1,-1,0,2,1,1,0,
+"i - 'Int_t' 0 - np F - 'Float_t' 0 - param",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("NParam",575,G__AliG3Volume_NParam_4_2,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("Parameters",1044,G__AliG3Volume_Parameters_5_2,121,-1,-1,0,2,1,1,8,
+"i - 'Int_t' 0 - i u 'TArrayF' - 1 - param",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("Copies",611,G__AliG3Volume_Copies_6_2,85,G__get_linked_tagnum(&G__AliGeant3CintLN_TList),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("AddCopy",676,G__AliG3Volume_AddCopy_7_2,121,-1,-1,0,1,1,1,0,"U 'AliG3Volume' - 0 - volume",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("Copy",411,G__AliG3Volume_Copy_8_2,85,G__get_linked_tagnum(&G__AliGeant3CintLN_AliG3Volume),-1,0,1,1,1,0,"i - 'Int_t' 0 - i",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("NCopies",689,G__AliG3Volume_NCopies_9_2,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("Posp",418,G__AliG3Volume_Posp_0_3,103,-1,G__defined_typename("Bool_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("SetPosp",718,G__AliG3Volume_SetPosp_1_3,121,-1,-1,0,1,1,1,0,"g - 'Bool_t' 0 - flag",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("CreateTShape",1177,G__AliG3Volume_CreateTShape_2_3,121,-1,-1,0,2,1,1,0,
+"C - - 0 - nameV U 'TMaterial' - 0 - mat",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("SetDivision",1137,G__AliG3Volume_SetDivision_3_3,121,-1,-1,0,4,1,1,0,
+"i - 'Int_t' 0 - ndiv i - 'Int_t' 0 - axis "
+"f - 'Float_t' 0 - start f - 'Float_t' 0 - step",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("Division",837,G__AliG3Volume_Division_4_3,121,-1,-1,0,4,1,1,8,
+"i - 'Int_t' 1 - ndiv i - 'Int_t' 1 - axis "
+"f - 'Float_t' 1 - start f - 'Float_t' 1 - step",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("Axis",405,G__AliG3Volume_Axis_5_3,105,-1,G__defined_typename("Int_t"),0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("Ndiv",401,G__AliG3Volume_Ndiv_6_3,105,-1,G__defined_typename("Int_t"),0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("Step",412,G__AliG3Volume_Step_7_3,102,-1,G__defined_typename("Float_t"),0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("StartC",593,G__AliG3Volume_StartC_8_3,102,-1,G__defined_typename("Float_t"),0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("GetItem",687,G__AliG3Volume_GetItem_9_3,85,G__get_linked_tagnum(&G__AliGeant3CintLN_TObject),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("AliG3Volume",1032,G__AliG3Volume_AliG3Volume_0_4,105,G__get_linked_tagnum(&G__AliGeant3CintLN_AliG3Volume),-1,0,1,1,1,0,"u 'AliG3Volume' - 11 - -",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("operator=",937,(G__InterfaceMethod)NULL,117,G__get_linked_tagnum(&G__AliGeant3CintLN_AliG3Volume),-1,1,1,1,4,0,"u 'AliG3Volume' - 11 - -",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("Class",502,G__AliG3Volume_Class_2_4,85,G__get_linked_tagnum(&G__AliGeant3CintLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("Class_Name",982,G__AliG3Volume_Class_Name_3_4,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("Class_Version",1339,G__AliG3Volume_Class_Version_4_4,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("Dictionary",1046,G__AliG3Volume_Dictionary_5_4,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("IsA",253,G__AliG3Volume_IsA_6_4,85,G__get_linked_tagnum(&G__AliGeant3CintLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("ShowMembers",1132,G__AliG3Volume_ShowMembers_7_4,121,-1,-1,0,2,1,1,0,
+"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("Streamer",835,G__AliG3Volume_Streamer_8_4,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("StreamerNVirtual",1656,G__AliG3Volume_StreamerNVirtual_9_4,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("DeclFileName",1145,G__AliG3Volume_DeclFileName_0_5,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("DeclFileLine",1152,G__AliG3Volume_DeclFileLine_1_5,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("ImplFileName",1171,G__AliG3Volume_ImplFileName_2_5,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("ImplFileLine",1178,G__AliG3Volume_ImplFileLine_3_5,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
+   // automatic destructor
+   G__memfunc_setup("~AliG3Volume",1158,G__AliG3Volume_wAAliG3Volume_4_5,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
+   G__tag_memfunc_reset();
+}
+
+static void G__setup_memfuncAliNode(void) {
+   /* AliNode */
+   G__tag_memfunc_setup(G__get_linked_tagnum(&G__AliGeant3CintLN_AliNode));
+   G__memfunc_setup("AliNode",668,G__AliNode_AliNode_0_0,105,G__get_linked_tagnum(&G__AliGeant3CintLN_AliNode),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("AliNode",668,G__AliNode_AliNode_1_0,105,G__get_linked_tagnum(&G__AliGeant3CintLN_AliNode),-1,0,8,1,1,0,
+"C - - 10 - name C - - 10 - title "
+"C - - 10 - shapename d - 'Double_t' 0 0 x "
+"d - 'Double_t' 0 0 y d - 'Double_t' 0 0 z "
+"C - - 10 \"\" matrixname C - 'Option_t' 0 \"\" option",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("AliNode",668,G__AliNode_AliNode_2_0,105,G__get_linked_tagnum(&G__AliGeant3CintLN_AliNode),-1,0,8,1,1,0,
+"C - - 10 - name C - - 10 - title "
+"U 'TShape' - 0 - shape d - 'Double_t' 0 0 x "
+"d - 'Double_t' 0 0 y d - 'Double_t' 0 0 z "
+"U 'TRotMatrix' - 0 0 matrix C - 'Option_t' 0 \"\" option",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("AliNode",668,G__AliNode_AliNode_3_0,105,G__get_linked_tagnum(&G__AliGeant3CintLN_AliNode),-1,0,2,1,1,0,
+"u 'AliNode' - 11 - node U 'AliNode' - 0 - parent",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("SetDivision",1137,G__AliNode_SetDivision_5_0,121,-1,-1,0,4,1,1,0,
+"i - 'Int_t' 0 - ndiv i - 'Int_t' 0 - axis "
+"f - 'Float_t' 0 - start f - 'Float_t' 0 - step",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("ExpandDivisions",1560,G__AliNode_ExpandDivisions_6_0,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("Axis",405,G__AliNode_Axis_7_0,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("Ndiv",401,G__AliNode_Ndiv_8_0,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("Step",412,G__AliNode_Step_9_0,102,-1,G__defined_typename("Float_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("StartC",593,G__AliNode_StartC_0_1,102,-1,G__defined_typename("Float_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("AddSons",684,G__AliNode_AddSons_1_1,121,-1,-1,0,1,1,1,0,"U 'TList' - 0 - list",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("AddSon",569,G__AliNode_AddSon_2_1,121,-1,-1,0,1,1,1,0,"U 'AliNode' - 0 - node",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("operator=",937,(G__InterfaceMethod)NULL,117,G__get_linked_tagnum(&G__AliGeant3CintLN_AliNode),-1,1,1,1,4,0,"u 'AliNode' - 11 - -",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("Class",502,G__AliNode_Class_4_1,85,G__get_linked_tagnum(&G__AliGeant3CintLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("Class_Name",982,G__AliNode_Class_Name_5_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("Class_Version",1339,G__AliNode_Class_Version_6_1,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("Dictionary",1046,G__AliNode_Dictionary_7_1,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("IsA",253,G__AliNode_IsA_8_1,85,G__get_linked_tagnum(&G__AliGeant3CintLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("ShowMembers",1132,G__AliNode_ShowMembers_9_1,121,-1,-1,0,2,1,1,0,
+"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("Streamer",835,G__AliNode_Streamer_0_2,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("StreamerNVirtual",1656,G__AliNode_StreamerNVirtual_1_2,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("DeclFileName",1145,G__AliNode_DeclFileName_2_2,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("DeclFileLine",1152,G__AliNode_DeclFileLine_3_2,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("ImplFileName",1171,G__AliNode_ImplFileName_4_2,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("ImplFileLine",1178,G__AliNode_ImplFileLine_5_2,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
+   // automatic copy constructor
+   G__memfunc_setup("AliNode",668,G__AliNode_AliNode_6_2,(int)('i'),G__get_linked_tagnum(&G__AliGeant3CintLN_AliNode),-1,0,1,1,1,0,"u 'AliNode' - 1 - -",(char*)NULL,(void*)NULL,0);
+   // automatic destructor
+   G__memfunc_setup("~AliNode",794,G__AliNode_wAAliNode_7_2,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
+   G__tag_memfunc_reset();
+}
+
+static void G__setup_memfuncAliGuiGeomMain(void) {
+   /* AliGuiGeomMain */
+   G__tag_memfunc_setup(G__get_linked_tagnum(&G__AliGeant3CintLN_AliGuiGeomMain));
+   G__memfunc_setup("AliGuiGeomMain",1352,G__AliGuiGeomMain_AliGuiGeomMain_0_0,105,G__get_linked_tagnum(&G__AliGeant3CintLN_AliGuiGeomMain),-1,0,3,1,1,0,
+"U 'TGWindow' - 10 - p h - 'UInt_t' 0 - w "
+"h - 'UInt_t' 0 - h",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("CloseWindow",1134,G__AliGuiGeomMain_CloseWindow_2_0,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("AddItem",664,G__AliGuiGeomMain_AddItem_3_0,85,G__get_linked_tagnum(&G__AliGeant3CintLN_TGListTreeItem),-1,0,5,1,1,0,
+"U 'TObject' - 0 - obj U 'TGListTreeItem' - 0 - parent "
+"C - - 10 - name U 'TGPicture' - 10 - open "
+"U 'TGPicture' - 10 - closed",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("AddMaterial",1080,G__AliGuiGeomMain_AddMaterial_4_0,121,-1,-1,0,2,1,1,0,
+"U 'AliG3Material' - 0 - Material i - 'Int_t' 0 - i",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("AddMedium",874,G__AliGuiGeomMain_AddMedium_5_0,121,-1,-1,0,2,1,1,0,
+"U 'AliG3Medium' - 0 - Medium i - 'Int_t' 0 - i",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("ProcessMessage",1444,G__AliGuiGeomMain_ProcessMessage_6_0,103,-1,G__defined_typename("Bool_t"),0,3,1,1,0,
+"l - 'Long_t' 0 - msg l - 'Long_t' 0 - parm1 "
+"l - 'Long_t' 0 - parm2",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("Update",611,G__AliGuiGeomMain_Update_7_0,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("UpdateCombo",1107,G__AliGuiGeomMain_UpdateCombo_8_0,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("UpdateListBox",1320,G__AliGuiGeomMain_UpdateListBox_9_0,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("SetMaterialComboEntries",2341,G__AliGuiGeomMain_SetMaterialComboEntries_0_1,121,-1,-1,0,1,1,1,0,"U 'TClonesArray' - 0 - entries",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("SetMediaComboEntries",2006,G__AliGuiGeomMain_SetMediaComboEntries_1_1,121,-1,-1,0,1,1,1,0,"U 'TClonesArray' - 0 - entries",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("AddFoldersRecursively",2165,G__AliGuiGeomMain_AddFoldersRecursively_2_1,121,-1,-1,0,2,1,1,0,
+"U 'TFolder' - 0 0 folder U 'TGListTreeItem' - 0 NULL parent",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("Plot",415,G__AliGuiGeomMain_Plot_3_1,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("AliGuiGeomMain",1352,(G__InterfaceMethod)NULL,105,G__get_linked_tagnum(&G__AliGeant3CintLN_AliGuiGeomMain),-1,0,1,1,4,0,"u 'AliGuiGeomMain' - 11 - gm",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("operator=",937,(G__InterfaceMethod)NULL,117,G__get_linked_tagnum(&G__AliGeant3CintLN_AliGuiGeomMain),-1,1,1,1,4,0,"u 'AliGuiGeomMain' - 11 - -",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("Class",502,G__AliGuiGeomMain_Class_6_1,85,G__get_linked_tagnum(&G__AliGeant3CintLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("Class_Name",982,G__AliGuiGeomMain_Class_Name_7_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("Class_Version",1339,G__AliGuiGeomMain_Class_Version_8_1,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("Dictionary",1046,G__AliGuiGeomMain_Dictionary_9_1,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("IsA",253,G__AliGuiGeomMain_IsA_0_2,85,G__get_linked_tagnum(&G__AliGeant3CintLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("ShowMembers",1132,G__AliGuiGeomMain_ShowMembers_1_2,121,-1,-1,0,2,1,1,0,
+"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("Streamer",835,G__AliGuiGeomMain_Streamer_2_2,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("StreamerNVirtual",1656,G__AliGuiGeomMain_StreamerNVirtual_3_2,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("DeclFileName",1145,G__AliGuiGeomMain_DeclFileName_4_2,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("DeclFileLine",1152,G__AliGuiGeomMain_DeclFileLine_5_2,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("ImplFileName",1171,G__AliGuiGeomMain_ImplFileName_6_2,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("ImplFileLine",1178,G__AliGuiGeomMain_ImplFileLine_7_2,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
+   // automatic destructor
+   G__memfunc_setup("~AliGuiGeomMain",1478,G__AliGuiGeomMain_wAAliGuiGeomMain_8_2,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
+   G__tag_memfunc_reset();
+}
+
+static void G__setup_memfuncAliGeant3GeometryGUI(void) {
+   /* AliGeant3GeometryGUI */
+   G__tag_memfunc_setup(G__get_linked_tagnum(&G__AliGeant3CintLN_AliGeant3GeometryGUI));
+   G__memfunc_setup("AliGeant3GeometryGUI",1897,G__AliGeant3GeometryGUI_AliGeant3GeometryGUI_0_0,105,G__get_linked_tagnum(&G__AliGeant3CintLN_AliGeant3GeometryGUI),-1,0,1,1,1,0,"C - - 10 \"\" opt",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("AliGeant3GeometryGUI",1897,(G__InterfaceMethod)NULL,105,G__get_linked_tagnum(&G__AliGeant3CintLN_AliGeant3GeometryGUI),-1,0,1,1,4,0,"u 'AliGeant3GeometryGUI' - 11 - -",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("operator=",937,(G__InterfaceMethod)NULL,117,G__get_linked_tagnum(&G__AliGeant3CintLN_AliGeant3GeometryGUI),-1,1,1,1,4,0,"u 'AliGeant3GeometryGUI' - 11 - -",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("Class",502,G__AliGeant3GeometryGUI_Class_4_0,85,G__get_linked_tagnum(&G__AliGeant3CintLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("Class_Name",982,G__AliGeant3GeometryGUI_Class_Name_5_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("Class_Version",1339,G__AliGeant3GeometryGUI_Class_Version_6_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("Dictionary",1046,G__AliGeant3GeometryGUI_Dictionary_7_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("IsA",253,G__AliGeant3GeometryGUI_IsA_8_0,85,G__get_linked_tagnum(&G__AliGeant3CintLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("ShowMembers",1132,G__AliGeant3GeometryGUI_ShowMembers_9_0,121,-1,-1,0,2,1,1,0,
+"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("Streamer",835,G__AliGeant3GeometryGUI_Streamer_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("StreamerNVirtual",1656,G__AliGeant3GeometryGUI_StreamerNVirtual_1_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("DeclFileName",1145,G__AliGeant3GeometryGUI_DeclFileName_2_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("DeclFileLine",1152,G__AliGeant3GeometryGUI_DeclFileLine_3_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("ImplFileName",1171,G__AliGeant3GeometryGUI_ImplFileName_4_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("ImplFileLine",1178,G__AliGeant3GeometryGUI_ImplFileLine_5_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
+   // automatic destructor
+   G__memfunc_setup("~AliGeant3GeometryGUI",2023,G__AliGeant3GeometryGUI_wAAliGeant3GeometryGUI_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
+   G__tag_memfunc_reset();
+}
+
+static void G__setup_memfuncAliG3toRoot(void) {
+   /* AliG3toRoot */
+   G__tag_memfunc_setup(G__get_linked_tagnum(&G__AliGeant3CintLN_AliG3toRoot));
+   G__memfunc_setup("AliG3toRoot",1047,G__AliG3toRoot_AliG3toRoot_0_0,105,G__get_linked_tagnum(&G__AliGeant3CintLN_AliG3toRoot),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("G3toRoot",769,G__AliG3toRoot_G3toRoot_2_0,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("ConvertToRootShapes",1964,G__AliG3toRoot_ConvertToRootShapes_3_0,121,-1,-1,0,3,1,1,0,
+"U 'TFolder' - 0 0 item U 'AliNode' - 2 0 node "
+"i - 'Int_t' 0 1 nNodes",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("SetExpandDivisions",1860,G__AliG3toRoot_SetExpandDivisions_4_0,121,-1,-1,0,1,1,1,0,"i - 'Int_t' 0 1 flag",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("GetTopFolder",1199,G__AliG3toRoot_GetTopFolder_5_0,85,G__get_linked_tagnum(&G__AliGeant3CintLN_TFolder),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("GetMaterials",1218,G__AliG3toRoot_GetMaterials_6_0,85,G__get_linked_tagnum(&G__AliGeant3CintLN_TClonesArray),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("GetMedia",768,G__AliG3toRoot_GetMedia_7_0,85,G__get_linked_tagnum(&G__AliGeant3CintLN_TClonesArray),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("ExpandDivisions",1560,(G__InterfaceMethod)NULL,121,-1,-1,0,1,1,4,0,"U 'AliNode' - 0 0 node",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("ReadGeometryTree",1624,(G__InterfaceMethod)NULL,121,-1,-1,0,0,1,4,0,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("ReadMaterials",1310,(G__InterfaceMethod)NULL,121,-1,-1,0,0,1,4,0,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("ReadRotations",1343,(G__InterfaceMethod)NULL,121,-1,-1,0,0,1,4,0,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("AddVolume",897,(G__InterfaceMethod)NULL,85,G__get_linked_tagnum(&G__AliGeant3CintLN_TFolder),-1,0,3,1,4,0,
+"U 'TObject' - 0 - obj U 'TFolder' - 0 - parent "
+"C - - 10 - name",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("Volume",632,(G__InterfaceMethod)NULL,85,G__get_linked_tagnum(&G__AliGeant3CintLN_AliG3Volume),-1,0,1,1,4,0,"i - 'Int_t' 0 - id",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("Medium",609,(G__InterfaceMethod)NULL,105,-1,G__defined_typename("Int_t"),0,1,1,4,0,"i - 'Int_t' 0 - idvol",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("Material",815,(G__InterfaceMethod)NULL,105,-1,G__defined_typename("Int_t"),0,1,1,4,0,"i - 'Int_t' 0 - idvol",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("Cut",300,(G__InterfaceMethod)NULL,102,-1,G__defined_typename("Float_t"),0,2,1,4,0,
+"i - 'Int_t' 0 - imed i - 'Int_t' 0 - icut",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("NChildren",887,(G__InterfaceMethod)NULL,105,-1,G__defined_typename("Int_t"),0,1,1,4,0,"i - 'Int_t' 0 - idvol",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("Child",484,(G__InterfaceMethod)NULL,105,-1,G__defined_typename("Int_t"),0,2,1,4,0,
+"i - 'Int_t' 0 - idvol i - 'Int_t' 0 - idc",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("operator=",937,(G__InterfaceMethod)NULL,117,G__get_linked_tagnum(&G__AliGeant3CintLN_AliG3toRoot),-1,1,1,1,4,0,"u 'AliG3toRoot' - 11 - -",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("Class",502,G__AliG3toRoot_Class_0_2,85,G__get_linked_tagnum(&G__AliGeant3CintLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("Class_Name",982,G__AliG3toRoot_Class_Name_1_2,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("Class_Version",1339,G__AliG3toRoot_Class_Version_2_2,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("Dictionary",1046,G__AliG3toRoot_Dictionary_3_2,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("IsA",253,G__AliG3toRoot_IsA_4_2,85,G__get_linked_tagnum(&G__AliGeant3CintLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("ShowMembers",1132,G__AliG3toRoot_ShowMembers_5_2,121,-1,-1,0,2,1,1,0,
+"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("Streamer",835,G__AliG3toRoot_Streamer_6_2,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("StreamerNVirtual",1656,G__AliG3toRoot_StreamerNVirtual_7_2,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("DeclFileName",1145,G__AliG3toRoot_DeclFileName_8_2,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("DeclFileLine",1152,G__AliG3toRoot_DeclFileLine_9_2,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("ImplFileName",1171,G__AliG3toRoot_ImplFileName_0_3,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("ImplFileLine",1178,G__AliG3toRoot_ImplFileLine_1_3,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
+   // automatic copy constructor
+   G__memfunc_setup("AliG3toRoot",1047,G__AliG3toRoot_AliG3toRoot_2_3,(int)('i'),G__get_linked_tagnum(&G__AliGeant3CintLN_AliG3toRoot),-1,0,1,1,1,0,"u 'AliG3toRoot' - 1 - -",(char*)NULL,(void*)NULL,0);
+   // automatic destructor
+   G__memfunc_setup("~AliG3toRoot",1173,G__AliG3toRoot_wAAliG3toRoot_3_3,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
+   G__tag_memfunc_reset();
+}
+
+
+/*********************************************************
+* Member function information setup
+*********************************************************/
+extern "C" void G__cpp_setup_memfuncAliGeant3Cint() {
+}
+
+/*********************************************************
+* Global variable information setup for each class
+*********************************************************/
+static void G__cpp_setup_global0() {
+
+   /* Setting up global variables */
+   G__resetplocal();
+
+}
+
+static void G__cpp_setup_global1() {
+}
+
+static void G__cpp_setup_global2() {
+}
+
+static void G__cpp_setup_global3() {
+}
+
+static void G__cpp_setup_global4() {
+}
+
+static void G__cpp_setup_global5() {
+}
+
+static void G__cpp_setup_global6() {
+
+   G__resetglobalenv();
+}
+extern "C" void G__cpp_setup_globalAliGeant3Cint() {
+  G__cpp_setup_global0();
+  G__cpp_setup_global1();
+  G__cpp_setup_global2();
+  G__cpp_setup_global3();
+  G__cpp_setup_global4();
+  G__cpp_setup_global5();
+  G__cpp_setup_global6();
+}
+
+/*********************************************************
+* Global function information setup for each class
+*********************************************************/
+static void G__cpp_setup_func0() {
+   G__lastifuncposition();
+
+}
+
+static void G__cpp_setup_func1() {
+}
+
+static void G__cpp_setup_func2() {
+
+   G__resetifuncposition();
+}
+
+extern "C" void G__cpp_setup_funcAliGeant3Cint() {
+  G__cpp_setup_func0();
+  G__cpp_setup_func1();
+  G__cpp_setup_func2();
+}
+
+/*********************************************************
+* Class,struct,union,enum tag information setup
+*********************************************************/
+/* Setup class/struct taginfo */
+G__linked_taginfo G__AliGeant3CintLN_TClass = { "TClass" , 99 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_TList = { "TList" , 99 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_TObjArray = { "TObjArray" , 99 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_TObject = { "TObject" , 99 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_TNamed = { "TNamed" , 99 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_TFolder = { "TFolder" , 99 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_AliG3Medium = { "AliG3Medium" , 99 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_TAttFill = { "TAttFill" , 99 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_TMaterial = { "TMaterial" , 99 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_AliG3Material = { "AliG3Material" , 99 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_TGObject = { "TGObject" , 99 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_TGWindow = { "TGWindow" , 99 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_TAttLine = { "TAttLine" , 99 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_TQObject = { "TQObject" , 99 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_TGFrame = { "TGFrame" , 99 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_TGCompositeFrame = { "TGCompositeFrame" , 99 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_TGLayoutHints = { "TGLayoutHints" , 99 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_TGHorizontalFrame = { "TGHorizontalFrame" , 99 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_TGMainFrame = { "TGMainFrame" , 99 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_TGCanvas = { "TGCanvas" , 99 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_TGListTreeItem = { "TGListTreeItem" , 99 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_TGListTree = { "TGListTree" , 99 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_TClonesArray = { "TClonesArray" , 99 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_Decay_t = { "Decay_t" , 101 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_Quest_t = { "Quest_t" , 115 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_Gcbank_t = { "Gcbank_t" , 115 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_Gclink_t = { "Gclink_t" , 115 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_Gcflag_t = { "Gcflag_t" , 115 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_Gckine_t = { "Gckine_t" , 115 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_Gcking_t = { "Gcking_t" , 115 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_Gckin2_t = { "Gckin2_t" , 115 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_Gckin3_t = { "Gckin3_t" , 115 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_Gcmate_t = { "Gcmate_t" , 115 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_Gctmed_t = { "Gctmed_t" , 115 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_Gctrak_t = { "Gctrak_t" , 115 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_Gcvolu_t = { "Gcvolu_t" , 115 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_Gcsets_t = { "Gcsets_t" , 115 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_Gcnum_t = { "Gcnum_t" , 115 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_Gccuts_t = { "Gccuts_t" , 115 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_Gcmulo_t = { "Gcmulo_t" , 115 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_Gcphys_t = { "Gcphys_t" , 115 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_Gcphlt_t = { "Gcphlt_t" , 115 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_Gcopti_t = { "Gcopti_t" , 115 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_Gctlit_t = { "Gctlit_t" , 115 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_Gcvdma_t = { "Gcvdma_t" , 115 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_Gctpol_t = { "Gctpol_t" , 115 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_Ertrio_t = { "Ertrio_t" , 115 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_Eropts_t = { "Eropts_t" , 115 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_Eroptc_t = { "Eroptc_t" , 115 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_Erwork_t = { "Erwork_t" , 115 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_TArrayF = { "TArrayF" , 99 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_AliG3Volume = { "AliG3Volume" , 99 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_TGTextBuffer = { "TGTextBuffer" , 99 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_TGTextEntry = { "TGTextEntry" , 99 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_TGLabel = { "TGLabel" , 99 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_TGComboBox = { "TGComboBox" , 99 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_TGTab = { "TGTab" , 99 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_AliGuiGeomDialog = { "AliGuiGeomDialog" , 99 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_TGTextButton = { "TGTextButton" , 99 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_TGListBox = { "TGListBox" , 99 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_TGMenuBar = { "TGMenuBar" , 99 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_TGPopupMenu = { "TGPopupMenu" , 99 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_AliNode = { "AliNode" , 99 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_AliGuiGeomMain = { "AliGuiGeomMain" , 99 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_AliGeant3GeometryGUI = { "AliGeant3GeometryGUI" , 99 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_TAtt3D = { "TAtt3D" , 99 , -1 };
+G__linked_taginfo G__AliGeant3CintLN__x3d_data_ = { "_x3d_data_" , 115 , -1 };
+G__linked_taginfo G__AliGeant3CintLN__x3d_sizeof_ = { "_x3d_sizeof_" , 115 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_TNode = { "TNode" , 99 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_TGeometry = { "TGeometry" , 99 , -1 };
+G__linked_taginfo G__AliGeant3CintLN_AliG3toRoot = { "AliG3toRoot" , 99 , -1 };
+
+/* Reset class/struct taginfo */
+extern "C" void G__cpp_reset_tagtableAliGeant3Cint() {
+  G__AliGeant3CintLN_TClass.tagnum = -1 ;
+  G__AliGeant3CintLN_TList.tagnum = -1 ;
+  G__AliGeant3CintLN_TObjArray.tagnum = -1 ;
+  G__AliGeant3CintLN_TObject.tagnum = -1 ;
+  G__AliGeant3CintLN_TNamed.tagnum = -1 ;
+  G__AliGeant3CintLN_TFolder.tagnum = -1 ;
+  G__AliGeant3CintLN_AliG3Medium.tagnum = -1 ;
+  G__AliGeant3CintLN_TAttFill.tagnum = -1 ;
+  G__AliGeant3CintLN_TMaterial.tagnum = -1 ;
+  G__AliGeant3CintLN_AliG3Material.tagnum = -1 ;
+  G__AliGeant3CintLN_TGObject.tagnum = -1 ;
+  G__AliGeant3CintLN_TGWindow.tagnum = -1 ;
+  G__AliGeant3CintLN_TAttLine.tagnum = -1 ;
+  G__AliGeant3CintLN_TQObject.tagnum = -1 ;
+  G__AliGeant3CintLN_TGFrame.tagnum = -1 ;
+  G__AliGeant3CintLN_TGCompositeFrame.tagnum = -1 ;
+  G__AliGeant3CintLN_TGLayoutHints.tagnum = -1 ;
+  G__AliGeant3CintLN_TGHorizontalFrame.tagnum = -1 ;
+  G__AliGeant3CintLN_TGMainFrame.tagnum = -1 ;
+  G__AliGeant3CintLN_TGCanvas.tagnum = -1 ;
+  G__AliGeant3CintLN_TGListTreeItem.tagnum = -1 ;
+  G__AliGeant3CintLN_TGListTree.tagnum = -1 ;
+  G__AliGeant3CintLN_TClonesArray.tagnum = -1 ;
+  G__AliGeant3CintLN_Decay_t.tagnum = -1 ;
+  G__AliGeant3CintLN_Quest_t.tagnum = -1 ;
+  G__AliGeant3CintLN_Gcbank_t.tagnum = -1 ;
+  G__AliGeant3CintLN_Gclink_t.tagnum = -1 ;
+  G__AliGeant3CintLN_Gcflag_t.tagnum = -1 ;
+  G__AliGeant3CintLN_Gckine_t.tagnum = -1 ;
+  G__AliGeant3CintLN_Gcking_t.tagnum = -1 ;
+  G__AliGeant3CintLN_Gckin2_t.tagnum = -1 ;
+  G__AliGeant3CintLN_Gckin3_t.tagnum = -1 ;
+  G__AliGeant3CintLN_Gcmate_t.tagnum = -1 ;
+  G__AliGeant3CintLN_Gctmed_t.tagnum = -1 ;
+  G__AliGeant3CintLN_Gctrak_t.tagnum = -1 ;
+  G__AliGeant3CintLN_Gcvolu_t.tagnum = -1 ;
+  G__AliGeant3CintLN_Gcsets_t.tagnum = -1 ;
+  G__AliGeant3CintLN_Gcnum_t.tagnum = -1 ;
+  G__AliGeant3CintLN_Gccuts_t.tagnum = -1 ;
+  G__AliGeant3CintLN_Gcmulo_t.tagnum = -1 ;
+  G__AliGeant3CintLN_Gcphys_t.tagnum = -1 ;
+  G__AliGeant3CintLN_Gcphlt_t.tagnum = -1 ;
+  G__AliGeant3CintLN_Gcopti_t.tagnum = -1 ;
+  G__AliGeant3CintLN_Gctlit_t.tagnum = -1 ;
+  G__AliGeant3CintLN_Gcvdma_t.tagnum = -1 ;
+  G__AliGeant3CintLN_Gctpol_t.tagnum = -1 ;
+  G__AliGeant3CintLN_Ertrio_t.tagnum = -1 ;
+  G__AliGeant3CintLN_Eropts_t.tagnum = -1 ;
+  G__AliGeant3CintLN_Eroptc_t.tagnum = -1 ;
+  G__AliGeant3CintLN_Erwork_t.tagnum = -1 ;
+  G__AliGeant3CintLN_TArrayF.tagnum = -1 ;
+  G__AliGeant3CintLN_AliG3Volume.tagnum = -1 ;
+  G__AliGeant3CintLN_TGTextBuffer.tagnum = -1 ;
+  G__AliGeant3CintLN_TGTextEntry.tagnum = -1 ;
+  G__AliGeant3CintLN_TGLabel.tagnum = -1 ;
+  G__AliGeant3CintLN_TGComboBox.tagnum = -1 ;
+  G__AliGeant3CintLN_TGTab.tagnum = -1 ;
+  G__AliGeant3CintLN_AliGuiGeomDialog.tagnum = -1 ;
+  G__AliGeant3CintLN_TGTextButton.tagnum = -1 ;
+  G__AliGeant3CintLN_TGListBox.tagnum = -1 ;
+  G__AliGeant3CintLN_TGMenuBar.tagnum = -1 ;
+  G__AliGeant3CintLN_TGPopupMenu.tagnum = -1 ;
+  G__AliGeant3CintLN_AliNode.tagnum = -1 ;
+  G__AliGeant3CintLN_AliGuiGeomMain.tagnum = -1 ;
+  G__AliGeant3CintLN_AliGeant3GeometryGUI.tagnum = -1 ;
+  G__AliGeant3CintLN_TAtt3D.tagnum = -1 ;
+  G__AliGeant3CintLN__x3d_data_.tagnum = -1 ;
+  G__AliGeant3CintLN__x3d_sizeof_.tagnum = -1 ;
+  G__AliGeant3CintLN_TNode.tagnum = -1 ;
+  G__AliGeant3CintLN_TGeometry.tagnum = -1 ;
+  G__AliGeant3CintLN_AliG3toRoot.tagnum = -1 ;
+}
+
+
+extern "C" void G__cpp_setup_tagtableAliGeant3Cint() {
+
+   /* Setting up class,struct,union tag entry */
+   G__tagtable_setup(G__get_linked_tagnum(&G__AliGeant3CintLN_AliG3Medium),sizeof(AliG3Medium),-1,98048,"Tracking Medium Object for GUI ",G__setup_memvarAliG3Medium,G__setup_memfuncAliG3Medium);
+   G__tagtable_setup(G__get_linked_tagnum(&G__AliGeant3CintLN_AliG3Material),sizeof(AliG3Material),-1,294656,"Material Object for GUI ",G__setup_memvarAliG3Material,G__setup_memfuncAliG3Material);
+   G__tagtable_setup(G__get_linked_tagnum(&G__AliGeant3CintLN_AliG3Volume),sizeof(AliG3Volume),-1,294656,"Volume Object for Drawing ",G__setup_memvarAliG3Volume,G__setup_memfuncAliG3Volume);
+   G__tagtable_setup(G__get_linked_tagnum(&G__AliGeant3CintLN_AliNode),sizeof(AliNode),-1,294144,"Material Object for GUI ",G__setup_memvarAliNode,G__setup_memfuncAliNode);
+   G__tagtable_setup(G__get_linked_tagnum(&G__AliGeant3CintLN_AliGuiGeomMain),sizeof(AliGuiGeomMain),-1,97792,"MainFrame for Geometry Browser",G__setup_memvarAliGuiGeomMain,G__setup_memfuncAliGuiGeomMain);
+   G__tagtable_setup(G__get_linked_tagnum(&G__AliGeant3CintLN_AliGeant3GeometryGUI),sizeof(AliGeant3GeometryGUI),-1,98048,"GUI for Geant3 geometry visualisation",G__setup_memvarAliGeant3GeometryGUI,G__setup_memfuncAliGeant3GeometryGUI);
+   G__tagtable_setup(G__get_linked_tagnum(&G__AliGeant3CintLN_AliG3toRoot),sizeof(AliG3toRoot),-1,294144,"Material Object for GUI ",G__setup_memvarAliG3toRoot,G__setup_memfuncAliG3toRoot);
+}
+extern "C" void G__cpp_setupAliGeant3Cint(void) {
+  G__check_setup_version(30051515,"G__cpp_setupAliGeant3Cint()");
+  G__set_cpp_environmentAliGeant3Cint();
+  G__cpp_setup_tagtableAliGeant3Cint();
+
+  G__cpp_setup_inheritanceAliGeant3Cint();
+
+  G__cpp_setup_typetableAliGeant3Cint();
+
+  G__cpp_setup_memvarAliGeant3Cint();
+
+  G__cpp_setup_memfuncAliGeant3Cint();
+  G__cpp_setup_globalAliGeant3Cint();
+  G__cpp_setup_funcAliGeant3Cint();
+
+   if(0==G__getsizep2memfunc()) G__get_sizep2memfuncAliGeant3Cint();
+  return;
+}
+class G__cpp_setup_initAliGeant3Cint {
+  public:
+    G__cpp_setup_initAliGeant3Cint() { G__add_setup_func("AliGeant3Cint",(G__incsetup)(&G__cpp_setupAliGeant3Cint)); G__call_setup_funcs(); }
+   ~G__cpp_setup_initAliGeant3Cint() { G__remove_setup_func("AliGeant3Cint"); }
+};
+G__cpp_setup_initAliGeant3Cint G__cpp_setup_initializerAliGeant3Cint;
+
diff --git a/AliGeant3/AliGeant3Cint.h b/AliGeant3/AliGeant3Cint.h
new file mode 100644 (file)
index 0000000..942726c
--- /dev/null
@@ -0,0 +1,114 @@
+/********************************************************************
+* AliGeant3Cint.h
+********************************************************************/
+#ifdef __CINT__
+#error AliGeant3Cint.h/C is only for compilation. Abort cint.
+#endif
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <string.h>
+#define G__ANSIHEADER
+#define G__DICTIONARY
+#include "G__ci.h"
+extern "C" {
+extern void G__cpp_setup_tagtableAliGeant3Cint();
+extern void G__cpp_setup_inheritanceAliGeant3Cint();
+extern void G__cpp_setup_typetableAliGeant3Cint();
+extern void G__cpp_setup_memvarAliGeant3Cint();
+extern void G__cpp_setup_globalAliGeant3Cint();
+extern void G__cpp_setup_memfuncAliGeant3Cint();
+extern void G__cpp_setup_funcAliGeant3Cint();
+extern void G__set_cpp_environmentAliGeant3Cint();
+}
+
+
+#include "TROOT.h"
+#include "TMemberInspector.h"
+#include "AliG3Medium.h"
+#include "AliG3Material.h"
+#include "AliG3Volume.h"
+#include "AliGUISliders.h"
+#include "AliGuiGeomDialog.h"
+#include "AliGuiGeomMain.h"
+#include "AliGeant3GeometryGUI.h"
+#include "AliNode.h"
+#include "AliG3toRoot.h"
+
+#ifndef G__MEMFUNCBODY
+#endif
+
+extern G__linked_taginfo G__AliGeant3CintLN_TClass;
+extern G__linked_taginfo G__AliGeant3CintLN_TList;
+extern G__linked_taginfo G__AliGeant3CintLN_TObjArray;
+extern G__linked_taginfo G__AliGeant3CintLN_TObject;
+extern G__linked_taginfo G__AliGeant3CintLN_TNamed;
+extern G__linked_taginfo G__AliGeant3CintLN_TFolder;
+extern G__linked_taginfo G__AliGeant3CintLN_AliG3Medium;
+extern G__linked_taginfo G__AliGeant3CintLN_TAttFill;
+extern G__linked_taginfo G__AliGeant3CintLN_TMaterial;
+extern G__linked_taginfo G__AliGeant3CintLN_AliG3Material;
+extern G__linked_taginfo G__AliGeant3CintLN_TGObject;
+extern G__linked_taginfo G__AliGeant3CintLN_TGWindow;
+extern G__linked_taginfo G__AliGeant3CintLN_TAttLine;
+extern G__linked_taginfo G__AliGeant3CintLN_TQObject;
+extern G__linked_taginfo G__AliGeant3CintLN_TGFrame;
+extern G__linked_taginfo G__AliGeant3CintLN_TGCompositeFrame;
+extern G__linked_taginfo G__AliGeant3CintLN_TGLayoutHints;
+extern G__linked_taginfo G__AliGeant3CintLN_TGHorizontalFrame;
+extern G__linked_taginfo G__AliGeant3CintLN_TGMainFrame;
+extern G__linked_taginfo G__AliGeant3CintLN_TGCanvas;
+extern G__linked_taginfo G__AliGeant3CintLN_TGListTreeItem;
+extern G__linked_taginfo G__AliGeant3CintLN_TGListTree;
+extern G__linked_taginfo G__AliGeant3CintLN_TClonesArray;
+extern G__linked_taginfo G__AliGeant3CintLN_Decay_t;
+extern G__linked_taginfo G__AliGeant3CintLN_Quest_t;
+extern G__linked_taginfo G__AliGeant3CintLN_Gcbank_t;
+extern G__linked_taginfo G__AliGeant3CintLN_Gclink_t;
+extern G__linked_taginfo G__AliGeant3CintLN_Gcflag_t;
+extern G__linked_taginfo G__AliGeant3CintLN_Gckine_t;
+extern G__linked_taginfo G__AliGeant3CintLN_Gcking_t;
+extern G__linked_taginfo G__AliGeant3CintLN_Gckin2_t;
+extern G__linked_taginfo G__AliGeant3CintLN_Gckin3_t;
+extern G__linked_taginfo G__AliGeant3CintLN_Gcmate_t;
+extern G__linked_taginfo G__AliGeant3CintLN_Gctmed_t;
+extern G__linked_taginfo G__AliGeant3CintLN_Gctrak_t;
+extern G__linked_taginfo G__AliGeant3CintLN_Gcvolu_t;
+extern G__linked_taginfo G__AliGeant3CintLN_Gcsets_t;
+extern G__linked_taginfo G__AliGeant3CintLN_Gcnum_t;
+extern G__linked_taginfo G__AliGeant3CintLN_Gccuts_t;
+extern G__linked_taginfo G__AliGeant3CintLN_Gcmulo_t;
+extern G__linked_taginfo G__AliGeant3CintLN_Gcphys_t;
+extern G__linked_taginfo G__AliGeant3CintLN_Gcphlt_t;
+extern G__linked_taginfo G__AliGeant3CintLN_Gcopti_t;
+extern G__linked_taginfo G__AliGeant3CintLN_Gctlit_t;
+extern G__linked_taginfo G__AliGeant3CintLN_Gcvdma_t;
+extern G__linked_taginfo G__AliGeant3CintLN_Gctpol_t;
+extern G__linked_taginfo G__AliGeant3CintLN_Ertrio_t;
+extern G__linked_taginfo G__AliGeant3CintLN_Eropts_t;
+extern G__linked_taginfo G__AliGeant3CintLN_Eroptc_t;
+extern G__linked_taginfo G__AliGeant3CintLN_Erwork_t;
+extern G__linked_taginfo G__AliGeant3CintLN_TArrayF;
+extern G__linked_taginfo G__AliGeant3CintLN_AliG3Volume;
+extern G__linked_taginfo G__AliGeant3CintLN_TGTextBuffer;
+extern G__linked_taginfo G__AliGeant3CintLN_TGTextEntry;
+extern G__linked_taginfo G__AliGeant3CintLN_TGLabel;
+extern G__linked_taginfo G__AliGeant3CintLN_TGComboBox;
+extern G__linked_taginfo G__AliGeant3CintLN_TGTab;
+extern G__linked_taginfo G__AliGeant3CintLN_AliGuiGeomDialog;
+extern G__linked_taginfo G__AliGeant3CintLN_TGTextButton;
+extern G__linked_taginfo G__AliGeant3CintLN_TGListBox;
+extern G__linked_taginfo G__AliGeant3CintLN_TGMenuBar;
+extern G__linked_taginfo G__AliGeant3CintLN_TGPopupMenu;
+extern G__linked_taginfo G__AliGeant3CintLN_AliNode;
+extern G__linked_taginfo G__AliGeant3CintLN_AliGuiGeomMain;
+extern G__linked_taginfo G__AliGeant3CintLN_AliGeant3GeometryGUI;
+extern G__linked_taginfo G__AliGeant3CintLN_TAtt3D;
+extern G__linked_taginfo G__AliGeant3CintLN__x3d_data_;
+extern G__linked_taginfo G__AliGeant3CintLN__x3d_sizeof_;
+extern G__linked_taginfo G__AliGeant3CintLN_TNode;
+extern G__linked_taginfo G__AliGeant3CintLN_TGeometry;
+extern G__linked_taginfo G__AliGeant3CintLN_AliG3toRoot;
+
+/* STUB derived class for protected member access */
diff --git a/AliGeant3/AliGeant3GUI.C b/AliGeant3/AliGeant3GUI.C
new file mode 100644 (file)
index 0000000..c040850
--- /dev/null
@@ -0,0 +1,6 @@
+void TGeant3GUI(){
+gui=new AliGeant3GeometryGUI();
+}
+
+
+
diff --git a/AliGeant3/AliGeant3GeometryGUI.cxx b/AliGeant3/AliGeant3GeometryGUI.cxx
new file mode 100644 (file)
index 0000000..0701c4f
--- /dev/null
@@ -0,0 +1,121 @@
+/* *************************************************************************
+ * 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.4  2002/03/19 09:36:17  morsch
+Unnecessary includes removes, one included. (Jacek M. Holeczek)
+
+Revision 1.3  2001/10/24 12:04:24  morsch
+Expand divisions only on request.
+
+Revision 1.2  2001/07/09 11:45:15  morsch
+Reduced functionality: mediate between GUI and Geometry Conversion.
+
+Revision 1.1  2000/07/13 16:19:10  fca
+Mainly coding conventions + some small bug fixes
+
+Revision 1.8  2000/07/12 08:56:32  fca
+Coding convention correction and warning removal
+
+Revision 1.7  2000/06/28 21:27:45  morsch
+Most coding rule violations corrected.
+Still to do: Split the file (on file per class) ? Avoid the global variables.
+Copy constructors and assignment operators (dummy ?)
+
+Revision 1.6  2000/04/14 11:07:46  morsch
+Correct volume to medium assignment in case several media are asigned to the
+same material.
+
+Revision 1.5  2000/03/20 15:11:03  fca
+Mods to make the code compile on HP
+
+Revision 1.4  2000/01/18 16:12:08  morsch
+Bug in calculation of number of volume divisions and number of positionings corrected
+Browser for Material and Media properties added
+
+Revision 1.3  1999/11/14 14:31:14  fca
+Correct small error and remove compilation warnings on HP
+
+Revision 1.2  1999/11/10 16:53:35  fca
+The new geometry viewer from A.Morsch
+
+*/
+
+/* 
+ *  Version: 0
+ *  Written by Andreas Morsch
+ *  
+ * 
+ *
+ * For questions critics and suggestions to this part of the code
+ * contact andreas.morsch@cern.ch
+ * 
+ **************************************************************************/
+
+
+#include "AliGeant3GeometryGUI.h"
+#include "AliG3Volume.h"
+#include "AliG3Material.h"
+#include "AliG3Medium.h"
+#include "AliGuiGeomMain.h"
+#include "AliG3toRoot.h"
+
+#include <TArrayF.h>
+#include <TRotMatrix.h>
+#include <TGeometry.h>
+#include <TFile.h>
+#include <TFolder.h>
+
+AliG3Volume    *gCurrentVolume   = new AliG3Volume("NULL");
+AliG3Material  *gCurrentMaterial = new AliG3Material();
+AliG3Medium    *gCurrentMedium   = new AliG3Medium();
+
+ClassImp(AliGeant3GeometryGUI)
+
+    AliGeant3GeometryGUI::AliGeant3GeometryGUI(const char* opt)
+{
+    char tmp[20];
+    strcpy(tmp, opt);
+
+// Constructor
+    fPanel     = new AliGuiGeomMain(gClient->GetRoot(), 500, 500);
+//  Store local copy of zebra bank entries
+    AliG3toRoot* geometry = new AliG3toRoot();
+    if (strcmp(tmp, "expand") == 0) geometry->SetExpandDivisions();
+    geometry->G3toRoot();
+    //   geometry->ConvertToRootShapes();
+    
+    AliG3Volume* top = (AliG3Volume*) 
+       (geometry->GetTopFolder()->FindObject("ALIC"));
+    gCurrentVolume = top;
+//
+//  Mediate between g3 Geometry and GUI
+    fPanel->SetMaterialComboEntries(geometry->GetMaterials());
+    fPanel->SetMediaComboEntries(geometry->GetMedia());
+    fPanel->AddFoldersRecursively(geometry->GetTopFolder());
+    fPanel->Update();
+}
+
+void AliGeant3GeometryGUI::Streamer(TBuffer &)
+{
+// Dummy Streamer
+;
+}
+
+
+
+
+
diff --git a/AliGeant3/AliGeant3GeometryGUI.h b/AliGeant3/AliGeant3GeometryGUI.h
new file mode 100644 (file)
index 0000000..d47ac6e
--- /dev/null
@@ -0,0 +1,38 @@
+#ifndef ALIGEANT3GEOMETRYGUI_H
+#define ALIGEANT3GEOMETRYGUI_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+
+
+#include "TClonesArray.h"
+#include "TGeant3.h"
+
+class AliGuiGeomMain;
+class AliDrawVolume;
+class TRotMatrix;
+
+class AliGeant3GeometryGUI : public TObject {
+ public:
+    AliGeant3GeometryGUI(const char* opt = "");
+    virtual ~AliGeant3GeometryGUI(){}
+   private:
+    AliGuiGeomMain *fPanel;      // the main gui panel
+    Int_t          fNstack;      // number of volumes
+    TClonesArray   *fVolumes;    // array of volumes  
+    Int_t          fNMaterials;  // number of materials and media
+    TClonesArray   *fMaterials;  // array of materials
+    TClonesArray   *fMedia;      // array of materials
+    TObjArray      *fRotations;  // Rotation Matrices
+ private:
+    AliGeant3GeometryGUI(const AliGeant3GeometryGUI&) {}
+    AliGeant3GeometryGUI & operator=(const AliGeant3GeometryGUI&) 
+    {return *this;}
+    
+    ClassDef(AliGeant3GeometryGUI,1)  // GUI for Geant3 geometry visualisation
+};
+
+
+
+#endif
diff --git a/AliGeant3/AliGeant3LinkDef.h b/AliGeant3/AliGeant3LinkDef.h
new file mode 100644 (file)
index 0000000..6e5cffb
--- /dev/null
@@ -0,0 +1,46 @@
+#ifdef __CINT__
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+
+#pragma link off all globals;
+#pragma link off all classes;
+#pragma link off all functions;
+#pragma link C++ class  AliGuiGeomMain-;
+#pragma link C++ class  AliG3Volume+;
+#pragma link C++ class  AliGeant3GeometryGUI-;
+#pragma link C++ class  AliG3Material+;
+#pragma link C++ class  AliG3Medium-;
+#pragma link C++ class  AliNode+;
+#pragma link C++ class  AliG3toRoot+;
+
+/*
+#pragma link C++ class Quest_t+;
+#pragma link C++ class Gcbank_t+;
+#pragma link C++ class Gclink_t+;
+#pragma link C++ class Gcflag_t+;
+#pragma link C++ class Gckine_t+;
+#pragma link C++ class Gcking_t+;
+#pragma link C++ class Gckin2_t+;
+#pragma link C++ class Gckin3_t+;
+#pragma link C++ class Gcmate_t+;
+#pragma link C++ class Gctmed_t+;
+#pragma link C++ class Gctrak_t+;
+#pragma link C++ class Gcvolu_t+;
+#pragma link C++ class Gcsets_t+;
+#pragma link C++ class Gcnum_t+;
+#pragma link C++ class Gccuts_t+;
+#pragma link C++ class Gcmulo_t+;
+#pragma link C++ class Gcphys_t+;
+#pragma link C++ class Gcopti_t+;
+#pragma link C++ class Gctlit_t+;
+#pragma link C++ class Gcvdma_t+;
+#pragma link C++ class Gctpol_t+;
+#pragma link C++ class Ertrio_t+;
+#pragma link C++ class Eropts_t+;
+#pragma link C++ class Eroptc_t+;
+#pragma link C++ class Erwork_t+;
+*/
+#endif
diff --git a/AliGeant3/AliGuiGeomDialog.cxx b/AliGeant3/AliGuiGeomDialog.cxx
new file mode 100644 (file)
index 0000000..923727b
--- /dev/null
@@ -0,0 +1,457 @@
+/* *************************************************************************
+ * 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.2  2001/07/09 11:48:47  morsch
+Use AliG3Volume, AliG3Medium, AliG3Material
+
+Revision 1.1  2000/07/13 16:19:10  fca
+Mainly coding conventions + some small bug fixes
+
+Revision 1.8  2000/07/12 08:56:32  fca
+Coding convention correction and warning removal
+
+Revision 1.7  2000/06/28 21:27:45  morsch
+Most coding rule violations corrected.
+Still to do: Split the file (on file per class) ? Avoid the global variables.
+Copy constructors and assignment operators (dummy ?)
+
+Revision 1.6  2000/04/14 11:07:46  morsch
+Correct volume to medium assignment in case several media are asigned to the
+same material.
+
+Revision 1.5  2000/03/20 15:11:03  fca
+Mods to make the code compile on HP
+
+Revision 1.4  2000/01/18 16:12:08  morsch
+Bug in calculation of number of volume divisions and number of positionings corrected
+Browser for Material and Media properties added
+
+Revision 1.3  1999/11/14 14:31:14  fca
+Correct small error and remove compilation warnings on HP
+
+Revision 1.2  1999/11/10 16:53:35  fca
+The new geometry viewer from A.Morsch
+
+*/
+
+#include "TGButton.h"
+#include "TGTab.h"
+#include "TGComboBox.h"
+#include "TGDoubleSlider.h"
+
+#include "AliGuiGeomDialog.h"
+#include "AliGUISliders.h"
+#include "AliG3Volume.h"
+
+AliGuiGeomDialog::AliGuiGeomDialog(const TGWindow *p, const TGWindow *main, UInt_t w,
+                       UInt_t h, UInt_t options)
+    : TGTransientFrame(p, main, w, h, options)
+{
+   // Create a dialog window. A dialog window pops up with respect to its
+   // "main" window.
+
+   fFrame1 = new TGHorizontalFrame(this, 60, 20, kFixedWidth);
+
+   fOkButton = new TGTextButton(fFrame1, "&Ok", 1);
+   fOkButton->Associate(this);
+   fCancelButton = new TGTextButton(fFrame1, "&Cancel", 2);
+   fCancelButton->Associate(this);
+
+   fL1 = new TGLayoutHints(kLHintsTop | kLHintsLeft | kLHintsExpandX,
+                           2, 2, 2, 2);
+   fL2 = new TGLayoutHints(kLHintsBottom | kLHintsRight, 2, 2, 5, 1);
+
+   fFrame1->AddFrame(fOkButton, fL1);
+   fFrame1->AddFrame(fCancelButton, fL1); 
+
+   fFrame1->Resize(150, fOkButton->GetDefaultHeight());
+   AddFrame(fFrame1, fL2);
+
+   //--------- create Tab widget and some composite frames for Tab testing
+
+   fTab = new TGTab(this, 300, 300);
+   fL3 = new TGLayoutHints(kLHintsTop | kLHintsLeft, 5, 5, 5, 5);
+//
+// Tab1: Sliders
+//
+   TGCompositeFrame *tf = fTab->AddTab("Draw");
+   fF1 = new AliGUISliders(tf, this, 60, 20);
+   tf->AddFrame(fF1,fL3);
+   
+// 
+// Tab2: Drawing Options
+//
+   tf = fTab->AddTab("Options");
+   fL1 = new TGLayoutHints(kLHintsTop | kLHintsLeft | kLHintsExpandX,
+                           200, 2, 2, 2);
+   fF2 = new TGCompositeFrame(tf, 60, 20, kVerticalFrame);
+
+   fF2->AddFrame(fChk1 = new TGCheckButton(fF2, "Shadow", 86), fL3);
+   fF2->AddFrame(fChk2 = new TGCheckButton(fF2, "Hide  ", 87), fL3);
+   fF2->AddFrame(fChk3 = new TGCheckButton(fF2, "Clip  ", 88), fL3);
+
+   fF2->AddFrame(fLabel1 = new TGLabel(fF2, "Fill"),fL3);
+   
+   fCombo = new TGComboBox(fF2, 89);
+   fF2->AddFrame(fCombo, fL3);
+
+   tf->AddFrame(fF2, fL3);
+
+   int i;
+   for (i = 0; i < 8; i++) {
+      char tmp[20];
+
+      sprintf(tmp, "%i", i+1);
+      fCombo->AddEntry(tmp, i+1);
+   }
+   fCombo->Select(1);
+   fCombo->Resize(50, 20);
+   fCombo->Associate(this);
+
+   fChk1->Associate(this);
+   fChk2->Associate(this);
+   fChk3->Associate(this);
+// 
+// Tab3: Seen Option
+//
+   tf = fTab->AddTab("Seen");
+   fF3 = new TGCompositeFrame(tf, 60, 20, kVerticalFrame);
+   fF3->AddFrame(fLabel2 = new TGLabel(fF3, "Seen"),fL3);
+   fCombo2 = new TGComboBox(fF3, 90);
+   fF3->AddFrame(fCombo2, fL3);
+   tf->AddFrame(fF3, fL3);
+
+   for (i = 0; i < 4; i++) {
+      char tmp[20];
+
+      sprintf(tmp, "%i", i-2);
+      fCombo2->AddEntry(tmp, i+1);
+   }
+   fCombo2->Select(4);
+   fCombo2->Resize(50, 20);
+   fCombo2->Associate(this);
+// 
+// Tab4: Clip Box
+//
+   tf = fTab->AddTab("ClipBox");
+   //--- layout for buttons: top align, equally expand horizontally
+   fBly = new TGLayoutHints(kLHintsTop | kLHintsExpandY, 5, 5, 5, 5);
+
+   //--- layout for the frame: place at bottom, right aligned
+   fBfly1 = new TGLayoutHints(kLHintsLeft | kLHintsExpandX );
+//
+//  Frames
+//
+//  Slider1
+   fF4 = new TGCompositeFrame(tf, 60, 20, kVerticalFrame);
+       
+   fHSframe1 = new TGHorizontalFrame(fF4, 400, 100, kFixedWidth);
+
+   fTbh11 = new TGTextBuffer(10);
+   fTeh11 = new TGTextEntry(fHSframe1, fTbh11,1);
+   fTbh11->AddText(0, "   0");
+   fTeh11->Associate(this);
+
+   fTbh12 = new TGTextBuffer(10);
+   fTeh12 = new TGTextEntry(fHSframe1, fTbh12,1);
+   fTbh12->AddText(0, "2000");
+   fTeh12->Associate(this);
+    
+   fDslider1 = new TGDoubleHSlider(fHSframe1, 400, kSlider1 | kScaleBoth, 1);
+   fDslider1->Associate(this);
+   fDslider1->SetRange(-2000, 2000);
+   fDslider1->SetPosition(0, 2000);
+   
+   fSLabel1 = new TGLabel(fHSframe1, "xmin-xmax");
+
+   fHSframe1->AddFrame(fSLabel1, fBfly1);
+   fHSframe1->AddFrame(fTeh11, fBfly1);
+   fHSframe1->AddFrame(fTeh12, fBfly1);
+   fHSframe1->AddFrame(fDslider1, fBfly1);
+   
+   fF4->AddFrame(fHSframe1, fBly);
+
+//
+   fHSframe2 = new TGHorizontalFrame(fF4, 400, 100, kFixedWidth);
+
+   fTbh21 = new TGTextBuffer(10);
+   fTeh21 = new TGTextEntry(fHSframe2, fTbh21,1);
+   fTbh21->AddText(0, "   0");
+   fTeh21->Associate(this);
+
+   fTbh22 = new TGTextBuffer(10);
+   fTeh22 = new TGTextEntry(fHSframe2, fTbh22,1);
+   fTbh22->AddText(0, "2000");
+   fTeh22->Associate(this);
+
+   fDslider2 = new TGDoubleHSlider(fHSframe2, 400, kSlider1 | kScaleBoth, 2);
+   fDslider2->Associate(this);
+   fDslider2->SetRange(-2000, 2000);
+   fDslider2->SetPosition(0, 2000);
+   
+   fSLabel2 = new TGLabel(fHSframe2, "ymin-ymax");
+
+   fHSframe2->AddFrame(fSLabel2, fBfly1);
+   fHSframe2->AddFrame(fTeh21, fBfly1);
+   fHSframe2->AddFrame(fTeh22, fBfly1);
+   fHSframe2->AddFrame(fDslider2, fBfly1);
+   
+   fF4->AddFrame(fHSframe2, fBly);
+
+//
+   fHSframe3 = new TGHorizontalFrame(fF4, 400, 100, kFixedWidth);
+
+   fTbh31 = new TGTextBuffer(10);
+   fTeh31 = new TGTextEntry(fHSframe3, fTbh31,1);
+   fTbh31->AddText(0, "   0");
+   fTeh31->Associate(this);
+
+   fTbh32 = new TGTextBuffer(10);
+   fTeh32 = new TGTextEntry(fHSframe3, fTbh32,1);
+   fTbh32->AddText(0, "2000");
+   fTeh32->Associate(this);
+
+   fDslider3 = new TGDoubleHSlider(fHSframe3, 400, kSlider1 | kScaleBoth, 3);
+   fDslider3->Associate(this);
+   fDslider3->SetRange(-2000, 2000);
+   fDslider3->SetPosition(0, 2000);
+   
+   fSLabel3 = new TGLabel(fHSframe3, "zmin-zmax");
+
+   fHSframe3->AddFrame(fSLabel3, fBfly1);
+   fHSframe3->AddFrame(fTeh31, fBfly1);
+   fHSframe3->AddFrame(fTeh32, fBfly1);
+   fHSframe3->AddFrame(fDslider3, fBfly1);
+   
+   fF4->AddFrame(fHSframe3, fBly);
+   tf->AddFrame(fF4, fL3);
+//
+//
+   TGLayoutHints *fL5 = new TGLayoutHints(kLHintsBottom | kLHintsExpandX |
+                                          kLHintsExpandY, 2, 2, 5, 1);
+   AddFrame(fTab, fL5);
+
+   MapSubwindows();
+   Resize(GetDefaultSize());
+
+   // position relative to the parent's window
+   Window_t wdum;
+   int ax, ay;
+   gVirtualX->TranslateCoordinates(main->GetId(), GetParent()->GetId(),
+                          (((TGFrame *) main)->GetWidth() - fWidth) >> 1,
+                          (((TGFrame *) main)->GetHeight() - fHeight) >> 1,
+                          ax, ay, wdum);
+   Move(ax, ay);
+
+   SetWindowName("Dialog");
+
+   MapWindow();
+   //gClient->WaitFor(this);    // otherwise canvas contextmenu does not work
+}
+
+AliGuiGeomDialog::~AliGuiGeomDialog()
+{
+   // Delete test dialog widgets.
+
+   delete fOkButton;
+   delete fCancelButton;
+   delete fFrame1;
+   delete fChk1; delete fChk2;
+   delete fF1; delete fF2; delete fF3; delete fF4;
+   delete fCombo;
+   delete fTab;
+   delete fL3; delete fL4;
+   delete fL1; delete fL2;
+   delete fBly; delete fBfly1;
+   delete fTbh11; delete fTbh12; delete fTbh21; delete fTbh22; 
+   delete fTbh31; delete fTbh32; delete fTeh11; delete fTeh12; 
+   delete fTeh21; delete fTeh22; delete fTeh31; delete fTeh32;
+   delete fDslider1; delete fDslider2; delete fDslider3;
+   delete fSLabel1;  delete fSLabel2;  delete fSLabel3;
+}
+
+void AliGuiGeomDialog::Update()
+{
+// Update widgets
+    
+    Float_t param;
+//  Update Sliders
+    if (fF1) {
+       fF1->Update();
+    }
+//  Seen
+    if (fCombo2) {
+       param=gCurrentVolume->GetParam(kSeen);
+       fCombo2->Select(Int_t(param)+3);
+    }
+//  Hide, Shadow, Clip
+    if (fChk1) {
+       if (Int_t(gCurrentVolume->GetParam(kShadow))) {
+           fChk1->SetState(kButtonDown);
+       } else {
+           fChk1->SetState(kButtonUp);
+       }
+    }
+
+    if (fChk2) {
+       if (Int_t(gCurrentVolume->GetParam(kHide))) {
+           fChk2->SetState(kButtonDown);
+       } else {
+           fChk2->SetState(kButtonUp);
+       }
+    }
+
+    if (fChk3) {
+       if (Int_t(gCurrentVolume->GetParam(kClip))) {
+           fChk3->SetState(kButtonDown);
+       } else {
+           fChk3->SetState(kButtonUp);
+       }
+    }
+    
+}
+
+void AliGuiGeomDialog::CloseWindow()
+{
+   // Called when window is closed via the window manager.
+   delete this;
+}
+
+Bool_t AliGuiGeomDialog::ProcessMessage(Long_t msg, Long_t parm1, Long_t parm2)
+{
+   // Process messages coming from widgets associated with the dialog.
+    char buf[10];
+    Float_t min,max;
+    switch (GET_MSG(msg)) {
+    case kC_HSLIDER:
+       switch (GET_SUBMSG(msg)) {
+       case kSL_POS:
+           switch (Int_t(parm1)) {
+           case 1:
+               min=fDslider1->GetMinPosition();
+               max=fDslider1->GetMaxPosition();
+               sprintf(buf, "%6.2f", min);
+               fTbh11->Clear();
+               fTbh11->AddText(0, buf);
+               sprintf(buf, "%6.2f", max);
+               fTbh12->Clear();
+               fTbh12->AddText(0, buf);
+               gClient->NeedRedraw(fTeh11);
+               gClient->NeedRedraw(fTeh12);
+               gCurrentVolume->SetParam(kClipXmin,min);
+               gCurrentVolume->SetParam(kClipXmax,max);
+               break;
+           case 2:
+               min=fDslider2->GetMinPosition();
+               max=fDslider2->GetMaxPosition();
+               sprintf(buf, "%6.2f", min);
+               fTbh21->Clear();
+               fTbh21->AddText(0, buf);
+               sprintf(buf, "%6.2f", max);
+               fTbh22->Clear();
+               fTbh22->AddText(0, buf);
+               gClient->NeedRedraw(fTeh21);
+               gClient->NeedRedraw(fTeh22);
+               gCurrentVolume->SetParam(kClipYmin,min);
+               gCurrentVolume->SetParam(kClipYmax,max);
+               break;
+           case 3:
+               min=fDslider3->GetMinPosition();
+               max=fDslider3->GetMaxPosition();
+               sprintf(buf, "%6.2f", min);
+               fTbh31->Clear();
+               fTbh31->AddText(0, buf);
+               sprintf(buf, "%6.2f", max);
+               fTbh32->Clear();
+               fTbh32->AddText(0, buf);
+               gClient->NeedRedraw(fTeh31);
+               gClient->NeedRedraw(fTeh32);
+               gCurrentVolume->SetParam(kClipZmin,min);
+               gCurrentVolume->SetParam(kClipZmax,max);
+               break;
+           default:
+               break;
+           }
+       }
+       break;
+    case kC_COMMAND:
+       switch (GET_SUBMSG(msg)) {
+       case kCM_BUTTON:
+           switch(parm1) {
+           case 1:
+           case 2:
+               printf("\nTerminating dialog: %s pressed\n",
+                      (parm1 == 1) ? "OK" : "Cancel");
+               CloseWindow();
+               break;
+           }
+           break;
+       case kCM_COMBOBOX:
+           switch(parm1) {
+           case 89:
+               gCurrentVolume->SetParam(kFill, Float_t(parm2));
+               gCurrentVolume->Draw();
+               break;
+           case 90:
+               gCurrentVolume->SetParam(kSeen, Float_t(parm2-3));
+               gCurrentVolume->Draw();
+               break;
+           }
+           break;
+       case kCM_CHECKBUTTON:
+           switch (parm1) {
+           case 86:
+               if (Int_t(gCurrentVolume->GetParam(kShadow))) {
+                   gCurrentVolume->SetParam(kShadow, 0.);
+               } else {
+                   gCurrentVolume->SetParam(kShadow, 1.);
+               }
+               gCurrentVolume->Draw();
+               break;
+           case 87:
+               if (Int_t(gCurrentVolume->GetParam(kHide))) {
+                   gCurrentVolume->SetParam(kHide, 0.);
+               } else {
+                   gCurrentVolume->SetParam(kHide, 1.);
+               }
+               gCurrentVolume->Draw();
+               break;
+           case 88:
+               if (Int_t(gCurrentVolume->GetParam(kClip))) {
+                   gCurrentVolume->SetParam(kClip, 0.);
+               } else {
+                   gCurrentVolume->SetParam(kClip, 1.);
+               }
+               gCurrentVolume->Draw();
+               break;
+
+           default:
+               break;
+           }
+           break;
+       case kCM_TAB:
+           break;
+       default:
+           break;
+       }
+       break;
+    default:
+       break;
+    }
+    return kTRUE;
+}
+
diff --git a/AliGeant3/AliGuiGeomDialog.h b/AliGeant3/AliGuiGeomDialog.h
new file mode 100644 (file)
index 0000000..7c5e679
--- /dev/null
@@ -0,0 +1,55 @@
+#ifndef ALIGUIGEOMDIALOG_H
+#define ALIGUIGEOMDIALOG_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+
+#include "TGFrame.h"
+
+class AliGUISliders;
+class TGButton;
+class TGComboBox;
+class TGLabel;
+class TGTab;
+class TGTextBuffer;
+class TGTextEntry;
+class TGDoubleHSlider;
+class AliG3Volume;
+
+class AliGuiGeomDialog : public TGTransientFrame {
+public:
+   AliGuiGeomDialog(const TGWindow *p, const TGWindow *main, UInt_t w, UInt_t h,
+               UInt_t options = kMainFrame | kVerticalFrame);
+   virtual ~AliGuiGeomDialog();
+// Destroy this window
+   virtual void CloseWindow();
+// Process messages from this window    
+   virtual Bool_t ProcessMessage(Long_t msg, Long_t parm1, Long_t parm2);
+// Update widgets   
+   virtual void Update();
+private:
+    AliGUISliders       *fF1;                                          // Slider for Draw Control
+    TGCompositeFrame    *fFrame1, *fF2, *fF3, *fF4;                            // Outer frames
+    TGButton            *fOkButton, *fCancelButton;                            // Buttons
+    TGButton            *fChk1, *fChk2, *fChk3;                                // Buttons
+    TGComboBox          *fCombo, *fCombo2;                                     // Combo Boxes
+    TGLabel             *fLabel1, *fLabel2;                                    // Labels
+    TGTab               *fTab;                                                 // Tab Entries
+    TGLayoutHints       *fL1, *fL2, *fL3, *fL4, *fBly, *fBfly1;                // Layout hints
+    TGHorizontalFrame   *fHSframe1, *fHSframe2, *fHSframe3;                    // Horizontal frames
+    TGTextBuffer        *fTbh11, *fTbh12, *fTbh21, *fTbh22, *fTbh31, *fTbh32;  // Text buffers
+    TGTextEntry         *fTeh11, *fTeh12, *fTeh21, *fTeh22, *fTeh31, *fTeh32;  // Text Entries
+    TGDoubleHSlider     *fDslider1, *fDslider2, *fDslider3;                    // Sliders for clip box
+    TGLabel             *fSLabel1,  *fSLabel2,  *fSLabel3;                     // Labels
+
+private:
+  AliGuiGeomDialog(const AliGuiGeomDialog& gd):
+    TGTransientFrame((const TGTransientFrame&)gd) {}
+  virtual AliGuiGeomDialog & operator=(const AliGuiGeomDialog &) 
+  {return *this;}
+};
+
+R__EXTERN AliG3Volume  *gCurrentVolume;
+
+#endif
diff --git a/AliGeant3/AliGuiGeomMain.cxx b/AliGeant3/AliGuiGeomMain.cxx
new file mode 100644 (file)
index 0000000..4a5d5e5
--- /dev/null
@@ -0,0 +1,929 @@
+/* *************************************************************************
+ * 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 strictlSy 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.5  2002/03/19 09:36:17  morsch
+Unnecessary includes removes, one included. (Jacek M. Holeczek)
+
+Revision 1.4  2001/07/18 14:59:13  morsch
+Unactive code in dialog removed (caused compiling problems with ROOT 3.01/06)
+
+Revision 1.3  2001/07/17 09:50:21  morsch
+Index on media and material arrays corrected
+
+Revision 1.2  2001/07/09 11:46:08  morsch
+Conversion code moved to AliG3toRoot
+
+Revision 1.1  2000/07/13 16:19:10  fca
+Mainly coding conventions + some small bug fixes
+
+Revision 1.8  2000/07/12 08:56:32  fca
+Coding convention correction and warning removal
+
+Revision 1.7  2000/06/28 21:27:45  morsch
+Most coding rule violations corrected.
+Still to do: Split the file (on file per class) ? Avoid the global variables.
+Copy constructors and assignment operators (dummy ?)
+
+Revision 1.6  2000/04/14 11:07:46  morsch
+Correct volume to medium assignment in case several media are asigned to the
+same material.
+
+Revision 1.5  2000/03/20 15:11:03  fca
+Mods to make the code compile on HP
+
+Revision 1.4  2000/01/18 16:12:08  morsch
+Bug in calculation of number of volume divisions and number of positionings corrected
+Browser for Material and Media properties added
+
+Revision 1.3  1999/11/14 14:31:14  fca
+Correct small error and remove compilation warnings on HP
+
+Revision 1.2  1999/11/10 16:53:35  fca
+The new geometry viewer from A.Morsch
+
+*/
+
+/* 
+ *  Version: 0
+ *  Written by Andreas Morsch
+ *  
+ * 
+ *
+ * For questions critics and suggestions to this part of the code
+ * contact andreas.morsch@cern.ch
+ * 
+ **************************************************************************/
+
+#include <stdlib.h>
+#include <TArrayF.h>
+#include <TGMsgBox.h>
+#include <TGMenu.h>
+#include <TGTab.h>
+#include <TGFrame.h>
+#include <TGTextBuffer.h>
+#include <TGTextEntry.h>
+#include <TGLabel.h>
+#include <TGButton.h>
+#include <TGraph.h>
+#include <TCanvas.h>
+#include <TH1.h>
+#include <TApplication.h>
+#include <TGFileDialog.h>
+#include <TGListTree.h>
+#include <TGeant3.h>
+#include <TShape.h>
+#include <TGeometry.h>
+#include <TBRIK.h>
+#include <TGeometry.h>
+#include <TList.h>
+#include <TFile.h>
+#include <TFolder.h>
+
+#include "AliGuiGeomMain.h"
+#include "AliGuiGeomDialog.h"
+#include "AliG3Volume.h"
+#include "AliG3Medium.h"
+#include "AliG3Material.h"
+#include "AliNode.h"
+
+
+ClassImp(AliGuiGeomMain)
+
+static Int_t           gCurrentParticle = 1;
+static Int_t           gCurrentProcess  = 1;
+
+ const Text_t* kLabelTextP[19]  = 
+{"PAIR  ", "COMP  ", "PHOT  ", "PFIS  ", "DRAY  ", "ANNI  ", "BREM  ", 
+ "HADR  ", "MUNU  ", "DCAY  ", "LOSS  ", "MULS  ", "GHCOR1", "BIRK1 ", 
+ "BIRK2 ", "BIRK3 ", "LABS  ", "SYNC  ", "STRA  "};
+
+
+ const Text_t* kLabelTextC[10]  = 
+ {"CUTGAM", "CUTELE", "CUTNEU", "CUTHAD", "CUTMUO", "BCUTE", "BCUTM",
+  "DCUTE ", "DCUTM ", "PPCUTM"};
+
+const Text_t* kLabelTextPart[24]  = 
+{"Photon", "Positron", "Electron", "Neutrino", "Muon+", "Muon-", 
+ "Pi0", "Pi+", "Pi-", "Kaon_L", "Kaon+", "Kaon-", "Neutron", "Proton", 
+ "Anti Proton", "Kaon_S", "Eta", "Lambda", "Sigma+", "Sigma0", "Sigma-",
+ "Xi0", "Xi-", "Omega-"};
+
+const Text_t* kLabelTextMechanism[24]  = 
+{"HADF", "INEF", "ELAF", "FISF", "CAPF",
+ "HADG", "INEG", "ELAG", "FISG", "CAPG",
+ "LOSS", "PHOT", "ANNI", "COMP", "BREM",
+ "PAIR", "DRAY", "PFIS", "RAYL", "HADG",
+ "MUNU", "RANG", "STEP", "MUON"};
+
+
+
+
+enum ETestCommandIdentifiers {
+   kFileOpen,
+   kFileSave,
+   kFileSaveAs,
+   kFileExit,
+
+   kTestDlg,
+
+   kHelpContents,
+   kHelpSearch,
+   kHelpAbout,
+
+
+   kVId1,
+   kHId1,
+   kVId2,
+   kHId2,
+
+   kVSId1,
+   kHSId1,
+   kVSId2,
+   kHSId2
+};
+
+
+Int_t mbButtonId[9] = { kMBYes, kMBNo, kMBOk, kMBApply,
+                          kMBRetry, kMBIgnore, kMBCancel,
+                          kMBClose, kMBDismiss };
+
+EMsgBoxIcon mbIcon[4] = { kMBIconStop, kMBIconQuestion,
+                           kMBIconExclamation, kMBIconAsterisk };
+
+const char *kFileTypes[] = { "All files",     "*",
+                            "ROOT files",    "*.root",
+                            "ROOT macros",   "*.C",
+                            0,               0 };
+
+
+
+
+TGListTreeItem*  AliGuiGeomMain::
+AddItem(TObject * obj, TGListTreeItem *parent, const char* name, const TGPicture *open, const TGPicture *closed)
+{
+// Add item to the list tree
+    return fLt->AddItem(parent, name, obj, open, closed);
+}
+
+AliGuiGeomMain::AliGuiGeomMain(const TGWindow *p, UInt_t w, UInt_t h)
+      : TGMainFrame(p, w, h)
+{
+    // Create test main frame. A TGMainFrame is a top level window.
+    // Create menubar and popup menus. The hint objects are used to place
+    // and group the different menu widgets with respect to eachother.
+    
+    fDialog=0;
+    fMenuBarLayout = new TGLayoutHints(kLHintsTop | kLHintsLeft | kLHintsExpandX,
+                                      0, 0, 1, 1);
+    fMenuBarItemLayout = new TGLayoutHints(kLHintsTop | kLHintsLeft, 0, 4, 0, 0);
+    fMenuBarHelpLayout = new TGLayoutHints(kLHintsTop | kLHintsRight);
+    
+    fMenuFile = new TGPopupMenu(gClient->GetRoot());
+    fMenuFile->AddEntry("&Open...", kFileOpen);
+    fMenuFile->AddEntry("&Save", kFileSave);
+    fMenuFile->AddEntry("S&ave as...", kFileSaveAs);
+    fMenuFile->AddEntry("&Close", -1);
+    fMenuFile->AddSeparator();
+    fMenuFile->AddEntry("E&xit", kFileExit);
+    
+    fMenuFile->DisableEntry(kFileSaveAs);
+    fMenuFile->DisableEntry(kFileOpen);
+    fMenuFile->DisableEntry(kFileSave);
+    
+
+
+   fMenuTest = new TGPopupMenu(this);
+   fMenuTest->AddLabel("Draw");
+   fMenuTest->AddSeparator();
+   fMenuTest->AddEntry("&Volume Draw Control", kTestDlg);
+   fMenuTest->AddSeparator();
+   fMenuTest->Associate(this);
+   
+   
+   fMenuHelp = new TGPopupMenu(gClient->GetRoot());
+   fMenuHelp->AddEntry("&Contents", kHelpContents);
+   fMenuHelp->AddEntry("&Search...", kHelpSearch);
+   fMenuHelp->AddSeparator();
+   fMenuHelp->AddEntry("&About", kHelpAbout);
+
+   fMenuFile->DisableEntry(kHelpContents);
+   fMenuFile->DisableEntry(kHelpSearch);
+   fMenuFile->DisableEntry(kHelpAbout);
+   // Menu button messages are handled by the main frame (i.e. "this")
+   // ProcessMessage() method.
+   fMenuFile->Associate(this);
+   fMenuTest->Associate(this);
+   fMenuHelp->Associate(this);
+
+   fMenuBar = new TGMenuBar(this, 1, 1, kHorizontalFrame);
+   fMenuBar->AddPopup("&File", fMenuFile, fMenuBarItemLayout);
+   fMenuBar->AddPopup("&Draw Control", fMenuTest, fMenuBarItemLayout);
+   fMenuBar->AddPopup("&Help", fMenuHelp, fMenuBarHelpLayout);
+
+   AddFrame(fMenuBar, fMenuBarLayout);
+
+// 
+// Volumes
+//
+   fTab = new TGTab(this, 400, 400);
+   TGCompositeFrame *tf = fTab->AddTab("Volumes");
+   TGLayoutHints *lTab = new TGLayoutHints(kLHintsBottom | kLHintsExpandX |
+                                          kLHintsExpandY, 2, 2, 5, 1);
+   AddFrame(fTab, lTab);
+
+// Create TGCanvas and a canvas container which uses a tile layout manager
+   fCanvasWindow = new TGCanvas(tf, 400, 240);
+// Create TreeList
+   fLt = new TGListTree(fCanvasWindow->GetViewPort(), 10, 10, kHorizontalFrame,
+                        fgWhitePixel);
+   fLt->Associate(this);
+   fCanvasWindow->SetContainer(fLt);
+
+    
+   TGLayoutHints *lo = new TGLayoutHints(kLHintsExpandX | kLHintsExpandY);
+   tf->AddFrame(fCanvasWindow, lo);
+//
+// Materials
+//
+   tf = fTab->AddTab("Materials");
+   fF2 = new TGCompositeFrame(tf, 60, 20, kHorizontalFrame);
+   fL2 = new TGLayoutHints(kLHintsTop | kLHintsLeft, 5, 5, 5, 5);
+// ComboBox for materials
+   fMaterialCombo = new TGComboBox(fF2, 1);
+   fF2->AddFrame(fMaterialCombo, fL2);
+// 
+// text labels with material properties 
+//
+   Text_t* labelText[6]  = 
+   {"Material Number  ", 
+    "Atomic Weight    ",
+    "Atomic Number    ", 
+    "Density          ",
+    "Radiation Length ", 
+    "Absorption Length"};
+
+   TGLayoutHints* bly   = 
+       new TGLayoutHints(kLHintsTop | kLHintsExpandY, 5, 5, 5, 5);
+   TGLayoutHints* bFly1 = 
+       new TGLayoutHints(kLHintsLeft | kLHintsExpandX );
+   fF21 = new TGCompositeFrame(fF2, 60, 20, kVerticalFrame);
+   fF2->AddFrame(fF21,fL2);
+   { //Begin local scope for i
+     for (Int_t i=0; i<6; i++) {
+       Int_t idT=i+1;       
+       fHframe[i] = new TGHorizontalFrame(fF21, 400, 100, kFixedWidth);
+       fF21->AddFrame(fHframe[i], bly);
+       fTbh[i] = new TGTextBuffer(10);
+       fTeh[i] = new TGTextEntry(fHframe[i], fTbh[i],idT);
+       fTeh[i]->Associate(this);
+       fLabel[i] = new TGLabel(fHframe[i], labelText[i]);
+       fHframe[i]->AddFrame(fLabel[i], bFly1);
+       fHframe[i]->AddFrame(fTeh[i], bFly1);
+     }
+   } //End local scope for i
+   tf->AddFrame(fF2, fL2);
+   fMaterialCombo->Resize(200, 20);
+   fMaterialCombo->Associate(this);
+   
+
+// Media Combo
+//   
+   tf = fTab->AddTab("Media");
+   fF3 = new TGCompositeFrame(tf, 60, 20, kHorizontalFrame);
+// ComboBox for tracking media
+   fMediaCombo = new TGComboBox(fF3, 2);
+   fF3->AddFrame(fMediaCombo, fL2);
+// 
+// text labels with material properties 
+//
+   Text_t* labelTextM[8]  = 
+   {"Sensitivity Flag      ", 
+    "Magnetic Field Flag   ",
+    "Maximum Field         ", 
+    "Max. Ang. Deviation   ",
+    "Maximum Step          ", 
+    "Max. Frac. Energy Loss",
+    "Crossing Precission   ",
+    "Minimum Step Size     "};
+
+   fF31 = new TGCompositeFrame(fF3, 60, 20, kVerticalFrame);
+   fF3->AddFrame(fF31,fL2);
+   { //Begin local scope for i
+     for (Int_t i=0; i<8; i++) {
+       Int_t idT=i+1;       
+       fHframeM[i] = new TGHorizontalFrame(fF31, 400, 100, kFixedWidth);
+       fF31->AddFrame(fHframeM[i], bly);
+       fTbhM[i] = new TGTextBuffer(10);
+       fTehM[i] = new TGTextEntry(fHframeM[i], fTbhM[i],idT);
+       fTehM[i]->Associate(this);
+       fLabelM[i] = new TGLabel(fHframeM[i], labelTextM[i]);
+       fHframeM[i]->AddFrame(fLabelM[i], bFly1);
+       fHframeM[i]->AddFrame(fTehM[i], bFly1);
+     }
+   } //End local scope for i
+   tf->AddFrame(fF3, fL2);
+   fMediaCombo->Resize(200, 20);
+   fMediaCombo->Associate(this);
+//
+// Processes
+   tf = fTab->AddTab("Processes");
+   fF4 = new TGCompositeFrame(tf, 60, 20, kHorizontalFrame);
+   fProcessLB = new TGListBox(fF4, 1);
+   fF4->AddFrame(fProcessLB, fL2);
+   tf->AddFrame(fF4, fL2);
+   fProcessLB->Resize(150, 350);
+   fProcessLB->Associate(this);
+   
+//
+// Cuts
+   tf = fTab->AddTab("Cuts");
+   fF5 = new TGCompositeFrame(tf, 60, 20, kHorizontalFrame);
+   fCutsLB = new TGListBox(fF5, 1);
+   fF5->AddFrame(fCutsLB, fL2);
+   tf->AddFrame(fF5, fL2);
+   fCutsLB->Resize(150, 350);
+
+//
+// de/dx and cross-sections
+   tf = fTab->AddTab("DE/DX and X-Sections");
+   fF6 = new TGCompositeFrame(tf, 60, 20, kHorizontalFrame);
+
+// ComboBox for particles
+   fF61 = new TGCompositeFrame(fF6, 60, 20, kVerticalFrame);
+   fF6->AddFrame(fF61, fL2);
+   fParticleCombo = new TGComboBox(fF61, 3);
+   fF61->AddFrame(fParticleCombo, fL2);
+   { //Begin local scope for i
+     for (Int_t i = 0; i < 24; i++) {
+       char tmp[20];
+       sprintf(tmp, "%s", kLabelTextPart[i]);
+       fParticleCombo->AddEntry(tmp, i+1);
+     }
+   } //End local scope for i
+   fParticleCombo->Select(1);
+   fParticleCombo->Resize(100, 20);
+   fParticleCombo->Associate(this);
+
+// ComboBox for mechanisms
+   fF63 = new TGCompositeFrame(fF6, 60, 20, kVerticalFrame);
+   fF6->AddFrame(fF63, fL2);
+   fMechanismCombo = new TGComboBox(fF63, 4);
+   fF63->AddFrame(fMechanismCombo, fL2);
+   { //Begin local scope for i
+     for (Int_t i = 0; i < 24; i++) {
+       char tmp[20];
+       sprintf(tmp, "%s", kLabelTextMechanism[i]);
+       fMechanismCombo->AddEntry(tmp, i+1);
+     }
+   } //End local scope for i
+   fMechanismCombo->Select(1);
+   fMechanismCombo->Resize(100, 20);
+   fMechanismCombo->Associate(this);
+
+//
+// Energy Range
+//
+   fTbh61 = new TGTextBuffer(10);
+   fTeh61 = new TGTextEntry(fF61, fTbh61,10);
+   fTbh61->AddText(0, "  100");
+   fTeh61->Associate(this);
+
+   fTbh62 = new TGTextBuffer(10);
+   fTeh62 = new TGTextEntry(fF61, fTbh62,11);
+   fTbh62->AddText(0, "0.001");
+   fTeh62->Associate(this);
+    
+   fTbh63 = new TGTextBuffer(10);
+   fTeh63 = new TGTextEntry(fF61, fTbh63,12);
+   fTbh63->AddText(0, "10.");
+   fTeh63->Associate(this);
+
+   fEmin=0.001;
+   fEmax=10.;
+   fNbins=100;
+   
+   fSLabel61 = new TGLabel(fF61, "Nbins-Emin-Emax");
+   bFly1 = new TGLayoutHints(kLHintsLeft | kLHintsExpandX );
+   fF61->AddFrame(fSLabel61, bFly1);
+   fF61->AddFrame(fTeh61, bFly1);
+   fF61->AddFrame(fTeh62, bFly1);
+   fF61->AddFrame(fTeh63, bFly1);
+//
+// Plot Button
+   fF62 = new TGCompositeFrame(fF6, 60, 20, kHorizontalFrame);
+   fF6->AddFrame(fF62, fL2);
+   fPlotButton = new TGTextButton(fF62, "Plot", 1);
+   fPlotButton -> Associate(this);
+   fF62->AddFrame(fPlotButton);
+
+   tf->AddFrame(fF6, fL2);
+// Window name and final mapping
+//
+   SetWindowName("AliRoot Geometry Browser");
+   MapSubwindows();
+   // We need to use GetDefault...() to initialize the layout algorithm...
+   Resize(GetDefaultSize());
+   MapWindow();
+}
+
+AliGuiGeomMain::~AliGuiGeomMain()
+{
+   // Delete all created widgets.
+
+   delete fCanvasWindow;
+
+   delete fMenuBarLayout;
+   delete fMenuBarItemLayout;
+   delete fMenuBarHelpLayout;
+
+   delete fMenuFile;
+   delete fMenuTest;
+   delete fMenuHelp;
+}
+
+void AliGuiGeomMain::Streamer(TBuffer &)
+{
+// Dummy streamer
+;
+}
+
+void AliGuiGeomMain::Plot()
+{
+// plot de/dx or cross-sections
+    const Float_t kAvo=0.60221367;
+    Float_t *tkin  = new Float_t[fNbins];
+    Float_t *value = new Float_t[fNbins];
+    Float_t *pcut  = new Float_t[fNbins];
+    Int_t ixst;
+    Int_t imate = gCurrentMaterial->Id();
+    Float_t z = gCurrentMaterial->GetZ();
+    Float_t a = gCurrentMaterial->GetA();
+    Float_t density = gCurrentMaterial->GetDensity();
+    
+    Int_t ipart=gCurrentParticle;
+    const char *kChMeca= kLabelTextMechanism[gCurrentProcess-1];
+    char* tmp;
+    tmp = new char[5];
+    strncpy(tmp, kChMeca, 4);
+    tmp[4]='\0';
+    Int_t kdim=fNbins;
+    Float_t de=(fEmax-fEmin)/fNbins;
+    { //Begin local scope for i
+      for (Int_t i=0; i<kdim; i++) {
+       tkin[i]=fEmin+Float_t(i)*de;
+       value[i]=0.;
+      }
+    } //End local scope for i
+    if (kChMeca!="MUON") {
+       ((TGeant3*) gMC)->Gftmat(imate, ipart, tmp, kdim, tkin, value, pcut, ixst);
+    } else {
+       for (Int_t i=0; i<kdim; i++) {
+           Float_t ekin=tkin[i];
+           value[i]+=((TGeant3*) gMC)->Gbrelm(z,ekin,1.e10);
+           value[i]+=((TGeant3*) gMC)->Gprelm(z,ekin,1.e10);
+           value[i]*=1000.*kAvo*density/a;
+       }
+    }
+
+    if (ixst) {
+       TGraph *graph = new TGraph(kdim,tkin,value);
+       TCanvas *c1 = new TCanvas("c1"," ",400,10,600,700);
+       c1->Divide(1,1);
+       c1->cd(1);
+       
+       graph->SetFillColor(42);
+       graph->SetMarkerColor(4);
+       graph->SetMarkerStyle(21);
+       graph->Draw("AC");
+       graph->GetHistogram()->SetXTitle("Energy (GeV)");
+       if (kChMeca == "RANG" || kChMeca == "STEP") {
+           graph->GetHistogram()->SetYTitle
+               ("Distance (cm)");   
+       } else if (kChMeca == "LOSS" || kChMeca == "MUON") {
+           graph->GetHistogram()->SetYTitle("dE/dx (MeV/cm)");   
+       } else {
+           graph->GetHistogram()->SetYTitle
+               ("Macroscopic X-Section (1/cm)"); 
+       }
+    }
+    
+    delete tkin;
+    delete value;
+    delete pcut;
+    
+    
+}
+
+void AliGuiGeomMain::Update()
+{
+// Update widgets
+    if (fDialog) {
+       fDialog->Update();
+    }
+
+    Int_t imat=gCurrentVolume->Material();
+    Int_t nmat=fComboMaterialEntries->GetEntriesFast();
+    Int_t i=0;
+    for (i=0; i<nmat; i++) {
+       gCurrentMaterial = (AliG3Material*) 
+           (fComboMaterialEntries->UncheckedAt(i));
+       if ((gCurrentMaterial->Id())==imat) break;
+    }
+    Int_t imed = gCurrentVolume->Medium();
+    Int_t nmed=fComboMediaEntries->GetEntriesFast();
+    for (i=0; i<nmed; i++) {
+       gCurrentMedium = (AliG3Medium*) 
+           (fComboMediaEntries->UncheckedAt(i));
+       if (gCurrentMedium->Id()==imed) break;
+    }
+
+    UpdateCombo();
+    UpdateListBox();
+    
+}
+
+void AliGuiGeomMain::UpdateCombo()
+{
+// Update combos
+
+    Int_t   imat = gCurrentMaterial->Id();
+    Float_t    a = gCurrentMaterial->GetA();
+    Float_t    z = gCurrentMaterial->GetZ();    
+    Float_t dens = gCurrentMaterial->GetDensity();
+    Float_t radl = gCurrentMaterial->GetRadLength();
+    Float_t absl = gCurrentMaterial->GetInterLength();
+    Int_t entry  = gCurrentMaterial->GetNumber();
+//    
+//
+    fMaterialCombo->Select(entry);
+    fMediaCombo->Select(entry);    
+    char buf[10];
+     
+    sprintf(buf, "%10i", imat);
+    fTbh[0]->Clear();
+    fTbh[0]->AddText(0, buf);
+    gClient->NeedRedraw(fTeh[0]);
+    sprintf(buf, "%10.2e", a);
+    fTbh[1]->Clear();
+    fTbh[1]->AddText(0, buf);
+    gClient->NeedRedraw(fTeh[1]);
+
+    sprintf(buf, "%10.2e", z);
+    fTbh[2]->Clear();
+    fTbh[2]->AddText(0, buf);
+    gClient->NeedRedraw(fTeh[2]);
+
+    sprintf(buf, "%10.2e", dens);
+    fTbh[3]->Clear();
+    fTbh[3]->AddText(0, buf);
+    gClient->NeedRedraw(fTeh[3]);
+
+    sprintf(buf, "%10.2e", radl);
+    fTbh[4]->Clear();
+    fTbh[4]->AddText(0, buf);
+    gClient->NeedRedraw(fTeh[4]);
+
+    sprintf(buf, "%10.2e", absl);
+    fTbh[5]->Clear();
+    fTbh[5]->AddText(0, buf);
+    gClient->NeedRedraw(fTeh[5]);
+
+//  Media Combo
+    sprintf(buf, "%10i", gCurrentMedium->Isvol());
+    fTbhM[0]->Clear();
+    fTbhM[0]->AddText(0, buf);
+    gClient->NeedRedraw(fTehM[0]);
+
+
+    sprintf(buf, "%10i", gCurrentMedium->Ifield());
+    fTbhM[1]->Clear();
+    fTbhM[1]->AddText(0, buf);
+    gClient->NeedRedraw(fTehM[1]);
+
+    sprintf(buf, "%10.2e", gCurrentMedium->Fieldm());
+    fTbhM[2]->Clear();
+    fTbhM[2]->AddText(0, buf);
+    gClient->NeedRedraw(fTehM[2]);
+
+    sprintf(buf, "%10.2e", gCurrentMedium->Tmaxfd());
+    fTbhM[3]->Clear();
+    fTbhM[3]->AddText(0, buf);
+    gClient->NeedRedraw(fTehM[3]);
+
+    sprintf(buf, "%10.2e", gCurrentMedium->Stemax());
+    fTbhM[4]->Clear();
+    fTbhM[4]->AddText(0, buf);
+    gClient->NeedRedraw(fTehM[4]);
+
+    sprintf(buf, "%10.2e", gCurrentMedium->Deemax());
+    fTbhM[5]->Clear();
+    fTbhM[5]->AddText(0, buf);
+    gClient->NeedRedraw(fTehM[5]);
+
+    sprintf(buf, "%10.2e", gCurrentMedium->Epsil());
+    fTbhM[6]->Clear();
+    fTbhM[6]->AddText(0, buf);
+    gClient->NeedRedraw(fTehM[6]);
+
+    sprintf(buf, "%10.2e", gCurrentMedium->Stmin());
+    fTbhM[7]->Clear();
+    fTbhM[7]->AddText(0, buf);
+    gClient->NeedRedraw(fTehM[7]);
+}
+
+void AliGuiGeomMain::UpdateListBox()
+{
+// Update the list box
+    Int_t i;
+    fProcessLB->RemoveEntries(1,19);
+    for (i=11; i < 30; i++) {
+       Float_t p=gCurrentMedium->GetPar(i);
+       char tmp[20];
+       sprintf(tmp, "%6s%5d", kLabelTextP[i-11], Int_t(p));
+       fProcessLB->AddEntry(tmp, i-10);
+    }
+    fProcessLB->MapSubwindows();
+    fProcessLB->Layout();
+
+    fCutsLB->RemoveEntries(1,10);
+    for (i=1; i < 11; i++) {
+       Float_t p=gCurrentMedium->GetPar(i);
+       char tmp[20];
+       sprintf(tmp, "%6s%10.3e", kLabelTextC[i-1], p);
+       fCutsLB->AddEntry(tmp,i);
+    }
+    fCutsLB->MapSubwindows();
+    fCutsLB->Layout();
+}
+
+
+void AliGuiGeomMain::CloseWindow()
+{
+   // Got close message for this MainFrame. Calls parent CloseWindow()
+   // (which destroys the window) and terminate the application.
+   // The close message is generated by the window manager when its close
+   // window menu item is selected.
+
+   TGMainFrame::CloseWindow();
+   gApplication->Terminate(0);
+}
+
+Bool_t AliGuiGeomMain::ProcessMessage(Long_t msg, Long_t parm1, Long_t parm2)
+{
+// Process messages to widgets
+    switch (GET_MSG(msg)) {
+//
+//  Text entries for binning of cross-section plots
+    case kC_TEXTENTRY:
+       switch (GET_SUBMSG(msg)) {
+       case kTE_TEXTCHANGED:
+           switch (parm1) {
+           case 10:
+               fNbins=(Int_t) atof(fTbh61->GetString());
+               break;
+           case 11:
+               fEmin= atof(fTbh62->GetString());
+               break;
+           case 12:
+               fEmax= atof(fTbh63->GetString());
+               break;
+           }
+       }
+       break;
+//
+// ListTree for volumes
+    case kC_LISTTREE:
+       switch (GET_SUBMSG(msg)) {
+//
+// Handle mouse click 
+       case kCT_ITEMCLICK:
+//
+// Button 1: Select volume
+           if (parm1 == kButton1) {
+             TGListTreeItem *item;
+             if ((item = fLt->GetSelected())) 
+               {
+                 gCurrentVolume=((AliG3Volume *) item->GetUserData());
+                 Update();
+               }
+           }
+//
+// Button 2: Draw volume specifications
+
+           if (parm1 == kButton2) {
+               TGListTreeItem *item;
+               if ((item = fLt->GetSelected())) 
+               {
+
+                   ((AliG3Volume *) item->GetUserData())->DrawSpec();
+
+                   gCurrentVolume=((AliG3Volume *) item->GetUserData());
+                   Update();
+               }
+           }
+//
+// Button 3: Draw Volume
+           if (parm1 == kButton3) {
+               TGListTreeItem *item;
+               if ((item = fLt->GetSelected())) 
+               {
+                   ((AliG3Volume *) item->GetUserData())->Draw();
+                   gCurrentVolume=((AliG3Volume *) item->GetUserData());
+                   Update();
+               }
+           }
+           
+           
+           break;
+       case kCT_ITEMDBLCLICK:
+           if (parm1 == kButton1) {
+               if (fLt->GetSelected() != 0) {
+                   gClient->NeedRedraw(fLt);
+               }
+           }
+           break;
+       default:
+           break;
+       }
+       break;
+    case kC_COMMAND:
+       switch (GET_SUBMSG(msg)) {
+       case kCM_BUTTON:
+           switch(parm1) {
+           case 1:
+               Plot();
+               break;
+           }
+           break;
+       case kCM_COMBOBOX:
+//
+// Combo box bindings
+           switch(parm1) {
+//
+// Material Combo
+           case 1:
+               gCurrentMaterial=(AliG3Material*) 
+                   (fComboMaterialEntries->UncheckedAt(Int_t(parm2-1)));
+               gCurrentMedium=(AliG3Medium*) 
+                   (fComboMediaEntries->UncheckedAt(Int_t(parm2-1)));
+               UpdateCombo();
+               UpdateListBox();
+               break;
+//
+// Media Combo
+           case 2:
+               gCurrentMedium=(AliG3Medium*) 
+                   (fComboMediaEntries->UncheckedAt(Int_t(parm2-1)));
+               gCurrentMaterial=(AliG3Material*) 
+                   (fComboMaterialEntries->UncheckedAt(Int_t(parm2-1)));
+               UpdateCombo();
+               UpdateListBox();
+               break;
+//
+// Particle Combo
+           case 3:
+               gCurrentParticle=Int_t(parm2);
+               break;
+//
+// Mechanism Combo
+           case 4:
+               gCurrentProcess=Int_t(parm2);
+               break;
+           }
+           break;
+       case kCM_MENUSELECT:
+           break;
+           
+       case kCM_MENU:
+           switch (parm1) {
+           case kFileOpen:
+           {
+               printf("kFileOpen not yet implemented \n");
+           }
+           break;
+           
+           case kTestDlg:
+               fDialog = new AliGuiGeomDialog
+                   (gClient->GetRoot(), this, 400, 200);
+               break;
+               
+           case kFileSave:
+               printf("kFileSave not yet implemented \n");
+               break;
+               
+           case kFileExit:
+//             printf("kFileExit not yet implemented \n");
+               CloseWindow();   // this also terminates theApp
+               break;
+           default:
+               break;
+           }
+       default:
+           break;
+       }
+    default:
+       break;
+    }
+    return kTRUE;
+}
+
+void AliGuiGeomMain::AddMaterial(AliG3Material *Material, Int_t i)
+{
+// Add material to material combo
+    const char* tmp;
+    tmp=Material->GetName();
+    char mName[21];
+    
+    strncpy(mName, tmp, 20);
+    mName[20]='\0';
+    
+//    Material->SetItemId(i);
+    fMaterialCombo->AddEntry(mName, i);
+    fMaterialCombo->Select(i);
+    fMaterialCombo->Resize(200, 20);
+}
+
+void AliGuiGeomMain::AddMedium(AliG3Medium *Medium, Int_t i)
+{
+// Add medium to medium combo
+    const char* tmp;
+    tmp=Medium->GetName();
+    char mName[21];
+    strncpy(mName, tmp, 20);
+    mName[20]='\0';
+    Medium->SetItemId(i);
+    fMediaCombo->AddEntry(mName, i);
+    fMediaCombo->Select(i);
+    fMediaCombo->Resize(200, 20);
+}
+
+void AliGuiGeomMain::SetMaterialComboEntries(TClonesArray *entries)
+{
+// Set the material combo entries
+//
+    fComboMaterialEntries = entries;
+    Int_t nent = fComboMaterialEntries->GetEntriesFast();
+    for (Int_t i=0; i < nent; i++)
+    {
+       AddMaterial((AliG3Material*)fComboMaterialEntries->At(i), i);
+       gCurrentMaterial = (AliG3Material*)fComboMaterialEntries->At(i);
+    }
+}
+
+
+void AliGuiGeomMain::SetMediaComboEntries(TClonesArray *entries)
+{
+// Set the media combo entries
+//
+    fComboMediaEntries = entries;
+    Int_t nent = fComboMediaEntries->GetEntriesFast();
+    for (Int_t i=0; i < nent; i++)
+    {
+       AddMedium((AliG3Medium*)fComboMediaEntries->At(i), i);
+       gCurrentMedium = (AliG3Medium*)fComboMediaEntries->At(i);
+    }
+}
+
+void AliGuiGeomMain::AddFoldersRecursively(TFolder* folder, TGListTreeItem* parent)
+{
+// Display geometry represented by TFolders in List Tree
+//
+    const TGPicture* kFolder     = gClient->GetPicture("folder_t.xpm");
+    const TGPicture* kOpenFolder = gClient->GetPicture("ofolder_t.xpm");
+    const TGPicture* kDocument   = gClient->GetPicture("doc_t.xpm");
+    
+    AliG3Volume* volume = ((AliG3Volume *) folder->FindObject(folder->GetName()));
+    volume->SetItem(folder);
+
+    TList* folders = (TList*) folder->GetListOfFolders();
+    TIter next(folders);
+    TObject* obj;
+    TGListTreeItem* nParent = 0;
+    if (folders->GetSize() > 1) {
+       nParent = fLt->AddItem(parent, folder->GetName(), volume, kOpenFolder, kFolder);
+    } else {
+       nParent = fLt->AddItem(parent, folder->GetName(), volume, kDocument, kDocument);
+    }
+    
+    while ((obj = next()))
+    {
+       if ((AliG3Volume*) obj == volume) continue;
+       TFolder* item = (TFolder*) obj;
+       AddFoldersRecursively(item, nParent);
+    }
+}
+
diff --git a/AliGeant3/AliGuiGeomMain.h b/AliGeant3/AliGuiGeomMain.h
new file mode 100644 (file)
index 0000000..cd70750
--- /dev/null
@@ -0,0 +1,95 @@
+#ifndef ALIGUIGEOMMAIN_H
+#define ALIGUIGEOMMAIN_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+
+#include "TClonesArray.h"
+#include "TGFrame.h"
+#include "TGListTree.h"
+#include "TGComboBox.h"
+
+
+class TGTab;
+class TGMenuBar;
+class TGPopupMenu;
+class TGTextBuffer;
+class TGTextEntry;
+class TGLabel;
+class TGTextButton;
+class AliNode;
+class TObjArray;
+class TFolder;
+
+class AliG3Material;
+class AliG3Medium;
+class AliGuiGeomDialog;
+class AliG3Volume;
+
+class AliGuiGeomMain : public TGMainFrame {
+ public:
+    AliGuiGeomMain(const TGWindow *p, UInt_t w, UInt_t h);
+    virtual ~AliGuiGeomMain();
+    // Destroy the main window
+    virtual void CloseWindow();
+    // Add item to ListTree
+    virtual TGListTreeItem *
+       AddItem(TObject *obj, TGListTreeItem* parent,
+               const char* name,
+               const TGPicture* open, const TGPicture* closed);
+    // Add Material to ComboBox
+    virtual void AddMaterial(AliG3Material *Material, Int_t i);
+    // Add Medium to ComboBox
+    virtual void AddMedium(AliG3Medium *Medium, Int_t i);
+    // Process messages from this window
+    virtual Bool_t ProcessMessage(Long_t msg, Long_t parm1, Long_t parm2);
+    // Update widgets
+    virtual void Update();
+    // Update ComboBoxes
+    virtual void UpdateCombo();
+    virtual void UpdateListBox();
+    // Relate objects to ComboEntries
+    // Currently ComboBox Entries are strings only, hence we need this construction
+    virtual void SetMaterialComboEntries(TClonesArray *entries);
+    virtual void SetMediaComboEntries(TClonesArray *entries);
+    virtual void AddFoldersRecursively(TFolder* folder=0, TGListTreeItem* parent=NULL);
+    virtual void Plot();
+private:
+    TGTab              *fTab;           // Contains Tab entries: volumes, materials..
+    TGCanvas           *fCanvasWindow;  // Canvas window for list tree
+    TGCompositeFrame   *fF2, *fF21, *fF3, *fF31, *fF4, *fF5;      // Frames for combos
+    TGCompositeFrame   *fF6, *fF61, *fF62, *fF63;                 // Frames for combos
+    TGListTree         *fLt;                                      // Volumes list tree
+    TGMenuBar          *fMenuBar;                                 // Menu bar: File, Draw Control ...
+    TGPopupMenu        *fMenuFile, *fMenuTest, *fMenuHelp;        // Pop-up menus
+    TGLayoutHints      *fMenuBarItemLayout, *fMenuBarHelpLayout,  // Lay-out hints
+                      *fMenuBarLayout, fLTab;                    // Lay-out hints
+    TGLayoutHints      *fL2;                                      // Lay-out hints
+    AliGuiGeomDialog   *fDialog;                                  //! no output please
+    TGComboBox         *fMaterialCombo;                           // Material  combo box
+    TGComboBox         *fMechanismCombo;                          // Mechanism combo box
+    TGComboBox         *fMediaCombo, *fParticleCombo;             // Media and particle combo boxes
+    TGListBox          *fProcessLB, *fCutsLB;                     // List boxes for cuts and processes
+    TClonesArray       *fComboMaterialEntries;                    // List of materials
+    TClonesArray       *fComboMediaEntries;                       // List of media
+    TGHorizontalFrame  *fHframe[6],*fHframeM[8];                  // sub frames 
+    TGTextBuffer       *fTbh[6], *fTbhM[8], *fTbh61, *fTbh62, *fTbh63;  // text frames
+    TGTextEntry        *fTeh[6], *fTehM[8], *fTeh61, *fTeh62, *fTeh63;  // text entries
+    TGLabel            *fLabel[6], *fLabelM[8], *fSLabel61;             // labels
+    TGTextButton       *fPlotButton;                                    // Plot-Button
+    Float_t            fEmin;         // minimum energy for de/dx plot
+    Float_t            fEmax;         // maximum energy for de/dx plot
+    Int_t              fNbins;        // number of bins for de/dx plot
+  AliGuiGeomMain(const AliGuiGeomMain &gm) 
+    : TGMainFrame((const TGMainFrame&)gm) {}
+  virtual AliGuiGeomMain & operator=(const AliGuiGeomMain &) {return *this;}
+    
+
+    ClassDef(AliGuiGeomMain,1)  // MainFrame for Geometry Browser
+};
+
+R__EXTERN AliG3Material  *gCurrentMaterial;
+R__EXTERN AliG3Medium    *gCurrentMedium;
+
+#endif
diff --git a/AliGeant3/AliNode.cxx b/AliGeant3/AliNode.cxx
new file mode 100644 (file)
index 0000000..ca1c25e
--- /dev/null
@@ -0,0 +1,462 @@
+/* *************************************************************************
+ * 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.1  2001/07/09 11:44:01  morsch
+Node class derived from TNode to allow expansion of volume divisions.
+
+*/
+
+
+#include "AliNode.h"
+#include "TShape.h"
+#include "TTUBE.h"
+#include "TBRIK.h"
+#include "TTRD1.h"
+#include "TTRD2.h"
+#include "TTRAP.h"
+#include "TTUBS.h"
+#include "TCONE.h"
+#include "TCONS.h"
+#include "TSPHE.h"
+#include "TPARA.h"
+#include "TPGON.h"
+#include "TPCON.h"
+#include "TTUBS.h"
+#include "TELTU.h"
+#include "THYPE.h"
+#include "TGTRA.h"
+#include "TCTUB.h"
+
+ClassImp(AliNode)
+    AliNode::AliNode(const char* name, const char* title, const char* shapename,
+                    Double_t x, Double_t y, Double_t z, const char* matrixname,
+                    Option_t* option) : 
+       TNode(name, title, shapename, x, y, z, matrixname, option)
+{
+    fNDivision   = -1;
+    fAxis   =  0;
+    fStartC = 0.;
+    fStep   = 0.;
+}
+
+  AliNode::AliNode(const char* name, const char* title, TShape* shape,
+                    Double_t x, Double_t y, Double_t z, TRotMatrix* matrix,
+                    Option_t* option) : 
+       TNode(name, title, shape, x, y, z, matrix, option)
+{
+    fNDivision   = -1;
+    fAxis   =  0;
+    fStartC = 0.;
+    fStep   = 0.;
+}
+
+void   AliNode::SetDivision(Int_t ndiv, Int_t axis, Float_t start, Float_t step)
+{
+    fNDivision   = ndiv;
+    fAxis   = axis;
+    fStartC = start;
+    fStep   = step;
+}
+
+void AliNode::ExpandDivisions()
+{
+    Int_t i;
+    char vName[20];
+    char nName[20];
+    
+    char tmp[4];
+    AliNode* node;
+    TShape*  parent =  fParent->GetShape();
+    TShape*  newsh;
+    
+    strcpy(tmp, parent->GetTitle());
+    Int_t ndiv = fNDivision;
+
+//                                      TUBE
+    
+    if (strcmp(tmp, "TUBE")==0) {
+       TTUBE * shape = (TTUBE*) parent;
+
+       Float_t dZ   = shape->GetDz();
+       Float_t rMin = shape->GetRmin();
+       Float_t rMax = shape->GetRmax();
+       
+       if (fAxis == 1) {
+//  radial-division
+           Float_t dr = (rMax-rMin)/Float_t(fNDivision);
+           Float_t r1, r2;
+           for (i=0; i<ndiv; i++) {
+               r1 = rMin+Float_t(i)*dr;
+               r2 = r1+dr;
+               sprintf(vName, "%sD%d", fShape->GetName(), i);
+               sprintf(nName, "%sD%d", GetName(), i);
+               newsh = new TTUBE(vName, "TUBE", "void", r1, r2, dZ);
+               fParent->cd();
+               node = new AliNode(nName,"", newsh, 0., 0., 0.);
+               node->AddSons(fNodes);
+               cd();
+           }
+    
+       } else if (fAxis == 2) {
+//  phi-division
+           Float_t dPhi = 360./Float_t(fNDivision);
+           Float_t phi1, phi2;
+           for (i=0; i<ndiv; i++) {
+               phi1 = Float_t(i)*dPhi;
+               phi2 = phi1+dPhi;
+               sprintf(vName, "%sD%d", fShape->GetName(), i);
+               sprintf(nName, "%sD%d", GetName(), i);
+               newsh = new TTUBS(vName, "TUBS", "void", rMin, rMax, dZ, phi1, phi2);
+               fParent->cd();
+               node = new AliNode(nName, "", newsh, 0., 0., 0.);
+               node->AddSons(fNodes);
+               cd();
+           }
+       } else {
+//  z-division
+           Float_t delZ = dZ/Float_t(fNDivision);
+           for (i=0; i<ndiv; i++) {
+               sprintf(vName, "%sD%d", fShape->GetName(), i);
+               sprintf(nName, "%sD%d", GetName(), i);
+               newsh = new TTUBE(vName, "TUBE", "void", rMin, rMax, delZ);
+               fParent->cd();
+               Float_t zpos = -dZ+delZ*(2.*Float_t(i)+1.);
+               node = new AliNode(nName, "",newsh, 0., 0., zpos);
+               node->AddSons(fNodes);
+               cd();
+           }
+       }
+//
+//                            TUBS
+//
+    } else if (strcmp(tmp, "TUBS")==0) {
+       TTUBS * shape = (TTUBS*) parent;
+       Float_t dZ   = shape->GetDz();
+       Float_t rMin = shape->GetRmin();
+       Float_t rMax = shape->GetRmax();
+       Float_t phi1 = shape->GetPhi1();
+       Float_t phi2 = shape->GetPhi2();
+       
+       if (fAxis == 1) {
+//  radial-division
+           Float_t dr = (rMax-rMin)/Float_t(fNDivision);
+           Float_t r1, r2;
+           Int_t ndiv = fNDivision;
+           for (i=0; i<ndiv; i++) {
+               r1 = rMin+Float_t(i)*dr;
+               r2 = r1+dr;
+               sprintf(vName, "%sD%d", fShape->GetName(), i);
+               sprintf(nName, "%sD%d", GetName(), i);
+               newsh = new TTUBS(vName, "TUBS", "void", r1, r2, dZ, phi1, phi2);
+               fParent->cd();
+               node = new AliNode(nName,"", newsh, 0., 0., 0.);
+               node->AddSons(fNodes);
+               cd();
+           }
+           
+       } else if (fAxis == 2) {
+//  phi-division
+           Float_t dPhi = (phi2-phi1)/Float_t(fNDivision);
+           Float_t nphi1, nphi2;
+           
+           for (i=0; i<fNDivision; i++) {
+               nphi1 = phi1+Float_t(i)*dPhi;
+               nphi2 = nphi1+dPhi;
+               sprintf(vName, "%sD%d", fShape->GetName(), i);
+               sprintf(nName, "%sD%d", GetName(), i);
+
+               newsh = new TTUBS(vName, "TUBS", "void", rMin, rMax, dZ, nphi1, nphi2);
+               fParent->cd();
+               node = new AliNode(nName, "", newsh, 0., 0., 0.);
+               node->AddSons(fNodes);
+               cd();
+           }
+       } else {
+//  z-division
+           Float_t delZ = dZ/Float_t(fNDivision);
+           for (i=0; i<ndiv; i++) {
+               sprintf(vName, "%sD%d", fShape->GetName(), i);
+               sprintf(nName, "%sD%d", GetName(), i);
+               newsh = new TTUBS(vName, "TUBS", "void", rMin, rMax, delZ, phi1, phi2);
+               fParent->cd();
+               Float_t zpos = -dZ+delZ*(2.*Float_t(i)+1.);
+               node = new AliNode(nName, "",newsh, 0., 0., zpos);
+               node->AddSons(fNodes);
+               cd();
+           }
+       }
+       
+    } else if (strcmp(tmp, "CONE")==0) {
+       TCONE * shape = (TCONE*) parent;
+
+       Float_t dZ   = shape->GetDz();
+       Float_t rMin1 = shape->GetRmin();
+       Float_t rMax1 = shape->GetRmax();
+       Float_t rMin2 = shape->GetRmin2();
+       Float_t rMax2 = shape->GetRmax2();
+       
+       if (fAxis == 1) {
+//  radial-division
+           Float_t dr1 = (rMax1-rMin1)/Float_t(fNDivision);
+           Float_t dr2 = (rMax2-rMin2)/Float_t(fNDivision);
+           Float_t r11, r12, r21, r22;
+           for (i=0; i<ndiv; i++) {
+               r11 = rMin1+Float_t(i)*dr1;
+               r12 = r11+dr1;
+               r21 = rMin2+Float_t(i)*dr2;
+               r22 = r21+dr2;
+
+               sprintf(vName, "%sD%d", fShape->GetName(), i);
+               sprintf(nName, "%sD%d", GetName(), i);
+               newsh = new TCONE(vName, "CONE", "void", dZ, r11, r12, r21, r22);
+               fParent->cd();
+               node = new AliNode(nName,"", newsh, 0., 0., 0.);
+               node->AddSons(fNodes);
+               cd();
+           }
+       } else if (fAxis == 2) {
+//  phi-division
+           Float_t dPhi = 360./Float_t(fNDivision);
+           Float_t phi1, phi2;
+           for (i=0; i<ndiv; i++) {
+               phi1 = Float_t(i)*dPhi;
+               phi2 = phi1+dPhi;
+               sprintf(vName, "%sD%d", fShape->GetName(), i);
+               sprintf(nName, "%sD%d", GetName(), i);
+               newsh = new TCONS(vName, "CONS", "void", dZ, rMin1, rMax1, 
+                         rMin2, rMax2, phi1, phi2);
+               fParent->cd();
+               node = new AliNode(nName, "",newsh, 0., 0., 0.);
+               node->AddSons(fNodes);
+               cd();
+           }
+       } else {
+//  z-division
+           Float_t delZ = dZ/Float_t(fNDivision);
+           for (i=0; i<ndiv; i++) {
+               sprintf(vName, "%sD%d", fShape->GetName(), i);
+               sprintf(nName, "%sD%d", GetName(), i);
+               newsh = new TCONE(vName, "CONE", "void", delZ, rMin1, rMax1, rMin2, rMax2);
+               fParent->cd();
+               Float_t zpos = -dZ+delZ*(2.*Float_t(i)+1.);
+               node = new AliNode(nName, "",newsh, 0., 0., zpos);
+               node->AddSons(fNodes);
+               cd();
+           }
+       }
+       
+    } else if (strcmp(tmp, "CONS")==0) {
+       TCONS * shape = (TCONS*) parent;
+       Float_t dZ   = shape->GetDz();
+       Float_t rMin1 = shape->GetRmin();
+       Float_t rMax1 = shape->GetRmax();
+       Float_t rMin2 = shape->GetRmin2();
+       Float_t rMax2 = shape->GetRmax2();
+       Float_t phi1 = shape->GetPhi1();
+       Float_t phi2 = shape->GetPhi2();
+       if (fAxis == 1) {
+//  radial-division
+           Float_t dr1 = (rMax1-rMin1)/Float_t(fNDivision);
+           Float_t dr2 = (rMax2-rMin2)/Float_t(fNDivision);
+           Float_t r11, r12, r21, r22;
+           for (i=0; i<ndiv; i++) {
+               r11 = rMin1+Float_t(i)*dr1;
+               r12 = r11+dr1;
+               r21 = rMin2+Float_t(i)*dr2;
+               r22 = r21+dr2;
+
+               sprintf(vName, "%sD%d", fShape->GetName(), i);
+               sprintf(nName, "%sD%d", GetName(), i);
+               newsh = new TCONS(vName, "CONS", "void", dZ, r11, r12, r21, r22, phi1, phi2);
+               fParent->cd();
+               node = new AliNode(nName,"", newsh, 0., 0., 0.);
+               node->AddSons(fNodes);
+               cd();
+           }
+           
+       } else if (fAxis == 2) {
+//  phi-division
+           Float_t dPhi = (phi2-phi1)/Float_t(fNDivision);
+           Float_t nphi1, nphi2;
+           
+           for (i=0; i<fNDivision; i++) {
+               nphi1 = phi1+Float_t(i)*dPhi;
+               nphi2 = nphi1+dPhi;
+               sprintf(vName, "%sD%d", fShape->GetName(), i);
+               sprintf(nName, "%sD%d", GetName(), i);
+
+               newsh = new TCONS(vName, "CONS", "void", dZ, rMin1, rMax1, rMin2, rMax2, nphi1, nphi2);
+               fParent->cd();
+               node = new AliNode(nName, "", newsh, 0., 0., 0.);
+               node->AddSons(fNodes);
+               cd();
+           }
+       } else {
+//  z-division
+           Float_t delZ = dZ/Float_t(fNDivision);
+           for (i=0; i<ndiv; i++) {
+               sprintf(vName, "%sD%d", fShape->GetName(), i);
+               sprintf(nName, "%sD%d", GetName(), i);
+               newsh = new TCONS(vName, "CONS", "void", delZ, rMin1, rMax1, rMin2, rMax2, phi1, phi2);
+               fParent->cd();
+               Float_t zpos = -dZ+delZ*(2.*Float_t(i)+1.);
+               node = new AliNode(nName,"",newsh, 0., 0., zpos);
+               node->AddSons(fNodes);
+               cd();
+           }
+       }
+    } else if (strcmp(tmp, "BRIK")==0) {
+//
+//                          BRIK
+//
+       TBRIK * shape = (TBRIK*) parent;
+       Float_t dX   = shape->GetDx();
+       Float_t dY   = shape->GetDy();
+       Float_t dZ   = shape->GetDz();
+
+       if (fAxis == 1) {
+// division in x
+           Float_t delX = dX/Float_t(fNDivision);
+           for (i=0; i<ndiv; i++) {
+               sprintf(vName, "%sD%d", fShape->GetName(), i);
+               sprintf(nName, "%sD%d", GetName(), i);
+               newsh = new TBRIK(vName, "BRIK", "void", delX, dY, dZ);
+               fParent->cd();
+               Float_t xpos = -dX+delX*(2.*Float_t(i)+1.);
+               node = new AliNode(nName,"",newsh, xpos, 0., 0.);
+               node->AddSons(fNodes);
+               cd();
+           }
+       } else if (fAxis == 2) {
+// division in y
+           Float_t delY = dY/Float_t(fNDivision);
+           for (i=0; i<ndiv; i++) {
+               sprintf(vName, "%sD%d", fShape->GetName(), i);
+               sprintf(nName, "%sD%d", GetName(), i);
+               newsh = new TBRIK(vName, "BRIK", "void", dX, delY, dZ);
+               fParent->cd();
+               Float_t ypos = -dY+delY*(2.*Float_t(i)+1.);
+               node = new AliNode(nName,"",newsh, 0., ypos, 0.);
+               node->AddSons(fNodes);
+               cd();
+           }
+       } else {
+// division in z
+           Float_t delZ = dZ/Float_t(fNDivision);
+           for (i=0; i<ndiv; i++) {
+               sprintf(vName, "%sD%d", fShape->GetName(), i);
+               sprintf(nName, "%sD%d", GetName(), i);
+               newsh = new TBRIK(vName, "BRIK", "void", dX, dY, delZ);
+               fParent->cd();
+               Float_t zpos = -dZ+delZ*(2.*Float_t(i)+1.);
+               node = new AliNode(nName,"",newsh, 0., 0., zpos);
+               node->AddSons(fNodes);
+               cd();
+           }
+       }
+    }
+}
+
+void AliNode::AddSons(TList* list)
+{
+    if (!list) return;
+    if (!fNodes) fNodes = new TList();
+    
+    TIter next(list);
+    AliNode* node;
+    
+    while((node = (AliNode*)next())) {
+       AliNode* newNode = new AliNode(*node, this);
+       fNodes->Add(newNode);
+       newNode->SetParent(this);
+       newNode->AddSons(node->GetListOfNodes());
+    }
+}
+
+
+AliNode::AliNode(const AliNode &node, AliNode* parent)
+{
+    fNDivision   = node.Ndiv();
+    fAxis        = node.Axis();
+    fStartC      = node.StartC();
+    fStep        = node.Step();
+    fName        = node.GetName();
+    fTitle       = node.GetTitle();
+    fX           = node.GetX();
+    fY           = node.GetY();
+    fZ           = node.GetZ();
+    fMatrix      = node.GetMatrix();
+    fNodes       = 0;
+    fParent      = parent;
+    
+    
+    if (fNDivision > 0) {
+       fShape = new TShape(*node.GetShape());
+    } else {
+       fShape = (TShape*) node.GetShape()->Clone();
+    }
+    
+    
+//    fShape = (TShape*) shape->Clone();
+/*
+    char tmp[4];        
+    strcpy(tmp, shape->ClassName());
+
+    if (strcmp(tmp, "TTUBE")==0) 
+       fShape =  (TTUBE*)shape->Clone();
+    else if (strcmp(tmp, "TBRIK")==0) 
+       fShape =  (TBRIK*)shape->Clone();
+    else if (strcmp(tmp, "TCONE")==0) 
+       fShape =  (TCONE*)shape->Clone();
+    else if (strcmp(tmp, "TCONS")==0) 
+       fShape =  (TCONS*)shape->Clone();
+    else if (strcmp(tmp, "TTUBS")==0) 
+       fShape =  (TTUBS*)shape->Clone();
+    else if (strcmp(tmp, "TTRAP")==0) 
+       fShape =  (TTRAP*)shape->Clone();
+    else if (strcmp(tmp, "TTRD1")==0) 
+       fShape =  (TTRD1*)shape->Clone();
+    else if (strcmp(tmp, "TTRD2")==0)
+       fShape =  (TTRD2*)shape->Clone();
+    else if (strcmp(tmp, "TSPHE")==0) 
+       fShape =  (TSPHE*)shape->Clone();
+    else if (strcmp(tmp, "TPGON")==0) 
+       fShape =  (TPGON*)shape->Clone();
+    else if (strcmp(tmp, "TPCON")==0) 
+       fShape =  (TPCON*)shape->Clone();
+*/
+}
+
+void AliNode::AddSon(AliNode* node)
+{
+    fNodes->Add(node);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/AliGeant3/AliNode.h b/AliGeant3/AliNode.h
new file mode 100644 (file)
index 0000000..18b83cf
--- /dev/null
@@ -0,0 +1,55 @@
+#ifndef ALINODE_H
+#define ALINODE_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+
+#include "TNode.h"
+
+class AliNode : public TNode 
+{
+public:
+    AliNode(){}
+    AliNode(const char* name, const char* title, const char* shapename,
+           Double_t x = 0, Double_t y = 0, Double_t z = 0, const char* matrixname="",
+           Option_t* option="");
+
+    AliNode(const char* name, const char* title, TShape* shape,
+           Double_t x = 0, Double_t y = 0, Double_t z = 0, TRotMatrix* matrix = 0,
+           Option_t* option="");
+    AliNode(const AliNode &node, AliNode* parent);
+    
+    virtual ~AliNode(){}
+
+    virtual void SetDivision(Int_t ndiv, Int_t axis, Float_t start, Float_t step);
+    virtual void ExpandDivisions();
+    virtual Int_t   Axis()   const {return fAxis;}
+    virtual Int_t   Ndiv()   const {return fNDivision;}
+    virtual Float_t Step()   const {return fStep;}
+    virtual Float_t StartC() const {return fStartC;}
+    virtual void    AddSons(TList* list);
+    virtual void    AddSon(AliNode* node);
+    
+           
+           
+private:
+    Int_t   fAxis;         // division axis
+    Int_t   fNDivision;    // number of divisions
+    Float_t fStep;         // number of steps
+    Float_t fStartC;       // start coordinate
+
+    AliNode &operator=(const AliNode &) {return *this;}
+
+    ClassDef(AliNode,1) // Material Object for GUI 
+};
+
+#endif
+
+
+
+
+
+
+
+
diff --git a/AliGeant3/Makefile b/AliGeant3/Makefile
new file mode 100644 (file)
index 0000000..b091baa
--- /dev/null
@@ -0,0 +1,102 @@
+############################### AliGeant3 Makefile ##############################
+
+# Include machine specific definitions
+
+include $(ALICE_ROOT)/conf/GeneralDef
+include $(ALICE_ROOT)/conf/MachineDef.$(ALICE_TARGET)
+
+PACKAGE = AliGeant3
+
+# FORTRAN sources
+
+FSRCS       = 
+
+# C++ sources
+
+GSRCS          = AliG3Medium.cxx \
+                 AliG3Material.cxx AliG3Volume.cxx \
+                AliGUISliders.cxx AliGuiGeomDialog.cxx AliGuiGeomMain.cxx \
+                AliGeant3GeometryGUI.cxx AliNode.cxx AliG3toRoot.cxx
+
+# C++ Headers
+
+GHDRS          = $(filter-out gucode.h,$(GSRCS:.cxx=.h)) AliGeant3LinkDef.h
+
+# Library dictionary
+
+GDICT          = AliGeant3Cint.cxx
+GDICTH         = $(GDICT:.cxx=.h)
+GDICTO         = $(patsubst %.cxx,tgt_$(ALICE_TARGET)/%.o,$(GDICT))
+
+# Geant Objects
+
+GOBJS          = $(patsubst %.cxx,tgt_$(ALICE_TARGET)/%.o,$(GSRCS)) $(FOBJS) $(GDICTO)
+
+# FORTRAN Objectrs
+
+FOBJS         = $(patsubst %.F,tgt_$(ALICE_TARGET)/%.o,$(FSRCS))
+
+# C Objects
+
+COBJS         = $(patsubst %.c,tgt_$(ALICE_TARGET)/%.o,$(CSRCS))
+
+# C++ Objects
+
+OBJS          = $(patsubst %.cxx,tgt_$(ALICE_TARGET)/%.o,$(SRCS)) $(DICTO)
+
+# C++ Headers
+
+DHDRS          = AliGeant3LinkDef.h
+
+# Geant Objects
+
+DOBJS          = $(patsubst %.cxx,tgt_$(ALICE_TARGET)/%.o,$(DSRCS)) $(DDICTO)
+
+# C++ compilation flags
+
+CXXFLAGS      = $(CXXOPTS) -I$(ROOTSYS)/include -I. -I$(ALICE_ROOT)/include/ \
+               -I$(G3INSTALL)/geant321 -I$(G3INSTALL)/geant3mc
+# FORTRAN compilation flags
+
+FFLAGS      = $(FOPT) -I$(ALICE_ROOT)/GEANT321
+
+##### TARGETS #####
+# Target
+
+SLIBRARY       = $(LIBDIR)/libAliGeant3.$(SL) 
+ALIBRARY       = $(LIBDIR)/libAliGeant3.a
+
+default:       $(SLIBRARY)
+
+$(LIBDIR)/libAliGeant3.$(SL):          $(GOBJS)
+
+$(GDICT):                              $(GHDRS)
+
+$(DDICT):                              $(DHDRS)
+
+DICT   =               $(GDICT) $(DDICT)
+
+DEPINC += -I$(ALICE_ROOT)/GEANT321
+
+depend:                        $(GSRCS) $(FSRCS)
+
+TOCLEAN                = $(GOBJS) $(JOBJS) $(DOBJS) *Cint.cxx *Cint.h
+
+CHECKS        = $(patsubst %.cxx,check/%.viol,$(GSRCS))
+
+############################### General Macros ################################
+
+include $(ALICE_ROOT)/conf/GeneralMacros
+
+############################ Dependencies #####################################
+
+-include tgt_$(ALICE_TARGET)/Make-depend 
+
+
+
+
+
+
+