// @(#)root/geom:$Id$
// Author: Andrei Gheata   25/10/01

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/

////////////////////////////////////////////////////////////////////////////////
// General architecture
// --------------------
//
//   The new ROOT geometry package is a tool designed for building, browsing,
// tracking and visualizing a detector geometry. The code is independent from
// other external MC for simulation, therefore it does not contain any
// constraints related to physics. However, the package defines a number of
// hooks for tracking, such as media, materials, magnetic field or track state flags,
// in order to allow interfacing to tracking MC's. The final goal is to be
// able to use the same geometry for several purposes, such as tracking,
// reconstruction or visualization, taking advantage of the ROOT features
// related to bookkeeping, I/O, histograming, browsing and GUI's.
//
//   The geometrical modeler is the most important component of the package and
// it provides answers to the basic questions like "Where am I ?" or "How far
// from the next boundary ?", but also to more complex ones like "How far from
// the closest surface ?" or "Which is the next crossing along a helix ?".
//
//   The architecture of the modeler is a combination between a GEANT-like
// containment scheme and a normal CSG binary tree at the level of shapes. An
// important common feature of all detector geometry descriptions is the
// mother-daughter concept. This is the most natural approach when tracking
// is concerned and imposes a set of constraints to the way geometry is defined.
// Constructive solid geometry composition is used only in order to create more
// complex shapes from an existing set of primitives through boolean operations.
// This feature is not implemented yet but in future full definition of boolean
// expressions will be supported.
//
//   Practically every geometry defined in GEANT style can be mapped by the modeler.
// The basic components used for building the logical hierarchy of the geometry
// are called "volumes" and "nodes". Volumes (sometimes called "solids") are fully
// defined geometrical objects having a given shape and medium and possibly
// containing a list of nodes. Nodes represent just positioned instances of volumes
// inside a container volume and they are not directly defined by user. They are
// automatically created as a result of adding one volume inside other or dividing
// a volume. The geometrical transformation hold by nodes is always defined with
// respect to their mother (relative positioning). Reflection matrices are allowed.
// All volumes have to be fully aware of their containees when the geometry is
// closed. They will build aditional structures (voxels) in order to fasten-up
// the search algorithms. Finally, nodes can be regarded as bidirectional links
// between containers and containees objects.
//
//   The structure defined in this way is a graph structure since volumes are
// replicable (same volume can become daughter node of several other volumes),
// every volume becoming a branch in this graph. Any volume in the logical graph
// can become the actual top volume at run time (see TGeoManager::SetTopVolume()).
// All functionalities of the modeler will behave in this case as if only the
// corresponding branch starting from this volume is the registered geometry.
//
//Begin_Html
/*
<img src="gif/t_graf.jpg">
*/
//End_Html
//
//   A given volume can be positioned several times in the geometry. A volume
// can be divided according default or user-defined patterns, creating automatically
// the list of division nodes inside. The elementary volumes created during the
// dividing process follow the same scheme as usual volumes, therefore it is possible
// to position further geometrical structures inside or to divide them further more
// (see TGeoVolume::Divide()).
//
//   The primitive shapes supported by the package are basically the GEANT3
// shapes (see class TGeoShape), arbitrary wedges with eight vertices on two parallel
// planes. All basic primitives inherits from class TGeoBBox since the bounding box
// of a solid is essential for the tracking algorithms. They also implement the
// virtual methods defined in the virtual class TGeoShape (point and segment
// classification). User-defined primitives can be direcly plugged into the modeler
// provided that they override these methods. Composite shapes will be soon supported
// by the modeler. In order to build a TGeoCompositeShape, one will have to define
// first the primitive components. The object that handle boolean
// operations among components is called TGeoBoolCombinator and it has to be
// constructed providing a string boolean expression between the components names.
//
//
// Example for building a simple geometry :
//-----------------------------------------
//
// Begin_Html <a href=http://root.cern.ch/root/html/tutorials/geom/rootgeom.C.html>rootgeom.C</a> //
// End_Html                                                             //
//______________________________________________________________________________
//
//
//Begin_Html
/*
<img src="gif/t_root.jpg">
*/
//End_Html
//
//
// TGeoManager - the manager class for the geometry package.
// ---------------------------------------------------------
//
//   TGeoManager class is embedding all the API needed for building and tracking
// a geometry. It defines a global pointer (gGeoManager) in order to be fully
// accessible from external code. The mechanism of handling multiple geometries
// at the same time will be soon implemented.
//
//   TGeoManager is the owner of all geometry objects defined in a session,
// therefore users must not try to control their deletion. It contains lists of
// media, materials, transformations, shapes and volumes. Logical nodes (positioned
// volumes) are created and destroyed by the TGeoVolume class. Physical
// nodes and their global transformations are subjected to a caching mechanism
// due to the sometimes very large memory requirements of logical graph expansion.
// The caching mechanism is triggered by the total number of physical instances
// of volumes and the cache manager is a client of TGeoManager. The manager class
// also controls the painter client. This is linked with ROOT graphical libraries
// loaded on demand in order to control visualization actions.
//
// Rules for building a valid geometry
// -----------------------------------
//
//   A given geometry can be built in various ways, but there are mandatory steps
// that have to be followed in order to be validated by the modeler. There are
// general rules : volumes needs media and shapes in order to be created,
// both container an containee volumes must be created before linking them together,
// and the relative transformation matrix must be provided. All branches must
// have an upper link point otherwise they will not be considered as part of the
// geometry. Visibility or tracking properties of volumes can be provided both
// at build time or after geometry is closed, but global visualization settings
// (see TGeoPainter class) should not be provided at build time, otherwise the
// drawing package will be loaded. There is also a list of specific rules :
// positioned daughters should not extrude their mother or intersect with sisters
// unless this is specified (see TGeoVolume::AddNodeOverlap()), the top volume
// (containing all geometry tree) must be specified before closing the geometry
// and must not be positioned - it represents the global reference frame. After
// building the full geometry tree, the geometry must be closed
// (see TGeoManager::CloseGeometry()). Voxelization can be redone per volume after
// this process.
//
//
//   Below is the general scheme of the manager class.
//
//Begin_Html
/*
<img src="gif/t_mgr.jpg">
*/
//End_Html
//
//  An interactive session
// ------------------------
//
//   Provided that a geometry was successfully built and closed (for instance the
// previous example $ROOTSYS/tutorials/geom/rootgeom.C ), the manager class will register
// itself to ROOT and the logical/physical structures will become immediately browsable.
// The ROOT browser will display starting from the geometry folder : the list of
// transformations and media, the top volume and the top logical node. These last
// two can be fully expanded, any intermediate volume/node in the browser being subject
// of direct access context menu operations (right mouse button click). All user
// utilities of classes TGeoManager, TGeoVolume and TGeoNode can be called via the
// context menu.
//
//Begin_Html
/*
<img src="gif/t_browser.jpg">
*/
//End_Html
//
//  --- Drawing the geometry
//
//   Any logical volume can be drawn via TGeoVolume::Draw() member function.
// This can be direcly accessed from the context menu of the volume object
// directly from the browser.
//   There are several drawing options that can be set with
// TGeoManager::SetVisOption(Int_t opt) method :
// opt=0 - only the content of the volume is drawn, N levels down (default N=3).
//    This is the default behavior. The number of levels to be drawn can be changed
//    via TGeoManager::SetVisLevel(Int_t level) method.
//
//Begin_Html
/*
<img src="gif/t_frame0.jpg">
*/
//End_Html
//
// opt=1 - the final leaves (e.g. daughters with no containment) of the branch
//    starting from volume are drawn down to the current number of levels.
//                                     WARNING : This mode is memory consuming
//    depending of the size of geometry, so drawing from top level within this mode
//    should be handled with care for expensive geometries. In future there will be
//    a limitation on the maximum number of nodes to be visualized.
//
//Begin_Html
/*
<img src="gif/t_frame1.jpg">
*/
//End_Html
//
// opt=2 - only the clicked volume is visualized. This is automatically set by
//    TGeoVolume::DrawOnly() method
// opt=3 - only a given path is visualized. This is automatically set by
//    TGeoVolume::DrawPath(const char *path) method
//
//    The current view can be exploded in cartesian, cylindrical or spherical
// coordinates :
//   TGeoManager::SetExplodedView(Int_t opt). Options may be :
// - 0  - default (no bombing)
// - 1  - cartesian coordinates. The bomb factor on each axis can be set with
//        TGeoManager::SetBombX(Double_t bomb) and corresponding Y and Z.
// - 2  - bomb in cylindrical coordinates. Only the bomb factors on Z and R
//        are considered
//
//Begin_Html
/*
<img src="gif/t_frameexp.jpg">
*/
//End_Html
//
// - 3  - bomb in radial spherical coordinate : TGeoManager::SetBombR()
//
// Volumes themselves support different visualization settings :
//    - TGeoVolume::SetVisibility() : set volume visibility.
//    - TGeoVolume::VisibleDaughters() : set daughters visibility.
// All these actions automatically updates the current view if any.
//
//  --- Checking the geometry
//
//  Several checking methods are accessible from the volume context menu. They
// generally apply only to the visible parts of the drawn geometry in order to
// ease geometry checking, and their implementation is in the TGeoChecker class
// from the painting package.
//
// 1. Checking a given point.
//   Can be called from TGeoManager::CheckPoint(Double_t x, Double_t y, Double_t z).
// This method is drawing the daughters of the volume containing the point one
// level down, printing the path to the deepest physical node holding this point.
// It also computes the closest distance to any boundary. The point will be drawn
// in red.
//
//Begin_Html
/*
<img src="gif/t_checkpoint.jpg">
*/
//End_Html
//
//  2. Shooting random points.
//   Can be called from TGeoVolume::RandomPoints() (context menu function) and
// it will draw this volume with current visualization settings. Random points
// are generated in the bounding box of the top drawn volume. The points are
// classified and drawn with the color of their deepest container. Only points
// in visible nodes will be drawn.
//
//Begin_Html
/*
<img src="gif/t_random1.jpg">
*/
//End_Html
//
//
//  3. Raytracing.
//   Can be called from TGeoVolume::RandomRays() (context menu of volumes) and
// will shoot rays from a given point in the local reference frame with random
// directions. The intersections with displayed nodes will appear as segments
// having the color of the touched node. Drawn geometry will be then made invisible
// in order to enhance rays.
//
//Begin_Html
/*
<img src="gif/t_random2.jpg">
*/
//End_Html

#include <stdlib.h>

#include "Riostream.h"

#include "TROOT.h"
#include "TGeoManager.h"
#include "TSystem.h"
#include "TStyle.h"
#include "TVirtualPad.h"
#include "TBrowser.h"
#include "TFile.h"
#include "TKey.h"
#include "THashList.h"
#include "TClass.h"
#include "TThread.h"
#include "ThreadLocalStorage.h"

#include "TGeoVoxelFinder.h"
#include "TGeoElement.h"
#include "TGeoMaterial.h"
#include "TGeoMedium.h"
#include "TGeoMatrix.h"
#include "TGeoNode.h"
#include "TGeoPhysicalNode.h"
#include "TGeoManager.h"
#include "TGeoPara.h"
#include "TGeoParaboloid.h"
#include "TGeoTube.h"
#include "TGeoEltu.h"
#include "TGeoHype.h"
#include "TGeoCone.h"
#include "TGeoSphere.h"
#include "TGeoArb8.h"
#include "TGeoPgon.h"
#include "TGeoTrd1.h"
#include "TGeoTrd2.h"
#include "TGeoTorus.h"
#include "TGeoXtru.h"
#include "TGeoCompositeShape.h"
#include "TGeoBoolNode.h"
#include "TGeoBuilder.h"
#include "TVirtualGeoPainter.h"
#include "TPluginManager.h"
#include "TVirtualGeoTrack.h"
#include "TQObject.h"
#include "TMath.h"
#include "TEnv.h"
#include "TGeoParallelWorld.h"

// statics and globals

TGeoManager *gGeoManager = 0;

ClassImp(TGeoManager)

Bool_t TGeoManager::fgLock         = kFALSE;
Bool_t TGeoManager::fgLockNavigators = kFALSE;
Int_t  TGeoManager::fgVerboseLevel = 1;
Int_t  TGeoManager::fgMaxLevel = 1;
Int_t  TGeoManager::fgMaxDaughters = 1;
Int_t  TGeoManager::fgMaxXtruVert = 1;
Int_t  TGeoManager::fgNumThreads   = 0;
TGeoManager::ThreadsMap_t *TGeoManager::fgThreadId = 0;

//_____________________________________________________________________________
TGeoManager::TGeoManager()
{
// Default constructor.
   if (!fgThreadId) fgThreadId = new TGeoManager::ThreadsMap_t;
   if (TClass::IsCallingNew() == TClass::kDummyNew) {
      fTimeCut = kFALSE;
      fTmin = 0.;
      fTmax = 999.;
      fPhiCut = kFALSE;
      fPhimin = 0;
      fPhimax = 360;
      fDrawExtra = kFALSE;
      fStreamVoxels = kFALSE;
      fIsGeomReading = kFALSE;
      fIsGeomCleaning = kFALSE;
      fClosed = kFALSE;
      fLoopVolumes = kFALSE;
      fBits = 0;
      fCurrentNavigator = 0;
      fMaterials = 0;
      fHashPNE = 0;
      fArrayPNE = 0;
      fMatrices = 0;
      fNodes = 0;
      fOverlaps = 0;
      fNNodes = 0;
      fMaxVisNodes = 10000;
      fVolumes = 0;
      fPhysicalNodes = 0;
      fShapes = 0;
      fGVolumes = 0;
      fGShapes = 0;
      fTracks = 0;
      fMedia = 0;
      fNtracks = 0;
      fNpdg = 0;
      fPdgNames = 0;
      memset(fPdgId, 0, 1024*sizeof(Int_t));
      fCurrentTrack = 0;
      fCurrentVolume = 0;
      fTopVolume = 0;
      fTopNode = 0;
      fMasterVolume = 0;
      fPainter = 0;
      fActivity = kFALSE;
      fIsNodeSelectable = kFALSE;
      fVisDensity = 0.;
      fVisLevel = 3;
      fVisOption = 1;
      fExplodedView = 0;
      fNsegments = 20;
      fNLevel = 0;
      fUniqueVolumes = 0;
      fNodeIdArray = 0;
      fClippingShape = 0;
      fMatrixTransform = kFALSE;
      fMatrixReflection = kFALSE;
      fGLMatrix = 0;
      fPaintVolume = 0;
      fElementTable = 0;
      fHashVolumes = 0;
      fHashGVolumes = 0;
      fSizePNEId = 0;
      fNPNEId = 0;
      fKeyPNEId = 0;
      fValuePNEId = 0;
      fMultiThread = kFALSE;
      fMaxThreads = 0;
      fUsePWNav = kFALSE;
      fParallelWorld = 0;
      ClearThreadsMap();
   } else {
      Init();
      if (!gGeoIdentity && TClass::IsCallingNew() == TClass::kRealNew) gGeoIdentity = new TGeoIdentity("Identity");
      BuildDefaultMaterials();
   }
}

//_____________________________________________________________________________
TGeoManager::TGeoManager(const char *name, const char *title)
            :TNamed(name, title)
{
// Constructor.
   if (!gROOT->GetListOfGeometries()->FindObject(this)) gROOT->GetListOfGeometries()->Add(this);
   if (!gROOT->GetListOfBrowsables()->FindObject(this)) gROOT->GetListOfBrowsables()->Add(this);
   Init();
   gGeoIdentity = new TGeoIdentity("Identity");
   BuildDefaultMaterials();
   if (fgVerboseLevel>0) Info("TGeoManager","Geometry %s, %s created", GetName(), GetTitle());
}

//_____________________________________________________________________________
void TGeoManager::Init()
{
// Initialize manager class.

   if (gGeoManager) {
      Warning("Init","Deleting previous geometry: %s/%s",gGeoManager->GetName(),gGeoManager->GetTitle());
      delete gGeoManager;
      if (fgLock) Fatal("Init", "New geometry created while the old one locked !!!");
   }

   gGeoManager = this;
   if (!fgThreadId) fgThreadId = new TGeoManager::ThreadsMap_t;
   fTimeCut = kFALSE;
   fTmin = 0.;
   fTmax = 999.;
   fPhiCut = kFALSE;
   fPhimin = 0;
   fPhimax = 360;
   fDrawExtra = kFALSE;
   fStreamVoxels = kFALSE;
   fIsGeomReading = kFALSE;
   fIsGeomCleaning = kFALSE;
   fClosed = kFALSE;
   fLoopVolumes = kFALSE;
   fBits = new UChar_t[50000]; // max 25000 nodes per volume
   fCurrentNavigator = 0;
   fHashPNE = new THashList(256,3);
   fArrayPNE = 0;
   fMaterials = new THashList(200,3);
   fMatrices = new TObjArray(256);
   fNodes = new TObjArray(30);
   fOverlaps = new TObjArray(256);
   fNNodes = 0;
   fMaxVisNodes = 10000;
   fVolumes = new TObjArray(256);
   fPhysicalNodes = new TObjArray(256);
   fShapes = new TObjArray(256);
   fGVolumes = new TObjArray(256);
   fGShapes = new TObjArray(256);
   fTracks = new TObjArray(256);
   fMedia = new THashList(200,3);
   fNtracks = 0;
   fNpdg = 0;
   fPdgNames = 0;
   memset(fPdgId, 0, 1024*sizeof(Int_t));
   fCurrentTrack = 0;
   fCurrentVolume = 0;
   fTopVolume = 0;
   fTopNode = 0;
   fMasterVolume = 0;
   fPainter = 0;
   fActivity = kFALSE;
   fIsNodeSelectable = kFALSE;
   fVisDensity = 0.;
   fVisLevel = 3;
   fVisOption = 1;
   fExplodedView = 0;
   fNsegments = 20;
   fNLevel = 0;
   fUniqueVolumes = new TObjArray(256);
   fNodeIdArray = 0;
   fClippingShape = 0;
   fMatrixTransform = kFALSE;
   fMatrixReflection = kFALSE;
   fGLMatrix = new TGeoHMatrix();
   fPaintVolume = 0;
   fElementTable = 0;
   fHashVolumes = 0;
   fHashGVolumes = 0;
   fSizePNEId = 0;
   fNPNEId = 0;
   fKeyPNEId = 0;
   fValuePNEId = 0;
   fMultiThread = kFALSE;
   fMaxThreads = 0;
   fUsePWNav = kFALSE;
   fParallelWorld = 0;
   ClearThreadsMap();
}

//_____________________________________________________________________________
TGeoManager::TGeoManager(const TGeoManager& gm) :
  TNamed(gm),
  fPhimin(gm.fPhimin),
  fPhimax(gm.fPhimax),
  fTmin(gm.fTmin),
  fTmax(gm.fTmax),
  fNNodes(gm.fNNodes),
  fParticleName(gm.fParticleName),
  fVisDensity(gm.fVisDensity),
  fExplodedView(gm.fExplodedView),
  fVisOption(gm.fVisOption),
  fVisLevel(gm.fVisLevel),
  fNsegments(gm.fNsegments),
  fNtracks(gm.fNtracks),
  fMaxVisNodes(gm.fMaxVisNodes),
  fCurrentTrack(gm.fCurrentTrack),
  fNpdg(gm.fNpdg),
  fClosed(gm.fClosed),
  fLoopVolumes(gm.fLoopVolumes),
  fStreamVoxels(gm.fStreamVoxels),
  fIsGeomReading(gm.fIsGeomReading),
  fIsGeomCleaning(kFALSE),
  fPhiCut(gm.fPhiCut),
  fTimeCut(gm.fTimeCut),
  fDrawExtra(gm.fDrawExtra),
  fMatrixTransform(gm.fMatrixTransform),
  fMatrixReflection(gm.fMatrixReflection),
  fActivity(gm.fActivity),
  fIsNodeSelectable(gm.fIsNodeSelectable),
  fPainter(gm.fPainter),
  fMatrices(gm.fMatrices),
  fShapes(gm.fShapes),
  fVolumes(gm.fVolumes),
  fPhysicalNodes(gm.fPhysicalNodes),
  fGShapes(gm.fGShapes),
  fGVolumes(gm.fGVolumes),
  fTracks(gm.fTracks),
  fPdgNames(gm.fPdgNames),
  fMaterials(gm.fMaterials),
  fMedia(gm.fMedia),
  fNodes(gm.fNodes),
  fOverlaps(gm.fOverlaps),
  fBits(gm.fBits),
  fCurrentNavigator(gm.fCurrentNavigator),
  fCurrentVolume(gm.fCurrentVolume),
  fTopVolume(gm.fTopVolume),
  fTopNode(gm.fTopNode),
  fMasterVolume(gm.fMasterVolume),
  fGLMatrix(gm.fGLMatrix),
  fUniqueVolumes(gm.fUniqueVolumes),
  fClippingShape(gm.fClippingShape),
  fElementTable(gm.fElementTable),
  fNodeIdArray(gm.fNodeIdArray),
  fNLevel(gm.fNLevel),
  fPaintVolume(gm.fPaintVolume),
  fHashVolumes(gm.fHashVolumes),
  fHashGVolumes(gm.fHashGVolumes),
  fHashPNE(gm.fHashPNE),
  fArrayPNE(gm.fArrayPNE),
  fSizePNEId(0),
  fNPNEId(0),
  fKeyPNEId(0),
  fValuePNEId(0),
  fMaxThreads(0),
  fMultiThread(kFALSE),
  fUsePWNav(kFALSE),
  fParallelWorld(0)
{
   //copy constructor
   for(Int_t i=0; i<1024; i++)
      fPdgId[i]=gm.fPdgId[i];
   if (!fgThreadId) fgThreadId = new TGeoManager::ThreadsMap_t;
   ClearThreadsMap();
}

//_____________________________________________________________________________
TGeoManager& TGeoManager::operator=(const TGeoManager& gm)
{
   //assignment operator
   if (!fgThreadId) fgThreadId = new TGeoManager::ThreadsMap_t;
   if(this!=&gm) {
      TNamed::operator=(gm);
      fPhimin=gm.fPhimin;
      fPhimax=gm.fPhimax;
      fTmin=gm.fTmin;
      fTmax=gm.fTmax;
      fNNodes=gm.fNNodes;
      fParticleName=gm.fParticleName;
      fVisDensity=gm.fVisDensity;
      fExplodedView=gm.fExplodedView;
      fVisOption=gm.fVisOption;
      fVisLevel=gm.fVisLevel;
      fNsegments=gm.fNsegments;
      fNtracks=gm.fNtracks;
      fMaxVisNodes=gm.fMaxVisNodes;
      fCurrentTrack=gm.fCurrentTrack;
      fNpdg=gm.fNpdg;
      for(Int_t i=0; i<1024; i++)
         fPdgId[i]=gm.fPdgId[i];
      fClosed=gm.fClosed;
      fLoopVolumes=gm.fLoopVolumes;
      fStreamVoxels=gm.fStreamVoxels;
      fIsGeomReading=gm.fIsGeomReading;
      fIsGeomCleaning = kFALSE;
      fPhiCut=gm.fPhiCut;
      fTimeCut=gm.fTimeCut;
      fDrawExtra=gm.fDrawExtra;
      fMatrixTransform=gm.fMatrixTransform;
      fMatrixReflection=gm.fMatrixReflection;
      fActivity=gm.fActivity;
      fIsNodeSelectable=gm.fIsNodeSelectable;
      fPainter=gm.fPainter;
      fMatrices=gm.fMatrices;
      fShapes=gm.fShapes;
      fVolumes=gm.fVolumes;
      fPhysicalNodes=gm.fPhysicalNodes;
      fGShapes=gm.fGShapes;
      fGVolumes=gm.fGVolumes;
      fTracks=gm.fTracks;
      fPdgNames=gm.fPdgNames;
      fMaterials=gm.fMaterials;
      fMedia=gm.fMedia;
      fNodes=gm.fNodes;
      fOverlaps=gm.fOverlaps;
      fBits=gm.fBits;
      fCurrentNavigator=gm.fCurrentNavigator;
      fCurrentVolume = gm.fCurrentVolume;
      fTopVolume=gm.fTopVolume;
      fTopNode=gm.fTopNode;
      fMasterVolume=gm.fMasterVolume;
      fGLMatrix=gm.fGLMatrix;
      fUniqueVolumes=gm.fUniqueVolumes;
      fClippingShape=gm.fClippingShape;
      fElementTable=gm.fElementTable;
      fNodeIdArray=gm.fNodeIdArray;
      fNLevel=gm.fNLevel;
      fPaintVolume=gm.fPaintVolume;
      fHashVolumes=gm.fHashVolumes;
      fHashGVolumes=gm.fHashGVolumes;
      fHashPNE=gm.fHashPNE;
      fArrayPNE=gm.fArrayPNE;
      fSizePNEId = 0;
      fNPNEId = 0;
      fKeyPNEId = 0;
      fValuePNEId = 0;
      fMultiThread = kFALSE;
      fMaxThreads = 0;
      fUsePWNav = kFALSE;
      fParallelWorld = 0;
      ClearThreadsMap();
      ClearThreadData();
   }
   return *this;
}

//_____________________________________________________________________________
TGeoManager::~TGeoManager()
{
//   Destructor
   if (gGeoManager != this) gGeoManager = this;
   fIsGeomCleaning = kTRUE;

   if (gROOT->GetListOfFiles()) { //in case this function is called from TROOT destructor
      gROOT->GetListOfGeometries()->Remove(this);
      gROOT->GetListOfBrowsables()->Remove(this);
   }
//   TSeqCollection *brlist = gROOT->GetListOfBrowsers();
//   TIter next(brlist);
//   TBrowser *browser = 0;
//   while ((browser=(TBrowser*)next())) browser->RecursiveRemove(this);
   ClearThreadsMap();
   ClearThreadData();
   delete TGeoBuilder::Instance(this);
   if (fBits)  delete [] fBits;
   SafeDelete(fNodes);
   SafeDelete(fTopNode);
   if (fOverlaps) {fOverlaps->Delete(); SafeDelete(fOverlaps);}
   if (fMaterials) {fMaterials->Delete(); SafeDelete(fMaterials);}
   SafeDelete(fElementTable);
   if (fMedia) {fMedia->Delete(); SafeDelete(fMedia);}
   if (fHashVolumes) fHashVolumes->Clear("nodelete"); SafeDelete(fHashVolumes);
   if (fHashGVolumes) fHashGVolumes->Clear("nodelete"); SafeDelete(fHashGVolumes);
   if (fHashPNE) {fHashPNE->Delete(); SafeDelete(fHashPNE);}
   if (fArrayPNE) {delete fArrayPNE;}
   if (fVolumes) {fVolumes->Delete(); SafeDelete(fVolumes);}
   if (fShapes) {fShapes->Delete(); SafeDelete( fShapes );}
   if (fPhysicalNodes) {fPhysicalNodes->Delete(); SafeDelete( fPhysicalNodes );}
   if (fMatrices) {fMatrices->Delete(); SafeDelete( fMatrices );}
   if (fTracks) {fTracks->Delete(); SafeDelete( fTracks );}
   SafeDelete( fUniqueVolumes );
   if (fPdgNames) {fPdgNames->Delete(); SafeDelete( fPdgNames );}
   ClearNavigators();
   CleanGarbage();
   SafeDelete( fPainter );
   SafeDelete( fGLMatrix );
   if (fSizePNEId) {
      delete [] fKeyPNEId;
      delete [] fValuePNEId;
   }
   delete fParallelWorld;
   fIsGeomCleaning = kFALSE;
   gGeoIdentity = 0;
   gGeoManager = 0;
}

//_____________________________________________________________________________
Int_t TGeoManager::AddMaterial(const TGeoMaterial *material)
{
// Add a material to the list. Returns index of the material in list.
   return TGeoBuilder::Instance(this)->AddMaterial((TGeoMaterial*)material);
}

//_____________________________________________________________________________
Int_t TGeoManager::AddOverlap(const TNamed *ovlp)
{
// Add an illegal overlap/extrusion to the list.
   Int_t size = fOverlaps->GetEntriesFast();
   fOverlaps->Add((TObject*)ovlp);
   return size;
}

//_____________________________________________________________________________
Int_t TGeoManager::AddTransformation(const TGeoMatrix *matrix)
{
// Add a matrix to the list. Returns index of the matrix in list.
   return TGeoBuilder::Instance(this)->AddTransformation((TGeoMatrix*)matrix);
}

//_____________________________________________________________________________
Int_t TGeoManager::AddShape(const TGeoShape *shape)
{
// Add a shape to the list. Returns index of the shape in list.
   return TGeoBuilder::Instance(this)->AddShape((TGeoShape*)shape);
}

//_____________________________________________________________________________
Int_t TGeoManager::AddTrack(Int_t id, Int_t pdgcode, TObject *particle)
{
// Add a track to the list of tracks. Use this for primaries only. For secondaries,
// add them to the parent track. The method create objects that are registered
// to the analysis manager but have to be cleaned-up by the user via ClearTracks().
   Int_t index = fNtracks;
   fTracks->AddAtAndExpand(GetGeomPainter()->AddTrack(id,pdgcode,particle),fNtracks++);
   return index;
}

//_____________________________________________________________________________
Int_t TGeoManager::AddTrack(TVirtualGeoTrack *track)
{
// Add a track to the list of tracks
   Int_t index = fNtracks;
   fTracks->AddAtAndExpand(track,fNtracks++);
   return index;
}

//_____________________________________________________________________________
TVirtualGeoTrack *TGeoManager::MakeTrack(Int_t id, Int_t pdgcode, TObject *particle)
{
// Makes a primary track but do not attach it to the list of tracks. The track
// can be attached as daughter to another one with TVirtualGeoTrack::AddTrack
   TVirtualGeoTrack *track = GetGeomPainter()->AddTrack(id,pdgcode,particle);
   return track;
}

//_____________________________________________________________________________
Int_t TGeoManager::AddVolume(TGeoVolume *volume)
{
// Add a volume to the list. Returns index of the volume in list.
   if (!volume) {
      Error("AddVolume", "invalid volume");
      return -1;
   }
   Int_t uid = fUniqueVolumes->GetEntriesFast();
   if (!uid) uid++;
   if (!fCurrentVolume) {
      fCurrentVolume = volume;
      fUniqueVolumes->AddAtAndExpand(volume,uid);
   } else {
      if (!strcmp(volume->GetName(), fCurrentVolume->GetName())) {
         uid = fCurrentVolume->GetNumber();
      } else {
         fCurrentVolume = volume;
         Int_t olduid = GetUID(volume->GetName());
         if (olduid<0) {
            fUniqueVolumes->AddAtAndExpand(volume,uid);
         } else {
            uid = olduid;
         }
      }
   }
   volume->SetNumber(uid);
   if (!fHashVolumes) {
      fHashVolumes = new THashList(256);
      fHashGVolumes = new THashList(256);
   }
   TObjArray *list = fVolumes;
   if (!volume->GetShape() || volume->IsRunTime() || volume->IsVolumeMulti()) {
      list = fGVolumes;
      fHashGVolumes->Add(volume);
   } else {
      fHashVolumes->Add(volume);
   }
   Int_t index = list->GetEntriesFast();
   list->AddAtAndExpand(volume,index);
   return uid;
}

//_____________________________________________________________________________
TGeoNavigator *TGeoManager::AddNavigator()
{
// Add a navigator in the list of navigators. If it is the first one make it
// current navigator.
   if (fMultiThread) TThread::Lock();
//   if (fgLockNavigators) {
//      Error("AddNavigator", "Navigators are locked. Use SetNavigatorsLock(false) first.");
//      return 0;
//   }
   Long_t threadId = fMultiThread ? TThread::SelfId() : 0;
   NavigatorsMap_t::const_iterator it = fNavigators.find(threadId);
   TGeoNavigatorArray *array = 0;
   if (it != fNavigators.end()) array = it->second;
   else {
      array = new TGeoNavigatorArray(this);
      fNavigators.insert(NavigatorsMap_t::value_type(threadId, array));
   }
   TGeoNavigator *nav = array->AddNavigator();
   if (fClosed) nav->GetCache()->BuildInfoBranch();
   if (fMultiThread) TThread::UnLock();
   return nav;
}

//_____________________________________________________________________________
TGeoNavigator *TGeoManager::GetCurrentNavigator() const
{
// Returns current navigator for the calling thread.
   TTHREAD_TLS(TGeoNavigator*) tnav = 0;
   if (!fMultiThread) return fCurrentNavigator;
   TGeoNavigator *nav = tnav; // TTHREAD_TLS_GET(TGeoNavigator*,tnav);
   if (nav) return nav;
   Long_t threadId = TThread::SelfId();
   NavigatorsMap_t::const_iterator it = fNavigators.find(threadId);
   if (it == fNavigators.end()) return 0;
   TGeoNavigatorArray *array = it->second;
   nav = array->GetCurrentNavigator();
   tnav = nav; // TTHREAD_TLS_SET(TGeoNavigator*,tnav,nav);
   return nav;
}

//_____________________________________________________________________________
TGeoNavigatorArray *TGeoManager::GetListOfNavigators() const
{
// Get list of navigators for the calling thread.
   Long_t threadId = fMultiThread ? TThread::SelfId() : 0;
   NavigatorsMap_t::const_iterator it = fNavigators.find(threadId);
   if (it == fNavigators.end()) return 0;
   TGeoNavigatorArray *array = it->second;
   return array;
}

//_____________________________________________________________________________
Bool_t TGeoManager::SetCurrentNavigator(Int_t index)
{
// Switch to another existing navigator for the calling thread.
   Long_t threadId = fMultiThread ? TThread::SelfId() : 0;
   NavigatorsMap_t::const_iterator it = fNavigators.find(threadId);
   if (it == fNavigators.end()) {
      Error("SetCurrentNavigator", "No navigator defined for thread %ld\n", threadId);
      return kFALSE;
   }
   TGeoNavigatorArray *array = it->second;
   TGeoNavigator *nav = array->SetCurrentNavigator(index);
   if (!nav) {
      Error("SetCurrentNavigator", "Navigator %d not existing for thread %ld\n", index, threadId);
      return kFALSE;
   }
   if (!fMultiThread) fCurrentNavigator = nav;
   return kTRUE;
}

//_____________________________________________________________________________
void TGeoManager::SetNavigatorsLock(Bool_t flag)
{
// Set the lock for navigators.
   fgLockNavigators = flag;
}

//_____________________________________________________________________________
void TGeoManager::ClearNavigators()
{
// Clear all navigators.
   if (fMultiThread) TThread::Lock();
   TGeoNavigatorArray *arr = 0;
   for (NavigatorsMap_t::iterator it = fNavigators.begin();
        it != fNavigators.end(); it++) {
      arr = (*it).second;
      if (arr) delete arr;
   }
   fNavigators.clear();
   if (fMultiThread) TThread::UnLock();
}

//_____________________________________________________________________________
void TGeoManager::RemoveNavigator(const TGeoNavigator *nav)
{
// Clear a single navigator.
   if (fMultiThread) TThread::Lock();
   for (NavigatorsMap_t::iterator it = fNavigators.begin();
        it != fNavigators.end(); it++) {
      TGeoNavigatorArray *arr = (*it).second;
      if (arr) {
         if ((TGeoNavigator*)arr->Remove((TObject*)nav)) {
            delete nav;
            if (!arr->GetEntries()) fNavigators.erase(it);
            if (fMultiThread) TThread::UnLock();
            return;
         }
      }
   }
   Error("Remove navigator", "Navigator %p not found", nav);
   if (fMultiThread) TThread::UnLock();
}

//_____________________________________________________________________________
void TGeoManager::SetMaxThreads(Int_t nthreads)
{
// Set maximum number of threads for navigation.
   if (!fClosed) {
      Error("SetMaxThreads", "Cannot set maximum number of threads before closing the geometry");
      return;
   }
   if (!fMultiThread) {
      TThread::Initialize();
      Long_t threadId = TThread::SelfId();
      NavigatorsMap_t::const_iterator it = fNavigators.find(0);
      if (it != fNavigators.end()) {
         TGeoNavigatorArray *array = it->second;
         fNavigators.erase(it);
         fNavigators.insert(NavigatorsMap_t::value_type(threadId, array));
      }
   }
   if (fMaxThreads) {
      ClearThreadsMap();
      ClearThreadData();
   }
   fMaxThreads = nthreads+1;
   if (fMaxThreads>0) {
      fMultiThread = kTRUE;
      CreateThreadData();
   }
}

//______________________________________________________________________________
void TGeoManager::ClearThreadData() const
{
   if (!fMaxThreads) return;
   TThread::Lock();
   TIter next(fVolumes);
   TGeoVolume *vol;
   while ((vol=(TGeoVolume*)next())) vol->ClearThreadData();
   TThread::UnLock();
}

//______________________________________________________________________________
void TGeoManager::CreateThreadData() const
{
// Create thread private data for all geometry objects.
   if (!fMaxThreads) return;
   TThread::Lock();
   TIter next(fVolumes);
   TGeoVolume *vol;
   while ((vol=(TGeoVolume*)next())) vol->CreateThreadData(fMaxThreads);
   TThread::UnLock();
}

//_____________________________________________________________________________
void TGeoManager::ClearThreadsMap()
{
// Clear the current map of threads. This will be filled again by the calling
// threads via ThreadId calls.
   if (gGeoManager && !gGeoManager->IsMultiThread()) return;
   TThread::Lock();
   if (!fgThreadId->empty()) fgThreadId->clear();
   fgNumThreads = 0;
   TThread::UnLock();
}

//_____________________________________________________________________________
Int_t TGeoManager::ThreadId()
{
// Translates the current thread id to an ordinal number. This can be used to
// manage data which is pspecific for a given thread.
//   static __thread Int_t tid = -1;
//   if (tid > -1) return tid;
   TTHREAD_TLS(Int_t) tid = -1;
   Int_t ttid = tid; // TTHREAD_TLS_GET(Int_t,tid);
   if (ttid > -1) return ttid;
   if (gGeoManager && !gGeoManager->IsMultiThread()) return 0;
   TGeoManager::ThreadsMapIt_t it = fgThreadId->find(TThread::SelfId());
   if (it != fgThreadId->end()) return it->second;
   // Map needs to be updated.
   TThread::Lock();
   (*fgThreadId)[TThread::SelfId()] = fgNumThreads;
   tid = fgNumThreads; // TTHREAD_TLS_SET(Int_t,tid,fgNumThreads);
   ttid = fgNumThreads++;
   TThread::UnLock();
   return ttid;
}

//_____________________________________________________________________________
void TGeoManager::Browse(TBrowser *b)
{
// Describe how to browse this object.
   if (!b) return;
   if (fMaterials) b->Add(fMaterials, "Materials");
   if (fMedia)     b->Add(fMedia,     "Media");
   if (fMatrices)  b->Add(fMatrices, "Local transformations");
   if (fOverlaps)  b->Add(fOverlaps, "Illegal overlaps");
   if (fTracks)    b->Add(fTracks,   "Tracks");
   if (fMasterVolume) b->Add(fMasterVolume, "Master Volume", fMasterVolume->IsVisible());
   if (fTopVolume) b->Add(fTopVolume, "Top Volume", fTopVolume->IsVisible());
   if (fTopNode)   b->Add(fTopNode);
   TString browserImp(gEnv->GetValue("Browser.Name", "TRootBrowserLite"));
   TQObject::Connect(browserImp.Data(), "Checked(TObject*,Bool_t)",
                     "TGeoManager", this, "SetVisibility(TObject*,Bool_t)");
}

//_____________________________________________________________________________
void TGeoManager::Edit(Option_t *option) {
// Append a pad for this geometry.
   AppendPad("");
   GetGeomPainter()->EditGeometry(option);
}

//_____________________________________________________________________________
void TGeoManager::SetVisibility(TObject *obj, Bool_t vis)
{
// Set visibility for a volume.
   if(obj->IsA() == TGeoVolume::Class()) {
      TGeoVolume *vol = (TGeoVolume *) obj;
      vol->SetVisibility(vis);
   } else {
      if (obj->InheritsFrom(TGeoNode::Class())) {
         TGeoNode *node = (TGeoNode *) obj;
         node->SetVisibility(vis);
      } else return;
   }
   GetGeomPainter()->ModifiedPad(kTRUE);
}

//_____________________________________________________________________________
void TGeoManager::BombTranslation(const Double_t *tr, Double_t *bombtr)
{
// Get the new 'bombed' translation vector according current exploded view mode.
   if (fPainter) fPainter->BombTranslation(tr, bombtr);
   return;
}

//_____________________________________________________________________________
void TGeoManager::UnbombTranslation(const Double_t *tr, Double_t *bombtr)
{
// Get the new 'unbombed' translation vector according current exploded view mode.
   if (fPainter) fPainter->UnbombTranslation(tr, bombtr);
   return;
}

//_____________________________________________________________________________
void TGeoManager::DoBackupState()
{
// Backup the current state without affecting the cache stack.
   GetCurrentNavigator()->DoBackupState();
}

//_____________________________________________________________________________
void TGeoManager::DoRestoreState()
{
// Restore a backed-up state without affecting the cache stack.
   GetCurrentNavigator()->DoRestoreState();
}

//_____________________________________________________________________________
void TGeoManager::RegisterMatrix(const TGeoMatrix *matrix)
{
// Register a matrix to the list of matrices. It will be cleaned-up at the
// destruction TGeoManager.
   return TGeoBuilder::Instance(this)->RegisterMatrix((TGeoMatrix*)matrix);
}

//_____________________________________________________________________________
Int_t TGeoManager::ReplaceVolume(TGeoVolume *vorig, TGeoVolume *vnew)
{
// Replaces all occurences of VORIG with VNEW in the geometry tree. The volume VORIG
// is not replaced from the list of volumes, but all node referencing it will reference
// VNEW instead. Returns number of occurences changed.
   Int_t nref = 0;
   if (!vorig || !vnew) return nref;
   TGeoMedium *morig = vorig->GetMedium();
   Bool_t checkmed = kFALSE;
   if (morig) checkmed = kTRUE;
   TGeoMedium *mnew = vnew->GetMedium();
   // Try to limit the damage produced by incorrect usage.
   if (!mnew && !vnew->IsAssembly()) {
      Error("ReplaceVolume","Replacement volume %s has no medium and it is not an assembly",
             vnew->GetName());
      return nref;
   }
   if (mnew && checkmed) {
      if (mnew->GetId() != morig->GetId())
         Warning("ReplaceVolume","Replacement volume %s has different medium than original volume %s",
                 vnew->GetName(), vorig->GetName());
      checkmed = kFALSE;
   }

   // Medium checking now performed only if replacement is an assembly and old volume a real one.
   // Check result is dependent on positioning.
   Int_t nvol = fVolumes->GetEntriesFast();
   Int_t i,j,nd;
   Int_t ierr = 0;
   TGeoVolume *vol;
   TGeoNode *node;
   TGeoVoxelFinder *voxels;
   for (i=0; i<nvol; i++) {
      vol = (TGeoVolume*)fVolumes->At(i);
      if (!vol) continue;
      if (vol==vorig || vol==vnew) continue;
      nd = vol->GetNdaughters();
      for (j=0; j<nd; j++) {
         node = vol->GetNode(j);
         if (node->GetVolume() == vorig) {
            if (checkmed) {
               mnew = node->GetMotherVolume()->GetMedium();
               if (mnew && mnew->GetId()!=morig->GetId()) ierr++;
            }
            nref++;
            if (node->IsOverlapping()) {
               node->SetOverlapping(kFALSE);
               Info("ReplaceVolume","%s replaced with assembly and declared NON-OVERLAPPING!",node->GetName());
            }
            node->SetVolume(vnew);
            voxels = node->GetMotherVolume()->GetVoxels();
            if (voxels) voxels->SetNeedRebuild();
         } else {
            if (node->GetMotherVolume() == vorig) {
               nref++;
               node->SetMotherVolume(vnew);
               if (node->IsOverlapping()) {
                  node->SetOverlapping(kFALSE);
                  Info("ReplaceVolume","%s inside substitute assembly %s declared NON-OVERLAPPING!",node->GetName(),vnew->GetName());
               }
            }
         }
      }
   }
   if (ierr) Warning("ReplaceVolume", "Volumes should not be replaced with assemblies if they are positioned in containers having a different medium ID.\n %i occurences for assembly replacing volume %s",
                     ierr, vorig->GetName());
   return nref;
}

//_____________________________________________________________________________
Int_t TGeoManager::TransformVolumeToAssembly(const char *vname)
{
// Transform all volumes named VNAME to assemblies. The volumes must be virtual.
   TGeoVolume *toTransform = FindVolumeFast(vname);
   if (!toTransform) {
      Warning("TransformVolumeToAssembly", "Volume %s not found", vname);
      return 0;
   }
   Int_t index = fVolumes->IndexOf(toTransform);
   Int_t count = 0;
   Int_t indmax = fVolumes->GetEntries();
   Bool_t replace = kTRUE;
   TGeoVolume *transformed;
   while (index<indmax) {
      if (replace) {
         replace = kFALSE;
         transformed = TGeoVolumeAssembly::MakeAssemblyFromVolume(toTransform);
         if (transformed) {
            ReplaceVolume(toTransform, transformed);
            count++;
         } else {
            if (toTransform->IsAssembly())
               Warning("TransformVolumeToAssembly", "Volume %s already assembly", toTransform->GetName());
            if (!toTransform->GetNdaughters())
               Warning("TransformVolumeToAssembly", "Volume %s has no daughters, cannot transform", toTransform->GetName());
            if (toTransform->IsVolumeMulti())
               Warning("TransformVolumeToAssembly", "Volume %s divided, cannot transform", toTransform->GetName());
         }
      }
      index++;
      if (index >= indmax) return count;
      toTransform = (TGeoVolume*)fVolumes->At(index);
      if (!strcmp(toTransform->GetName(),vname)) replace = kTRUE;
   }
   return count;
}

//_____________________________________________________________________________
TGeoVolume *TGeoManager::Division(const char *name, const char *mother, Int_t iaxis,
                                  Int_t ndiv, Double_t start, Double_t step, Int_t numed, Option_t *option)
{
// Create a new volume by dividing an existing one (GEANT3 like)
//
// Divides MOTHER into NDIV divisions called NAME
// along axis IAXIS starting at coordinate value START
// and having size STEP. The created volumes will have tracking
// media ID=NUMED (if NUMED=0 -> same media as MOTHER)
//    The behavior of the division operation can be triggered using OPTION :
// OPTION (case insensitive) :
//  N  - divide all range in NDIV cells (same effect as STEP<=0) (GSDVN in G3)
//  NX - divide range starting with START in NDIV cells          (GSDVN2 in G3)
//  S  - divide all range with given STEP. NDIV is computed and divisions will be centered
//         in full range (same effect as NDIV<=0)                (GSDVS, GSDVT in G3)
//  SX - same as DVS, but from START position.                   (GSDVS2, GSDVT2 in G3)

   return TGeoBuilder::Instance(this)->Division(name, mother, iaxis, ndiv, start, step, numed, option);
}

//_____________________________________________________________________________
void TGeoManager::Matrix(Int_t index, Double_t theta1, Double_t phi1,
                         Double_t theta2, Double_t phi2,
                         Double_t theta3, Double_t phi3)
{
// Create rotation matrix named 'mat<index>'.
//
//  index    rotation matrix number
//  theta1   polar angle for axis X
//  phi1     azimuthal angle for axis X
//  theta2   polar angle for axis Y
//  phi2     azimuthal angle for axis Y
//  theta3   polar angle for axis Z
//  phi3     azimuthal angle for axis Z
//
   TGeoBuilder::Instance(this)->Matrix(index, theta1, phi1, theta2, phi2, theta3, phi3);
}

//_____________________________________________________________________________
TGeoMaterial *TGeoManager::Material(const char *name, Double_t a, Double_t z, Double_t dens, Int_t uid,Double_t radlen, Double_t intlen)
{
// Create material with given A, Z and density, having an unique id.
   return TGeoBuilder::Instance(this)->Material(name, a, z, dens, uid, radlen, intlen);

}

//_____________________________________________________________________________
TGeoMaterial *TGeoManager::Mixture(const char *name, Float_t *a, Float_t *z, Double_t dens,
                                   Int_t nelem, Float_t *wmat, Int_t uid)
{
// Create mixture OR COMPOUND IMAT as composed by THE BASIC nelem
// materials defined by arrays A,Z and WMAT, having an unique id.
   return TGeoBuilder::Instance(this)->Mixture(name, a, z, dens, nelem, wmat, uid);
}

//_____________________________________________________________________________
TGeoMaterial *TGeoManager::Mixture(const char *name, Double_t *a, Double_t *z, Double_t dens,
                                   Int_t nelem, Double_t *wmat, Int_t uid)
{
// Create mixture OR COMPOUND IMAT as composed by THE BASIC nelem
// materials defined by arrays A,Z and WMAT, having an unique id.
   return TGeoBuilder::Instance(this)->Mixture(name, a, z, dens, nelem, wmat, uid);
}

//_____________________________________________________________________________
TGeoMedium *TGeoManager::Medium(const char *name, Int_t numed, Int_t nmat, Int_t isvol,
                                Int_t ifield, Double_t fieldm, Double_t tmaxfd,
                                Double_t stemax, Double_t deemax, Double_t epsil,
                                Double_t stmin)
{
// Create tracking medium
  //
  //  numed      tracking medium number assigned
  //  name      tracking medium name
  //  nmat      material number
  //  isvol     sensitive volume flag
  //  ifield    magnetic field
  //  fieldm    max. field value (kilogauss)
  //  tmaxfd    max. angle due to field (deg/step)
  //  stemax    max. step allowed
  //  deemax    max. fraction of energy lost in a step
  //  epsil     tracking precision (cm)
  //  stmin     min. step due to continuous processes (cm)
  //
  //  ifield = 0 if no magnetic field; ifield = -1 if user decision in guswim;
  //  ifield = 1 if tracking performed with g3rkuta; ifield = 2 if tracking
  //  performed with g3helix; ifield = 3 if tracking performed with g3helx3.
  //
   return TGeoBuilder::Instance(this)->Medium(name, numed, nmat, isvol, ifield, fieldm, tmaxfd, stemax, deemax, epsil, stmin);
}

//_____________________________________________________________________________
void TGeoManager::Node(const char *name, Int_t nr, const char *mother,
                       Double_t x, Double_t y, Double_t z, Int_t irot,
                       Bool_t isOnly, Float_t *upar, Int_t npar)
{
// Create a node called <name_nr> pointing to the volume called <name>
// as daughter of the volume called <mother> (gspos). The relative matrix is
// made of : a translation (x,y,z) and a rotation matrix named <matIROT>.
// In case npar>0, create the volume to be positioned in mother, according
// its actual parameters (gsposp).
//  NAME   Volume name
//  NUMBER Copy number of the volume
//  MOTHER Mother volume name
//  X      X coord. of the volume in mother ref. sys.
//  Y      Y coord. of the volume in mother ref. sys.
//  Z      Z coord. of the volume in mother ref. sys.
//  IROT   Rotation matrix number w.r.t. mother ref. sys.
//  ISONLY ONLY/MANY flag

   TGeoBuilder::Instance(this)->Node(name, nr, mother, x, y, z, irot, isOnly, upar, npar);
}

//_____________________________________________________________________________
void TGeoManager::Node(const char *name, Int_t nr, const char *mother,
                       Double_t x, Double_t y, Double_t z, Int_t irot,
                       Bool_t isOnly, Double_t *upar, Int_t npar)
{
// Create a node called <name_nr> pointing to the volume called <name>
// as daughter of the volume called <mother> (gspos). The relative matrix is
// made of : a translation (x,y,z) and a rotation matrix named <matIROT>.
// In case npar>0, create the volume to be positioned in mother, according
// its actual parameters (gsposp).
//  NAME   Volume name
//  NUMBER Copy number of the volume
//  MOTHER Mother volume name
//  X      X coord. of the volume in mother ref. sys.
//  Y      Y coord. of the volume in mother ref. sys.
//  Z      Z coord. of the volume in mother ref. sys.
//  IROT   Rotation matrix number w.r.t. mother ref. sys.
//  ISONLY ONLY/MANY flag
   TGeoBuilder::Instance(this)->Node(name, nr, mother, x, y, z, irot, isOnly, upar, npar);

}

//_____________________________________________________________________________
TGeoVolume *TGeoManager::Volume(const char *name, const char *shape, Int_t nmed,
                                Float_t *upar, Int_t npar)
{
// Create a volume in GEANT3 style.
//  NAME   Volume name
//  SHAPE  Volume type
//  NMED   Tracking medium number
//  NPAR   Number of shape parameters
//  UPAR   Vector containing shape parameters
   return TGeoBuilder::Instance(this)->Volume(name, shape, nmed, upar, npar);
}

//_____________________________________________________________________________
TGeoVolume *TGeoManager::Volume(const char *name, const char *shape, Int_t nmed,
                                Double_t *upar, Int_t npar)
{
// Create a volume in GEANT3 style.
//  NAME   Volume name
//  SHAPE  Volume type
//  NMED   Tracking medium number
//  NPAR   Number of shape parameters
//  UPAR   Vector containing shape parameters
   return TGeoBuilder::Instance(this)->Volume(name, shape, nmed, upar, npar);
}

//_____________________________________________________________________________
void TGeoManager::SetAllIndex()
{
// Assigns uid's for all materials,media and matrices.
   Int_t index = 1;
   TIter next(fMaterials);
   TGeoMaterial *mater;
   while ((mater=(TGeoMaterial*)next())) {
      mater->SetUniqueID(index++);
      mater->ResetBit(TGeoMaterial::kMatSavePrimitive);
   }
   index = 1;
   TIter next1(fMedia);
   TGeoMedium *med;
   while ((med=(TGeoMedium*)next1())) {
      med->SetUniqueID(index++);
      med->ResetBit(TGeoMedium::kMedSavePrimitive);
   }
   index = 1;
   TIter next2(fShapes);
   TGeoShape *shape;
   while ((shape=(TGeoShape*)next2())) {
      shape->SetUniqueID(index++);
      if (shape->IsComposite()) ((TGeoCompositeShape*)shape)->GetBoolNode()->RegisterMatrices();
   }

   TIter next3(fMatrices);
   TGeoMatrix *matrix;
   while ((matrix=(TGeoMatrix*)next3())) {
      matrix->RegisterYourself();
   }
   TIter next4(fMatrices);
   index = 1;
   while ((matrix=(TGeoMatrix*)next4())) {
      matrix->SetUniqueID(index++);
      matrix->ResetBit(TGeoMatrix::kGeoSavePrimitive);
   }
   TIter next5(fVolumes);
   TGeoVolume *vol;
   while ((vol=(TGeoVolume*)next5())) vol->UnmarkSaved();
}

//_____________________________________________________________________________
void TGeoManager::ClearAttributes()
{
// Reset all attributes to default ones. Default attributes for visualization
// are those defined before closing the geometry.
   if (gPad) delete gPad;
   gPad = 0;
   SetVisOption(0);
   SetVisLevel(3);
   SetExplodedView(0);
   SetBombFactors();
   if (!gStyle) return;
   TIter next(fVolumes);
   TGeoVolume *vol = 0;
   while ((vol=(TGeoVolume*)next())) {
      if (!vol->IsVisTouched()) continue;
      vol->SetVisTouched(kFALSE);
   }
}
//_____________________________________________________________________________
void TGeoManager::CloseGeometry(Option_t *option)
{
// Closing geometry implies checking the geometry validity, fixing shapes
// with negative parameters (run-time shapes)building the cache manager,
// voxelizing all volumes, counting the total number of physical nodes and
// registring the manager class to the browser.
   if (fClosed) {
      Warning("CloseGeometry", "geometry already closed");
      return;
   }
   if (!fMasterVolume) {
      Error("CloseGeometry","you MUST call SetTopVolume() first !");
      return;
   }
   if (!gROOT->GetListOfGeometries()->FindObject(this)) gROOT->GetListOfGeometries()->Add(this);
   if (!gROOT->GetListOfBrowsables()->FindObject(this)) gROOT->GetListOfBrowsables()->Add(this);
//   TSeqCollection *brlist = gROOT->GetListOfBrowsers();
//   TIter next(brlist);
//   TBrowser *browser = 0;
//   while ((browser=(TBrowser*)next())) browser->Refresh();
   TString opt(option);
   opt.ToLower();
//   Bool_t dummy = opt.Contains("d");
   Bool_t nodeid = opt.Contains("i");
   // Create a geometry navigator if not present
   TGeoNavigator *nav = 0;
   Int_t nnavigators = 0;
   // Check if the geometry is streamed from file
   if (fIsGeomReading) {
      if (fgVerboseLevel>0) Info("CloseGeometry","Geometry loaded from file...");
      gGeoIdentity=(TGeoIdentity *)fMatrices->At(0);
      if (!fElementTable) fElementTable = new TGeoElementTable(200);
      if (!fTopNode) {
         if (!fMasterVolume) {
            Error("CloseGeometry", "Master volume not streamed");
            return;
         }
         SetTopVolume(fMasterVolume);
         if (fStreamVoxels && fgVerboseLevel>0) Info("CloseGeometry","Voxelization retrieved from file");
      }
      // Create a geometry navigator if not present
      if (!GetCurrentNavigator()) fCurrentNavigator = AddNavigator();
      nnavigators = GetListOfNavigators()->GetEntriesFast();
      TIter next(fShapes);
      TGeoShape *shape;
      while ((shape = (TGeoShape*)next())) shape->AfterStreamer();
      Voxelize("ALL");
      CountLevels();
      for (Int_t i=0; i<nnavigators; i++) {
         nav = (TGeoNavigator*)GetListOfNavigators()->At(i);
         nav->GetCache()->BuildInfoBranch();
         if (nodeid) nav->GetCache()->BuildIdArray();
      }
      if (!fHashVolumes) {
         Int_t nvol = fVolumes->GetEntriesFast();
         Int_t ngvol = fGVolumes->GetEntriesFast();
         fHashVolumes = new THashList(nvol+1);
         fHashGVolumes = new THashList(ngvol+1);
         Int_t i;
         for (i=0; i<ngvol; i++) fHashGVolumes->AddLast(fGVolumes->At(i));
         for (i=0; i<nvol; i++) fHashVolumes->AddLast(fVolumes->At(i));
      }
      fClosed = kTRUE;
      if (fParallelWorld) {
         if (fgVerboseLevel>0) Info("CloseGeometry","Recreating parallel world %s ...",fParallelWorld->GetName());
         fParallelWorld->CloseGeometry();
      }   

      if (fgVerboseLevel>0) Info("CloseGeometry","%i nodes/ %i volume UID's in %s", fNNodes, fUniqueVolumes->GetEntriesFast()-1, GetTitle());
      if (fgVerboseLevel>0) Info("CloseGeometry","----------------modeler ready----------------");
      return;
   }

   // Create a geometry navigator if not present
   if (!GetCurrentNavigator()) fCurrentNavigator = AddNavigator();
   nnavigators = GetListOfNavigators()->GetEntriesFast();
   SelectTrackingMedia();
   CheckGeometry();
   if (fgVerboseLevel>0) Info("CloseGeometry","Counting nodes...");
   fNNodes = CountNodes();
   fNLevel = fMasterVolume->CountNodes(1,3)+1;
   if (fNLevel<30) fNLevel = 100;

//   BuildIdArray();
   Voxelize("ALL");
   if (fgVerboseLevel>0) Info("CloseGeometry","Building cache...");
   CountLevels();
   for (Int_t i=0; i<nnavigators; i++) {
      nav = (TGeoNavigator*)GetListOfNavigators()->At(i);
      nav->GetCache()->BuildInfoBranch();
      if (nodeid) nav->GetCache()->BuildIdArray();
   }
   fClosed = kTRUE;
   if (fgVerboseLevel>0) {
      Info("CloseGeometry","%i nodes/ %i volume UID's in %s", fNNodes, fUniqueVolumes->GetEntriesFast()-1, GetTitle());
      Info("CloseGeometry","----------------modeler ready----------------");
   }
}

//_____________________________________________________________________________
void TGeoManager::ClearOverlaps()
{
// Clear the list of overlaps.
   if (fOverlaps) {
      fOverlaps->Delete();
      delete fOverlaps;
   }
   fOverlaps = new TObjArray();
}

//_____________________________________________________________________________
void TGeoManager::ClearShape(const TGeoShape *shape)
{
// Remove a shape from the list of shapes.
   if (fShapes->FindObject(shape)) fShapes->Remove((TGeoShape*)shape);
   delete shape;
}
//_____________________________________________________________________________
void TGeoManager::CleanGarbage()
{
// Clean temporary volumes and shapes from garbage collection.
   if (!fGVolumes && !fGShapes) return;
   Int_t i,nentries;
   if (fGVolumes) {
      nentries = fGVolumes->GetEntries();
      TGeoVolume *vol = 0;
      for (i=0; i<nentries; i++) {
         vol=(TGeoVolume*)fGVolumes->At(i);
         if (vol) vol->SetFinder(0);
      }
      fGVolumes->Delete();
      delete fGVolumes;
      fGVolumes = 0;
   }
   if (fGShapes) {
      fGShapes->Delete();
      delete fGShapes;
      fGShapes = 0;
   }
}

//_____________________________________________________________________________
void TGeoManager::CdNode(Int_t nodeid)
{
// Change current path to point to the node having this id.
// Node id has to be in range : 0 to fNNodes-1 (no check for performance reasons)
   GetCurrentNavigator()->CdNode(nodeid);
}

//_____________________________________________________________________________
Int_t TGeoManager::GetCurrentNodeId() const
{
// Get the unique ID of the current node.
   return GetCurrentNavigator()->GetCurrentNodeId();
}

//_____________________________________________________________________________
void TGeoManager::CdTop()
{
// Make top level node the current node. Updates the cache accordingly.
// Determine the overlapping state of current node.
   GetCurrentNavigator()->CdTop();
}

//_____________________________________________________________________________
void TGeoManager::CdUp()
{
// Go one level up in geometry. Updates cache accordingly.
// Determine the overlapping state of current node.
   GetCurrentNavigator()->CdUp();
}
//_____________________________________________________________________________
void TGeoManager::CdDown(Int_t index)
{
// Make a daughter of current node current. Can be called only with a valid
// daughter index (no check). Updates cache accordingly.
   GetCurrentNavigator()->CdDown(index);
}

//_____________________________________________________________________________
void TGeoManager::CdNext()
{
// Do a cd to the node found next by FindNextBoundary
   GetCurrentNavigator()->CdNext();
}

//_____________________________________________________________________________
Bool_t TGeoManager::cd(const char *path)
{
// Browse the tree of nodes starting from fTopNode according to pathname.
// Changes the path accordingly.
   return GetCurrentNavigator()->cd(path);
}

//_____________________________________________________________________________
Bool_t TGeoManager::CheckPath(const char *path) const
{
// Check if a geometry path is valid without changing the state of the current navigator.
   return GetCurrentNavigator()->CheckPath(path);
}

//_____________________________________________________________________________
void TGeoManager::ConvertReflections()
{
// Convert all reflections in geometry to normal rotations + reflected shapes.
   if (!fTopNode) return;
   if (fgVerboseLevel>0) Info("ConvertReflections", "Converting reflections in: %s - %s ...", GetName(), GetTitle());
   TGeoIterator next(fTopVolume);
   TGeoNode *node;
   TGeoNodeMatrix *nodematrix;
   TGeoMatrix *matrix, *mclone;
   TGeoVolume *reflected;
   while ((node=next())) {
      matrix = node->GetMatrix();
      if (matrix->IsReflection()) {
//         printf("%s before\n", node->GetName());
//         matrix->Print();
         mclone = new TGeoCombiTrans(*matrix);
         mclone->RegisterYourself();
         // Reflect just the rotation component
         mclone->ReflectZ(kFALSE, kTRUE);
         nodematrix = (TGeoNodeMatrix*)node;
         nodematrix->SetMatrix(mclone);
//         printf("%s after\n", node->GetName());
//         node->GetMatrix()->Print();
         reflected = node->GetVolume()->MakeReflectedVolume();
         node->SetVolume(reflected);
      }
   }
   if (fgVerboseLevel>0) Info("ConvertReflections", "Done");
}

//_____________________________________________________________________________
void TGeoManager::CountLevels()
{
// Count maximum number of nodes per volume, maximum depth and maximum
// number of xtru vertices.
   if (!fTopNode) {
      Error("CountLevels", "Top node not defined.");
      return;
   }
   TGeoIterator next(fTopVolume);
   Bool_t fixrefs = fIsGeomReading && (fMasterVolume->GetRefCount()==1);
   if (fMasterVolume->GetRefCount()>1) fMasterVolume->Release();
   if (fgVerboseLevel>1 && fixrefs) Info("CountLevels", "Fixing volume reference counts");
   TGeoNode *node;
   Int_t maxlevel = 1;
   Int_t maxnodes = fTopVolume->GetNdaughters();
   Int_t maxvertices = 1;
   while ((node=next())) {
      if (fixrefs) {
         node->GetVolume()->Grab();
         for (Int_t ibit=10; ibit<14; ibit++) {
            node->SetBit(BIT(ibit+4), node->TestBit(BIT(ibit)));
//            node->ResetBit(BIT(ibit)); // cannot overwrite old crap for reproducibility
         }
      }
      if (node->GetVolume()->GetVoxels()) {
         if (node->GetNdaughters()>maxnodes) maxnodes = node->GetNdaughters();
      }
      if (next.GetLevel()>maxlevel) maxlevel = next.GetLevel();
      if (node->GetVolume()->GetShape()->IsA()==TGeoXtru::Class()) {
         TGeoXtru *xtru = (TGeoXtru*)node->GetVolume()->GetShape();
         if (xtru->GetNvert()>maxvertices) maxvertices = xtru->GetNvert();
      }
   }
   fgMaxLevel = maxlevel;
   fgMaxDaughters = maxnodes;
   fgMaxXtruVert = maxvertices;
   if (fgVerboseLevel>0) Info("CountLevels", "max level = %d, max placements = %d", fgMaxLevel, fgMaxDaughters);
}

//_____________________________________________________________________________
Int_t TGeoManager::CountNodes(const TGeoVolume *vol, Int_t nlevels, Int_t option)
{
// Count the total number of nodes starting from a volume, nlevels down.
   TGeoVolume *top;
   if (!vol) {
      top = fTopVolume;
   } else {
      top = (TGeoVolume*)vol;
   }
   Int_t count = top->CountNodes(nlevels, option);
   return count;
}

//_____________________________________________________________________________
void TGeoManager::DefaultAngles()
{
// Set default angles for a given view.
   if (fPainter) fPainter->DefaultAngles();
}

//_____________________________________________________________________________
void TGeoManager::DrawCurrentPoint(Int_t color)
{
// Draw current point in the same view.
   if (fPainter) fPainter->DrawCurrentPoint(color);
}

//_____________________________________________________________________________
void TGeoManager::AnimateTracks(Double_t tmin, Double_t tmax, Int_t nframes, Option_t *option)
{
// Draw animation of tracks
   SetAnimateTracks();
   GetGeomPainter();
   if (tmin<0 || tmin>=tmax || nframes<1) return;
   Double_t *box = fPainter->GetViewBox();
   box[0] = box[1] = box[2] = 0;
   box[3] = box[4] = box[5] = 100;
   Double_t dt = (tmax-tmin)/Double_t(nframes);
   Double_t delt = 2E-9;
   Double_t t = tmin;
   Int_t i, j;
   TString opt(option);
   Bool_t save = kFALSE, geomanim=kFALSE;
   TString fname;
   if (opt.Contains("/S")) save = kTRUE;

   if (opt.Contains("/G")) geomanim = kTRUE;
   SetTminTmax(0,0);
   DrawTracks(opt.Data());
   Double_t start[6], end[6];
   Double_t dd[6] = {0,0,0,0,0,0};
   Double_t dlat=0, dlong=0, dpsi=0;
   if (geomanim) {
      fPainter->EstimateCameraMove(tmin+5*dt, tmin+15*dt, start, end);
      for (i=0; i<3; i++) {
         start[i+3] = 20 + 1.3*start[i+3];
         end[i+3] = 20 + 0.9*end[i+3];
      }
      for (i=0; i<6; i++) {
         dd[i] = (end[i]-start[i])/10.;
      }
      memcpy(box, start, 6*sizeof(Double_t));
      fPainter->GetViewAngles(dlong,dlat,dpsi);
      dlong = (-206-dlong)/Double_t(nframes);
      dlat  = (126-dlat)/Double_t(nframes);
      dpsi  = (75-dpsi)/Double_t(nframes);
      fPainter->GrabFocus();
   }

   for (i=0; i<nframes; i++) {
      if (t-delt<0) SetTminTmax(t-delt,t);
      else gGeoManager->SetTminTmax(t-delt,t);
      if (geomanim) {
         for (j=0; j<6; j++) box[j]+=dd[j];
         fPainter->GrabFocus(1,dlong,dlat,dpsi);
      } else {
         ModifiedPad();
      }
      if (save) {
         fname = TString::Format("anim%04d.gif", i);
         gPad->Print(fname);
      }
      t += dt;
   }
   SetAnimateTracks(kFALSE);
}

//_____________________________________________________________________________
void TGeoManager::DrawTracks(Option_t *option)
{
// Draw tracks over the geometry, according to option. By default, only
// primaries are drawn. See TGeoTrack::Draw() for additional options.
   TVirtualGeoTrack *track;
   //SetVisLevel(1);
   //SetVisOption(1);
   SetAnimateTracks();
   for (Int_t i=0; i<fNtracks; i++) {
      track = GetTrack(i);
      if (track) track->Draw(option);
   }
   SetAnimateTracks(kFALSE);
   ModifiedPad();
}

//_____________________________________________________________________________
void TGeoManager::DrawPath(const char *path, Option_t *option)
{
// Draw current path
   if (!fTopVolume) return;
   fTopVolume->SetVisBranch();
   GetGeomPainter()->DrawPath(path, option);
}
//_____________________________________________________________________________
void TGeoManager::RandomPoints(const TGeoVolume *vol, Int_t npoints, Option_t *option)
{
// Draw random points in the bounding box of a volume.
   GetGeomPainter()->RandomPoints((TGeoVolume*)vol, npoints, option);
}
//_____________________________________________________________________________
void TGeoManager::Test(Int_t npoints, Option_t *option)
{
// Check time of finding "Where am I" for n points.
   GetGeomPainter()->Test(npoints, option);
}
//_____________________________________________________________________________
void TGeoManager::TestOverlaps(const char* path)
{
// Geometry overlap checker based on sampling.
   GetGeomPainter()->TestOverlaps(path);
}
//_____________________________________________________________________________
void TGeoManager::GetBranchNames(Int_t *names) const
{
// Fill volume names of current branch into an array.
   GetCurrentNavigator()->GetBranchNames(names);
}
//_____________________________________________________________________________
const char *TGeoManager::GetPdgName(Int_t pdg) const
{
// Get name for given pdg code;
   static char defaultname[5] = { "XXX" };
   if (!fPdgNames || !pdg) return defaultname;
   for (Int_t i=0; i<fNpdg; i++) {
      if (fPdgId[i]==pdg) return fPdgNames->At(i)->GetName();
   }
   return defaultname;
}

//_____________________________________________________________________________
void TGeoManager::SetPdgName(Int_t pdg, const char *name)
{
// Set a name for a particle having a given pdg.
   if (!pdg) return;
   if (!fPdgNames) {
      fPdgNames = new TObjArray(1024);
   }
   if (!strcmp(name, GetPdgName(pdg))) return;
   // store pdg name
   if (fNpdg>1023) {
      Warning("SetPdgName", "No more than 256 different pdg codes allowed");
      return;
   }
   fPdgId[fNpdg] = pdg;
   TNamed *pdgname = new TNamed(name, "");
   fPdgNames->AddAtAndExpand(pdgname, fNpdg++);
}

//_____________________________________________________________________________
void TGeoManager::GetBranchNumbers(Int_t *copyNumbers, Int_t *volumeNumbers) const
{
// Fill node copy numbers of current branch into an array.
   GetCurrentNavigator()->GetBranchNumbers(copyNumbers, volumeNumbers);
}

//_____________________________________________________________________________
void TGeoManager::GetBranchOnlys(Int_t *isonly) const
{
// Fill node copy numbers of current branch into an array.
   GetCurrentNavigator()->GetBranchOnlys(isonly);
}

//_____________________________________________________________________________
void TGeoManager::GetBombFactors(Double_t &bombx, Double_t &bomby, Double_t &bombz, Double_t &bombr) const
{
// Retrieve cartesian and radial bomb factors.
   if (fPainter) {
      fPainter->GetBombFactors(bombx, bomby, bombz, bombr);
      return;
   }
   bombx = bomby = bombz = bombr = 1.3;
}

//_____________________________________________________________________________
Int_t TGeoManager::GetMaxDaughters()
{
// Return maximum number of daughters of a volume used in the geometry.
   return fgMaxDaughters;
}

//_____________________________________________________________________________
Int_t TGeoManager::GetMaxLevels()
{
// Return maximum number of levels used in the geometry.
   return fgMaxLevel;
}

//_____________________________________________________________________________
Int_t TGeoManager::GetMaxXtruVert()
{
// Return maximum number of vertices for an xtru shape used.
   return fgMaxXtruVert;
}

//_____________________________________________________________________________
Int_t TGeoManager::GetNumThreads()
{
// Returns number of threads that were set to use geometry.
   return fgNumThreads;
}

//_____________________________________________________________________________
TGeoHMatrix *TGeoManager::GetHMatrix()
{
// Return stored current matrix (global matrix of the next touched node).
   if (!GetCurrentNavigator()) return NULL;
   return GetCurrentNavigator()->GetHMatrix();
}

//_____________________________________________________________________________
Int_t TGeoManager::GetVisLevel() const
{
// Returns current depth to which geometry is drawn.
   return fVisLevel;
}

//_____________________________________________________________________________
Int_t TGeoManager::GetVisOption() const
{
// Returns current depth to which geometry is drawn.
   return fVisOption;
}

//_____________________________________________________________________________
Int_t TGeoManager::GetVirtualLevel()
{
// Find level of virtuality of current overlapping node (number of levels
// up having the same tracking media.

   return GetCurrentNavigator()->GetVirtualLevel();
}
//_____________________________________________________________________________
TVirtualGeoTrack *TGeoManager::FindTrackWithId(Int_t id) const
{
// Search the track hierarchy to find the track with the
// given id
//
// if 'primsFirst' is true, then:
// first tries TGeoManager::GetTrackOfId, then does a
// recursive search if that fails. this would be faster
// if the track is somehow known to be a primary
   TVirtualGeoTrack* trk = 0;
   trk = GetTrackOfId(id);
   if (trk) return trk;
   // need recursive search
   TIter next(fTracks);
   TVirtualGeoTrack* prim;
   while ((prim = (TVirtualGeoTrack*)next())) {
      trk = prim->FindTrackWithId(id);
      if (trk) return trk;
   }
   return NULL;
}

//_____________________________________________________________________________
TVirtualGeoTrack *TGeoManager::GetTrackOfId(Int_t id) const
{
// Get track with a given ID.
   TVirtualGeoTrack *track;
   for (Int_t i=0; i<fNtracks; i++) {
      if ((track = (TVirtualGeoTrack *)fTracks->UncheckedAt(i))) {
         if (track->GetId() == id) return track;
      }
   }
   return 0;
}

//_____________________________________________________________________________
TVirtualGeoTrack *TGeoManager::GetParentTrackOfId(Int_t id) const
{
// Get parent track with a given ID.
   TVirtualGeoTrack *track = fCurrentTrack;
   while ((track=track->GetMother())) {
      if (track->GetId()==id) return track;
   }
   return 0;
}

//_____________________________________________________________________________
Int_t TGeoManager::GetTrackIndex(Int_t id) const
{
// Get index for track id, -1 if not found.
   TVirtualGeoTrack *track;
   for (Int_t i=0; i<fNtracks; i++) {
      if ((track = (TVirtualGeoTrack *)fTracks->UncheckedAt(i))) {
         if (track->GetId() == id) return i;
      }
   }
   return -1;
}

//_____________________________________________________________________________
Bool_t TGeoManager::GotoSafeLevel()
{
// Go upwards the tree until a non-overlaping node
   return GetCurrentNavigator()->GotoSafeLevel();
}

//_____________________________________________________________________________
Int_t TGeoManager::GetSafeLevel() const
{
// Go upwards the tree until a non-overlaping node
   return GetCurrentNavigator()->GetSafeLevel();
}

//_____________________________________________________________________________
void TGeoManager::DefaultColors()
{
// Set default volume colors according to A of material

   const Int_t nmax = 110;
   Int_t col[nmax];
   for (Int_t i=0;i<nmax;i++) col[i] = kGray;

   //here we should create a new TColor with the same rgb as in the default
   //ROOT colors used below
   col[ 3] = kYellow-10;
   col[ 4] = col[ 5] = kGreen-10;
   col[ 6] = col[ 7] = kBlue-7;
   col[ 8] = col[ 9] = kMagenta-3;
   col[10] = col[11] = kRed-10;
   col[12] = kGray+1;
   col[13] = kBlue-10;
   col[14] = kOrange+7;
   col[16] = kYellow+1;
   col[20] = kYellow-10;
   col[24] = col[25] = col[26] = kBlue-8;
   col[29] = kOrange+9;
   col[79] = kOrange-2;

   TGeoVolume *vol;
   TIter next(fVolumes);
   while ((vol=(TGeoVolume*)next())) {
      TGeoMedium *med = vol->GetMedium();
      if (!med) continue;
      TGeoMaterial *mat = med->GetMaterial();
      Int_t matZ = (Int_t)mat->GetZ();
      vol->SetLineColor(col[matZ]);
      if (mat->GetDensity()<0.1) vol->SetTransparency(60);
   }
}

//_____________________________________________________________________________
Double_t TGeoManager::Safety(Bool_t inside)
{
// Compute safe distance from the current point. This represent the distance
// from POINT to the closest boundary.

   return GetCurrentNavigator()->Safety(inside);
}

//_____________________________________________________________________________
void TGeoManager::SetVolumeAttribute(const char *name, const char *att, Int_t val)
{
// Set volume attributes in G3 style.
   TGeoVolume *volume;
   Bool_t all = kFALSE;
   if (strstr(name,"*")) all=kTRUE;
   Int_t ivo=0;
   TIter next(fVolumes);
   TString chatt = att;
   chatt.ToLower();
   while ((volume=(TGeoVolume*)next())) {
      if (strcmp(volume->GetName(), name) && !all) continue;
      ivo++;
      if (chatt.Contains("colo")) volume->SetLineColor(val);
      if (chatt.Contains("lsty")) volume->SetLineStyle(val);
      if (chatt.Contains("lwid")) volume->SetLineWidth(val);
      if (chatt.Contains("fill")) volume->SetFillColor(val);
      if (chatt.Contains("seen")) volume->SetVisibility(val);
   }
   TIter next1(fGVolumes);
   while ((volume=(TGeoVolume*)next1())) {
      if (strcmp(volume->GetName(), name) && !all) continue;
      ivo++;
      if (chatt.Contains("colo")) volume->SetLineColor(val);
      if (chatt.Contains("lsty")) volume->SetLineStyle(val);
      if (chatt.Contains("lwid")) volume->SetLineWidth(val);
      if (chatt.Contains("fill")) volume->SetFillColor(val);
      if (chatt.Contains("seen")) volume->SetVisibility(val);
   }
   if (!ivo) {
      Warning("SetVolumeAttribute","volume: %s does not exist",name);
   }
}
//_____________________________________________________________________________
void TGeoManager::SetBombFactors(Double_t bombx, Double_t bomby, Double_t bombz, Double_t bombr)
{
// Set factors that will "bomb" all translations in cartesian and cylindrical coordinates.
   if (fPainter) fPainter->SetBombFactors(bombx, bomby, bombz, bombr);
}

//_____________________________________________________________________________
void TGeoManager::SetClippingShape(TGeoShape *shape)
{
// Set a user-defined shape as clipping for ray tracing.
   TVirtualGeoPainter *painter = GetGeomPainter();
   if (shape) {
      if (fClippingShape && (fClippingShape!=shape)) ClearShape(fClippingShape);
      fClippingShape = shape;
   }
   painter->SetClippingShape(shape);
}

//_____________________________________________________________________________
void TGeoManager::SetMaxVisNodes(Int_t maxnodes) {
// set the maximum number of visible nodes.
   fMaxVisNodes = maxnodes;
   if (maxnodes>0 && fgVerboseLevel>0)
      Info("SetMaxVisNodes","Automatic visible depth for %d visible nodes", maxnodes);
   if (!fPainter) return;
   fPainter->CountVisibleNodes();
   Int_t level = fPainter->GetVisLevel();
   if (level != fVisLevel) fVisLevel = level;
}

//_____________________________________________________________________________
void TGeoManager::SetTopVisible(Bool_t vis) {
// make top volume visible on screen
   GetGeomPainter();
   fPainter->SetTopVisible(vis);
}

//_____________________________________________________________________________
void TGeoManager::SetCheckedNode(TGeoNode *node) {
// Assign a given node to be checked for ovelaps. Any other overlaps will be ignored.
   GetGeomPainter()->SetCheckedNode(node);
}
//_____________________________________________________________________________
void TGeoManager::SetNmeshPoints(Int_t npoints)
{
// Set the number of points to be generated on the shape outline when checking
// for overlaps.
   GetGeomPainter()->SetNmeshPoints(npoints);
}

//_____________________________________________________________________________
void TGeoManager::SetVisOption(Int_t option) {
// set drawing mode :
// option=0 (default) all nodes drawn down to vislevel
// option=1           leaves and nodes at vislevel drawn
// option=2           path is drawn
// option=4           visibility changed
   if ((option>=0) && (option<3)) fVisOption=option;
   if (fPainter) fPainter->SetVisOption(option);
}

//_____________________________________________________________________________
void TGeoManager::ViewLeaves(Bool_t flag)
{
// Set visualization option (leaves only OR all volumes)
   if (flag) SetVisOption(1);
   else      SetVisOption(0);
}

//_____________________________________________________________________________
void TGeoManager::SetVisDensity(Double_t density)
{
// Set density threshold. Volumes with densities lower than this become
// transparent.
   fVisDensity = density;
   if (fPainter) fPainter->ModifiedPad();
}

//_____________________________________________________________________________
void TGeoManager::SetVisLevel(Int_t level) {
// set default level down to which visualization is performed
   if (level>0) {
      fVisLevel = level;
      fMaxVisNodes = 0;
      if (fgVerboseLevel>0)
         Info("SetVisLevel","Automatic visible depth disabled");
      if (fPainter) fPainter->CountVisibleNodes();
   } else {
      SetMaxVisNodes();
   }
}

//_____________________________________________________________________________
void TGeoManager::SortOverlaps()
{
// Sort overlaps by decreasing overlap distance. Extrusions comes first.
   fOverlaps->Sort();
}

//_____________________________________________________________________________
void TGeoManager::OptimizeVoxels(const char *filename)
{
// Optimize voxelization type for all volumes. Save best choice in a macro.
   if (!fTopNode) {
      Error("OptimizeVoxels","Geometry must be closed first");
      return;
   }
   std::ofstream out;
   TString fname = filename;
   if (fname.IsNull()) fname = "tgeovox.C";
   out.open(fname, std::ios::out);
   if (!out.good()) {
      Error("OptimizeVoxels", "cannot open file");
      return;
   }
   // write header
   TDatime t;
   TString sname(fname);
   sname.ReplaceAll(".C", "");
   out << sname.Data()<<"()"<<std::endl;
   out << "{" << std::endl;
   out << "//=== Macro generated by ROOT version "<< gROOT->GetVersion()<<" : "<<t.AsString()<<std::endl;
   out << "//=== Voxel optimization for " << GetTitle() << " geometry"<<std::endl;
   out << "//===== <run this macro JUST BEFORE closing the geometry>"<<std::endl;
   out << "   TGeoVolume *vol = 0;"<<std::endl;
   out << "   // parse all voxelized volumes"<<std::endl;
   TGeoVolume *vol = 0;
   Bool_t cyltype;
   TIter next(fVolumes);
   while ((vol=(TGeoVolume*)next())) {
      if (!vol->GetVoxels()) continue;
      out<<"   vol = gGeoManager->GetVolume(\""<<vol->GetName()<<"\");"<<std::endl;
      cyltype = vol->OptimizeVoxels();
      if (cyltype) {
         out<<"   vol->SetCylVoxels();"<<std::endl;
      } else {
         out<<"   vol->SetCylVoxels(kFALSE);"<<std::endl;
      }
   }
   out << "}" << std::endl;
   out.close();
}
//_____________________________________________________________________________
Int_t TGeoManager::Parse(const char *expr, TString &expr1, TString &expr2, TString &expr3)
{
// Parse a string boolean expression and do a syntax check. Find top
// level boolean operator and returns its type. Fill the two
// substrings to which this operator applies. The returned integer is :
// -1 : parse error
//  0 : no boolean operator
//  1 : union - represented as '+' in expression
//  2 : difference (subtraction) - represented as '-' in expression
//  3 : intersection - represented as '*' in expression.
// Paranthesys should be used to avoid ambiguites. For instance :
//    A+B-C will be interpreted as (A+B)-C which is not the same as A+(B-C)
   // eliminate not needed paranthesys
   TString startstr(expr);
   Int_t len = startstr.Length();
   Int_t i;
   TString e0 = "";
   expr3 = "";
   // eliminate blanks
   for (i=0; i< len; i++) {
      if (startstr(i)==' ') continue;
      e0 += startstr(i, 1);
   }
   Int_t level = 0;
   Int_t levmin = 999;
   Int_t boolop = 0;
   Int_t indop = 0;
   Int_t iloop = 1;
   Int_t lastop = 0;
   Int_t lastdp = 0;
   Int_t lastpp = 0;
   Bool_t foundmat = kFALSE;
   // check/eliminate paranthesys
   while (iloop==1) {
      iloop = 0;
      lastop = 0;
      lastdp = 0;
      lastpp = 0;
      len = e0.Length();
      for (i=0; i<len; i++) {
         if (e0(i)=='(') {
            if (!level) iloop++;
            level++;
            continue;
         }
         if  (e0(i)==')') {
            level--;
            if (level==0) lastpp=i;
            continue;
         }
         if ((e0(i)=='+') || (e0(i)=='-') || (e0(i)=='*')) {
            lastop = i;
            if (level<levmin) {
               levmin = level;
               indop = i;
            }
            continue;
         }
         if  ((e0(i)==':') && (level==0)) {
            lastdp = i;
            continue;
         }
      }
      if (level!=0) {
         if (gGeoManager) gGeoManager->Error("Parse","paranthesys does not match");
         return -1;
      }
      if (iloop==1 && (e0(0)=='(') && (e0(len-1)==')')) {
         // eliminate extra paranthesys
         e0=e0(1, len-2);
         continue;
      }
      if (foundmat) break;
      if (((lastop==0) && (lastdp>0)) || ((lastpp>0) && (lastdp>lastpp) && (indop<lastpp))) {
         expr3 = e0(lastdp+1, len-lastdp);
         e0=e0(0, lastdp);
         foundmat = kTRUE;
         iloop = 1;
         continue;
      } else break;
   }
   // loop expression and search paranthesys/operators
   levmin = 999;
   for (i=0; i<len; i++) {
      if (e0(i)=='(') {
         level++;
         continue;
      }
      if  (e0(i)==')') {
         level--;
         continue;
      }
      // Take LAST operator at lowest level (revision 28/07/08)
      if (level<=levmin) {
         if (e0(i)=='+') {
            boolop = 1; // union
            levmin = level;
            indop = i;
         }
         if (e0(i)=='-') {
            boolop = 2; // difference
            levmin = level;
            indop = i;
         }
         if (e0(i)=='*') {
            boolop = 3; // intersection
            levmin = level;
            indop = i;
         }
      }
   }
   if (indop==0) {
      expr1=e0;
      return indop;
   }
   expr1 = e0(0, indop);
   expr2 = e0(indop+1, len-indop);
   return boolop;
}


//_____________________________________________________________________________
void TGeoManager::SaveAttributes(const char *filename)
{
// Save current attributes in a macro
   if (!fTopNode) {
      Error("SaveAttributes","geometry must be closed first\n");
      return;
   }
   std::ofstream out;
   TString fname(filename);
   if (fname.IsNull()) fname = "tgeoatt.C";
   out.open(fname, std::ios::out);
   if (!out.good()) {
      Error("SaveAttributes", "cannot open file");
      return;
   }
   // write header
   TDatime t;
   TString sname(fname);
   sname.ReplaceAll(".C", "");
   out << sname.Data()<<"()"<<std::endl;
   out << "{" << std::endl;
   out << "//=== Macro generated by ROOT version "<< gROOT->GetVersion()<<" : "<<t.AsString()<<std::endl;
   out << "//=== Attributes for " << GetTitle() << " geometry"<<std::endl;
   out << "//===== <run this macro AFTER loading the geometry in memory>"<<std::endl;
   // save current top volume
   out << "   TGeoVolume *top = gGeoManager->GetVolume(\""<<fTopVolume->GetName()<<"\");"<<std::endl;
   out << "   TGeoVolume *vol = 0;"<<std::endl;
   out << "   TGeoNode *node = 0;"<<std::endl;
   out << "   // clear all volume attributes and get painter"<<std::endl;
   out << "   gGeoManager->ClearAttributes();"<<std::endl;
   out << "   gGeoManager->GetGeomPainter();"<<std::endl;
   out << "   // set visualization modes and bomb factors"<<std::endl;
   out << "   gGeoManager->SetVisOption("<<GetVisOption()<<");"<<std::endl;
   out << "   gGeoManager->SetVisLevel("<<GetVisLevel()<<");"<<std::endl;
   out << "   gGeoManager->SetExplodedView("<<GetBombMode()<<");"<<std::endl;
   Double_t bombx, bomby, bombz, bombr;
   GetBombFactors(bombx, bomby, bombz, bombr);
   out << "   gGeoManager->SetBombFactors("<<bombx<<","<<bomby<<","<<bombz<<","<<bombr<<");"<<std::endl;
   out << "   // iterate volumes coontainer and set new attributes"<<std::endl;
//   out << "   TIter next(gGeoManager->GetListOfVolumes());"<<std::endl;
   TGeoVolume *vol = 0;
   fTopNode->SaveAttributes(out);

   TIter next(fVolumes);
   while ((vol=(TGeoVolume*)next())) {
      vol->SetVisStreamed(kFALSE);
   }
   out << "   // draw top volume with new settings"<<std::endl;
   out << "   top->Draw();"<<std::endl;
   out << "   gPad->x3d();"<<std::endl;
   out << "}" << std::endl;
   out.close();
}
//_____________________________________________________________________________
TGeoNode *TGeoManager::SearchNode(Bool_t downwards, const TGeoNode *skipnode)
{
// Returns the deepest node containing fPoint, which must be set a priori.

   return GetCurrentNavigator()->SearchNode(downwards, skipnode);
}

//_____________________________________________________________________________
TGeoNode *TGeoManager::CrossBoundaryAndLocate(Bool_t downwards, TGeoNode *skipnode)
{
// Cross next boundary and locate within current node
// The current point must be on the boundary of fCurrentNode.
   return GetCurrentNavigator()->CrossBoundaryAndLocate(downwards, skipnode);
}

//_____________________________________________________________________________
TGeoNode *TGeoManager::FindNextBoundaryAndStep(Double_t stepmax, Bool_t compsafe)
{
// Compute distance to next boundary within STEPMAX. If no boundary is found,
// propagate current point along current direction with fStep=STEPMAX. Otherwise
// propagate with fStep=SNEXT (distance to boundary) and locate/return the next
// node.

   return GetCurrentNavigator()->FindNextBoundaryAndStep(stepmax, compsafe);
}

//_____________________________________________________________________________
TGeoNode *TGeoManager::FindNextBoundary(Double_t stepmax, const char *path, Bool_t frombdr)
{
// Find distance to next boundary and store it in fStep. Returns node to which this
// boundary belongs. If PATH is specified, compute only distance to the node to which
// PATH points. If STEPMAX is specified, compute distance only in case fSafety is smaller
// than this value. STEPMAX represent the step to be made imposed by other reasons than
// geometry (usually physics processes). Therefore in this case this method provides the
// answer to the question : "Is STEPMAX a safe step ?" returning a NULL node and filling
// fStep with a big number.
// In case frombdr=kTRUE, the isotropic safety is set to zero.
// Note : safety distance for the current point is computed ONLY in case STEPMAX is
//        specified, otherwise users have to call explicitly TGeoManager::Safety() if
//        they want this computed for the current point.

   // convert current point and direction to local reference
   return GetCurrentNavigator()->FindNextBoundary(stepmax,path, frombdr);
}

//_____________________________________________________________________________
TGeoNode *TGeoManager::FindNextDaughterBoundary(Double_t *point, Double_t *dir, Int_t &idaughter, Bool_t compmatrix)
{
// Computes as fStep the distance to next daughter of the current volume.
// The point and direction must be converted in the coordinate system of the current volume.
// The proposed step limit is fStep.

   return GetCurrentNavigator()->FindNextDaughterBoundary(point, dir, idaughter, compmatrix);
}

//_____________________________________________________________________________
void TGeoManager::ResetState()
{
// Reset current state flags.
   GetCurrentNavigator()->ResetState();
}

//_____________________________________________________________________________
TGeoNode *TGeoManager::FindNode(Bool_t safe_start)
{
// Returns deepest node containing current point.
   return GetCurrentNavigator()->FindNode(safe_start);
}

//_____________________________________________________________________________
TGeoNode *TGeoManager::FindNode(Double_t x, Double_t y, Double_t z)
{
// Returns deepest node containing current point.
   return GetCurrentNavigator()->FindNode(x, y, z);
}

//_____________________________________________________________________________
Double_t *TGeoManager::FindNormalFast()
{
// Computes fast normal to next crossed boundary, assuming that the current point
// is close enough to the boundary. Works only after calling FindNextBoundary.
   return GetCurrentNavigator()->FindNormalFast();
}

//_____________________________________________________________________________
Double_t *TGeoManager::FindNormal(Bool_t forward)
{
// Computes normal vector to the next surface that will be or was already
// crossed when propagating on a straight line from a given point/direction.
// Returns the normal vector cosines in the MASTER coordinate system. The dot
// product of the normal and the current direction is positive defined.
   return GetCurrentNavigator()->FindNormal(forward);
}

//_____________________________________________________________________________
Bool_t TGeoManager::IsSameLocation(Double_t x, Double_t y, Double_t z, Bool_t change)
{
// Checks if point (x,y,z) is still in the current node.
   return GetCurrentNavigator()->IsSameLocation(x,y,z,change);
}

//_____________________________________________________________________________
Bool_t TGeoManager::IsSamePoint(Double_t x, Double_t y, Double_t z) const
{
// Check if a new point with given coordinates is the same as the last located one.
   return GetCurrentNavigator()->IsSamePoint(x,y,z);
}

//_____________________________________________________________________________
Bool_t TGeoManager::IsInPhiRange() const
{
// True if current node is in phi range
   if (!fPhiCut) return kTRUE;
   const Double_t *origin;
   if (!GetCurrentNavigator() || !GetCurrentNavigator()->GetCurrentNode()) return kFALSE;
   origin = ((TGeoBBox*)GetCurrentNavigator()->GetCurrentVolume()->GetShape())->GetOrigin();
   Double_t point[3];
   LocalToMaster(origin, &point[0]);
   Double_t phi = TMath::ATan2(point[1], point[0])*TMath::RadToDeg();
   if (phi<0) phi+=360.;
   if ((phi>=fPhimin) && (phi<=fPhimax)) return kFALSE;
   return kTRUE;
}

//_____________________________________________________________________________
TGeoNode *TGeoManager::InitTrack(const Double_t *point, const Double_t *dir)
{
// Initialize current point and current direction vector (normalized)
// in MARS. Return corresponding node.
   return GetCurrentNavigator()->InitTrack(point, dir);
}

//_____________________________________________________________________________
TGeoNode *TGeoManager::InitTrack(Double_t x, Double_t y, Double_t z, Double_t nx, Double_t ny, Double_t nz)
{
// Initialize current point and current direction vector (normalized)
// in MARS. Return corresponding node.
   return GetCurrentNavigator()->InitTrack(x,y,z,nx,ny,nz);
}

//_____________________________________________________________________________
void TGeoManager::InspectState() const
{
// Inspects path and all flags for the current state.
   GetCurrentNavigator()->InspectState();
}

//_____________________________________________________________________________
const char *TGeoManager::GetPath() const
{
// Get path to the current node in the form /node0/node1/...
   return GetCurrentNavigator()->GetPath();
}

//_____________________________________________________________________________
Int_t TGeoManager::GetByteCount(Option_t * /*option*/)
{
// Get total size of geometry in bytes.
   Int_t count = 0;
   TIter next(fVolumes);
   TGeoVolume *vol;
   while ((vol=(TGeoVolume*)next())) count += vol->GetByteCount();
   TIter next1(fMatrices);
   TGeoMatrix *matrix;
   while ((matrix=(TGeoMatrix*)next1())) count += matrix->GetByteCount();
   TIter next2(fMaterials);
   TGeoMaterial *mat;
   while ((mat=(TGeoMaterial*)next2())) count += mat->GetByteCount();
   TIter next3(fMedia);
   TGeoMedium *med;
   while ((med=(TGeoMedium*)next3())) count += med->GetByteCount();
   if (fgVerboseLevel>0) Info("GetByteCount","Total size of logical tree : %i bytes", count);
   return count;
}
//_____________________________________________________________________________
TVirtualGeoPainter *TGeoManager::GetGeomPainter()
{
// Make a default painter if none present. Returns pointer to it.
   if (!fPainter) {
      TPluginHandler *h;
      if ((h = gROOT->GetPluginManager()->FindHandler("TVirtualGeoPainter"))) {
         if (h->LoadPlugin() == -1)
            return 0;
         fPainter = (TVirtualGeoPainter*)h->ExecPlugin(1,this);
         if (!fPainter) {
            Error("GetGeomPainter", "could not create painter");
            return 0;
         }
      }
   }
   return fPainter;
}
//_____________________________________________________________________________
TGeoVolume *TGeoManager::GetVolume(const char *name) const
{
// Search for a named volume. All trailing blanks stripped.
   TString sname = name;
   sname = sname.Strip();
   TGeoVolume *vol = (TGeoVolume*)fVolumes->FindObject(sname.Data());
   return vol;
}

//_____________________________________________________________________________
TGeoVolume *TGeoManager::FindVolumeFast(const char *name, Bool_t multi)
{
// Fast search for a named volume. All trailing blanks stripped.
   if (!fHashVolumes) {
      Int_t nvol = fVolumes->GetEntriesFast();
      Int_t ngvol = fGVolumes->GetEntriesFast();
      fHashVolumes = new THashList(nvol+1);
      fHashGVolumes = new THashList(ngvol+1);
      Int_t i;
      for (i=0; i<ngvol; i++) fHashGVolumes->AddLast(fGVolumes->At(i));
      for (i=0; i<nvol; i++) fHashVolumes->AddLast(fVolumes->At(i));
   }
   TString sname = name;
   sname = sname.Strip();
   THashList *list = fHashVolumes;
   if (multi) list = fHashGVolumes;
   TGeoVolume *vol = (TGeoVolume*)list->FindObject(sname.Data());
   return vol;
}

//_____________________________________________________________________________
Int_t TGeoManager::GetUID(const char *volname) const
{
// Retreive unique id for a volume name. Return -1 if name not found.
   TGeoManager *geom = (TGeoManager*)this;
   TGeoVolume *vol = geom->FindVolumeFast(volname, kFALSE);
   if (!vol) vol = geom->FindVolumeFast(volname, kTRUE);
   if (!vol) return -1;
   return vol->GetNumber();
}

//_____________________________________________________________________________
TGeoMaterial *TGeoManager::FindDuplicateMaterial(const TGeoMaterial *mat) const
{
// Find if a given material duplicates an existing one.
   Int_t index = fMaterials->IndexOf(mat);
   if (index <= 0) return 0;
   TGeoMaterial *other;
   for (Int_t i=0; i<index; i++) {
      other = (TGeoMaterial*)fMaterials->At(i);
      if (other == mat) continue;
      if (other->IsEq(mat)) return other;
   }
   return 0;
}

//_____________________________________________________________________________
TGeoMaterial *TGeoManager::GetMaterial(const char *matname) const
{
// Search for a named material. All trailing blanks stripped.
   TString sname = matname;
   sname = sname.Strip();
   TGeoMaterial *mat = (TGeoMaterial*)fMaterials->FindObject(sname.Data());
   return mat;
}

//_____________________________________________________________________________
TGeoMedium *TGeoManager::GetMedium(const char *medium) const
{
// Search for a named tracking medium. All trailing blanks stripped.
   TString sname = medium;
   sname = sname.Strip();
   TGeoMedium *med = (TGeoMedium*)fMedia->FindObject(sname.Data());
   return med;
}

//_____________________________________________________________________________
TGeoMedium *TGeoManager::GetMedium(Int_t numed) const
{
// Search for a tracking medium with a given ID.
   TIter next(fMedia);
   TGeoMedium *med;
   while ((med=(TGeoMedium*)next())) {
      if (med->GetId()==numed) return med;
   }
   return 0;
}

//_____________________________________________________________________________
TGeoMaterial *TGeoManager::GetMaterial(Int_t id) const
{
// Return material at position id.
   if (id<0 || id >= fMaterials->GetSize()) return 0;
   TGeoMaterial *mat = (TGeoMaterial*)fMaterials->At(id);
   return mat;
}
//_____________________________________________________________________________
Int_t TGeoManager::GetMaterialIndex(const char *matname) const
{
// Return index of named material.
   TIter next(fMaterials);
   TGeoMaterial *mat;
   Int_t id = 0;
   TString sname = matname;
   sname = sname.Strip();
   while ((mat = (TGeoMaterial*)next())) {
      if (!strcmp(mat->GetName(),sname.Data()))
         return id;
      id++;
   }
   return -1;  // fail
}
//_____________________________________________________________________________
void TGeoManager::RandomRays(Int_t nrays, Double_t startx, Double_t starty, Double_t startz, const char *target_vol, Bool_t check_norm)
{
// Randomly shoot nrays and plot intersections with surfaces for current
// top node.
   GetGeomPainter()->RandomRays(nrays, startx, starty, startz, target_vol, check_norm);
}

//_____________________________________________________________________________
void TGeoManager::RemoveMaterial(Int_t index)
{
// Remove material at given index.
   TObject *obj = fMaterials->At(index);
   if (obj) fMaterials->Remove(obj);
}

//_____________________________________________________________________________
void TGeoManager::ResetUserData()
{
// Sets all pointers TGeoVolume::fField to NULL. User data becomes decoupled
// from geometry. Deletion has to be managed by users.
   TIter next(fVolumes);
   TGeoVolume *vol;
   while ((vol=(TGeoVolume*)next())) vol->SetField(0);
}

//_____________________________________________________________________________
void TGeoManager::RestoreMasterVolume()
{
// Restore the master volume of the geometry.
   if (fTopVolume == fMasterVolume) return;
   if (fMasterVolume) SetTopVolume(fMasterVolume);
}
//_____________________________________________________________________________
void TGeoManager::Voxelize(Option_t *option)
{
// Voxelize all non-divided volumes.
   TGeoVolume *vol;
//   TGeoVoxelFinder *vox = 0;
   if (!fStreamVoxels && fgVerboseLevel>0) Info("Voxelize","Voxelizing...");
//   Int_t nentries = fVolumes->GetSize();
   TIter next(fVolumes);
   while ((vol = (TGeoVolume*)next())) {
      if (!fIsGeomReading) vol->SortNodes();
      if (!fStreamVoxels) {
         vol->Voxelize(option);
      }
      if (!fIsGeomReading) vol->FindOverlaps();
   }
}
//_____________________________________________________________________________
void TGeoManager::ModifiedPad() const
{
// Send "Modified" signal to painter.
   if (!fPainter) return;
   fPainter->ModifiedPad();
}
//_____________________________________________________________________________
TGeoVolume *TGeoManager::MakeArb8(const char *name, TGeoMedium *medium,
                                  Double_t dz, Double_t *vertices)
{
// Make an TGeoArb8 volume.
   return TGeoBuilder::Instance(this)->MakeArb8(name, medium, dz, vertices);
}

//_____________________________________________________________________________
TGeoVolume *TGeoManager::MakeBox(const char *name, TGeoMedium *medium,
                                    Double_t dx, Double_t dy, Double_t dz)
{
// Make in one step a volume pointing to a box shape with given medium.
   return TGeoBuilder::Instance(this)->MakeBox(name, medium, dx, dy, dz);
}

//_____________________________________________________________________________
TGeoVolume *TGeoManager::MakePara(const char *name, TGeoMedium *medium,
                                    Double_t dx, Double_t dy, Double_t dz,
                                    Double_t alpha, Double_t theta, Double_t phi)
{
// Make in one step a volume pointing to a paralelipiped shape with given medium.
   return TGeoBuilder::Instance(this)->MakePara(name, medium, dx, dy, dz, alpha, theta, phi);
}

//_____________________________________________________________________________
TGeoVolume *TGeoManager::MakeSphere(const char *name, TGeoMedium *medium,
                                    Double_t rmin, Double_t rmax, Double_t themin, Double_t themax,
                                    Double_t phimin, Double_t phimax)
{
// Make in one step a volume pointing to a sphere shape with given medium
   return TGeoBuilder::Instance(this)->MakeSphere(name, medium, rmin, rmax, themin, themax, phimin, phimax);
}

//_____________________________________________________________________________
TGeoVolume *TGeoManager::MakeTorus(const char *name, TGeoMedium *medium, Double_t r,
                                   Double_t rmin, Double_t rmax, Double_t phi1, Double_t dphi)
{
// Make in one step a volume pointing to a torus shape with given medium.
   return TGeoBuilder::Instance(this)->MakeTorus(name, medium, r, rmin, rmax, phi1, dphi);
}

//_____________________________________________________________________________
TGeoVolume *TGeoManager::MakeTube(const char *name, TGeoMedium *medium,
                                     Double_t rmin, Double_t rmax, Double_t dz)
{
// Make in one step a volume pointing to a tube shape with given medium.
   return TGeoBuilder::Instance(this)->MakeTube(name, medium, rmin, rmax, dz);
}

//_____________________________________________________________________________
TGeoVolume *TGeoManager::MakeTubs(const char *name, TGeoMedium *medium,
                                     Double_t rmin, Double_t rmax, Double_t dz,
                                     Double_t phiStart, Double_t phiEnd)
{
   // Make in one step a volume pointing to a tube segment shape with given medium.
   // The segment will be from phiStart to phiEnd, the angles are expressed in degree
   return TGeoBuilder::Instance(this)->MakeTubs(name, medium, rmin, rmax, dz, phiStart, phiEnd);
}

//_____________________________________________________________________________
TGeoVolume *TGeoManager::MakeEltu(const char *name, TGeoMedium *medium,
                                     Double_t a, Double_t b, Double_t dz)
{
// Make in one step a volume pointing to a tube shape with given medium
   return TGeoBuilder::Instance(this)->MakeEltu(name, medium, a, b, dz);
}

//_____________________________________________________________________________
TGeoVolume *TGeoManager::MakeHype(const char *name, TGeoMedium *medium,
                                        Double_t rin, Double_t stin, Double_t rout, Double_t stout, Double_t dz)
{
// Make in one step a volume pointing to a tube shape with given medium
   return TGeoBuilder::Instance(this)->MakeHype(name, medium, rin, stin, rout, stout, dz);
}

//_____________________________________________________________________________
TGeoVolume *TGeoManager::MakeParaboloid(const char *name, TGeoMedium *medium,
                                        Double_t rlo, Double_t rhi, Double_t dz)
{
// Make in one step a volume pointing to a tube shape with given medium
   return TGeoBuilder::Instance(this)->MakeParaboloid(name, medium, rlo, rhi, dz);
}

//_____________________________________________________________________________
TGeoVolume *TGeoManager::MakeCtub(const char *name, TGeoMedium *medium,
                                     Double_t rmin, Double_t rmax, Double_t dz, Double_t phi1, Double_t phi2,
                                     Double_t lx, Double_t ly, Double_t lz, Double_t tx, Double_t ty, Double_t tz)
{
// Make in one step a volume pointing to a tube segment shape with given medium
   return TGeoBuilder::Instance(this)->MakeCtub(name, medium, rmin, rmax, dz, phi1, phi2, lx, ly, lz, tx, ty, tz);
}

//_____________________________________________________________________________
TGeoVolume *TGeoManager::MakeCone(const char *name, TGeoMedium *medium,
                                     Double_t dz, Double_t rmin1, Double_t rmax1,
                                     Double_t rmin2, Double_t rmax2)
{
// Make in one step a volume pointing to a cone shape with given medium.
   return TGeoBuilder::Instance(this)->MakeCone(name, medium, dz, rmin1, rmax1, rmin2, rmax2);
}

//_____________________________________________________________________________
TGeoVolume *TGeoManager::MakeCons(const char *name, TGeoMedium *medium,
                                     Double_t dz, Double_t rmin1, Double_t rmax1,
                                     Double_t rmin2, Double_t rmax2,
                                     Double_t phi1, Double_t phi2)
{
// Make in one step a volume pointing to a cone segment shape with given medium
   return TGeoBuilder::Instance(this)->MakeCons(name, medium, dz, rmin1, rmax1, rmin2, rmax2, phi1, phi2);
}

//_____________________________________________________________________________
TGeoVolume *TGeoManager::MakePcon(const char *name, TGeoMedium *medium,
                                     Double_t phi, Double_t dphi, Int_t nz)
{
// Make in one step a volume pointing to a polycone shape with given medium.
   return TGeoBuilder::Instance(this)->MakePcon(name, medium, phi, dphi, nz);
}

//_____________________________________________________________________________
TGeoVolume *TGeoManager::MakePgon(const char *name, TGeoMedium *medium,
                                     Double_t phi, Double_t dphi, Int_t nedges, Int_t nz)
{
// Make in one step a volume pointing to a polygone shape with given medium.
   return TGeoBuilder::Instance(this)->MakePgon(name, medium, phi, dphi, nedges, nz);
}

//_____________________________________________________________________________
TGeoVolume *TGeoManager::MakeTrd1(const char *name, TGeoMedium *medium,
                                  Double_t dx1, Double_t dx2, Double_t dy, Double_t dz)
{
// Make in one step a volume pointing to a TGeoTrd1 shape with given medium.
   return TGeoBuilder::Instance(this)->MakeTrd1(name, medium, dx1, dx2, dy, dz);
}

//_____________________________________________________________________________
TGeoVolume *TGeoManager::MakeTrd2(const char *name, TGeoMedium *medium,
                                  Double_t dx1, Double_t dx2, Double_t dy1, Double_t dy2,
                                  Double_t dz)
{
// Make in one step a volume pointing to a TGeoTrd2 shape with given medium.
   return TGeoBuilder::Instance(this)->MakeTrd2(name, medium, dx1, dx2, dy1, dy2, dz);
}

//_____________________________________________________________________________
TGeoVolume *TGeoManager::MakeTrap(const char *name, TGeoMedium *medium,
                                  Double_t dz, Double_t theta, Double_t phi, Double_t h1,
                                  Double_t bl1, Double_t tl1, Double_t alpha1, Double_t h2, Double_t bl2,
                                  Double_t tl2, Double_t alpha2)
{
// Make in one step a volume pointing to a trapezoid shape with given medium.
   return TGeoBuilder::Instance(this)->MakeTrap(name, medium, dz, theta, phi, h1, bl1, tl1, alpha1, h2, bl2, tl2, alpha2);
}

//_____________________________________________________________________________
TGeoVolume *TGeoManager::MakeGtra(const char *name, TGeoMedium *medium,
                                  Double_t dz, Double_t theta, Double_t phi, Double_t twist, Double_t h1,
                                  Double_t bl1, Double_t tl1, Double_t alpha1, Double_t h2, Double_t bl2,
                                  Double_t tl2, Double_t alpha2)
{
// Make in one step a volume pointing to a twisted trapezoid shape with given medium.
   return TGeoBuilder::Instance(this)->MakeGtra(name, medium, dz, theta, phi, twist, h1, bl1, tl1, alpha1, h2, bl2, tl2, alpha2);
}

//_____________________________________________________________________________
TGeoVolume *TGeoManager::MakeXtru(const char *name, TGeoMedium *medium, Int_t nz)
{
// Make a TGeoXtru-shaped volume with nz planes
   return TGeoBuilder::Instance(this)->MakeXtru(name, medium, nz);
}

//_____________________________________________________________________________
TGeoPNEntry *TGeoManager::SetAlignableEntry(const char *unique_name, const char *path,
                                            Int_t uid)
{
// Creates an aligneable object with unique name corresponding to a path
// and adds it to the list of alignables. An optional unique ID can be
// provided, in which case PN entries can be searched fast by uid.
   if (!CheckPath(path)) return NULL;
   if (!fHashPNE) fHashPNE = new THashList(256,3);
   if (!fArrayPNE) fArrayPNE = new TObjArray(256);
   TGeoPNEntry *entry = GetAlignableEntry(unique_name);
   if (entry) {
      Error("SetAlignableEntry", "An alignable object with name %s already existing. NOT ADDED !", unique_name);
      return 0;
   }
   entry = new TGeoPNEntry(unique_name, path);
   Int_t ientry = fHashPNE->GetSize();
   fHashPNE->Add(entry);
   fArrayPNE->AddAtAndExpand(entry, ientry);
   if (uid>=0) {
      Bool_t added = InsertPNEId(uid, ientry);
      if (!added) Error("SetAlignableEntry", "A PN entry: has already uid=%i", uid);
   }
   return entry;
}

//_____________________________________________________________________________
TGeoPNEntry *TGeoManager::GetAlignableEntry(const char *name) const
{
// Retreives an existing alignable object.
   if (!fHashPNE) return 0;
   return (TGeoPNEntry*)fHashPNE->FindObject(name);
}

//_____________________________________________________________________________
TGeoPNEntry *TGeoManager::GetAlignableEntry(Int_t index) const
{
// Retreives an existing alignable object at a given index.
   if (!fArrayPNE && !InitArrayPNE()) return 0;
   return (TGeoPNEntry*)fArrayPNE->At(index);
}

//_____________________________________________________________________________
TGeoPNEntry *TGeoManager::GetAlignableEntryByUID(Int_t uid) const
{
// Retreives an existing alignable object having a preset UID.
   if (!fNPNEId || (!fArrayPNE && !InitArrayPNE())) return NULL;
   Int_t index = TMath::BinarySearch(fNPNEId, fKeyPNEId, uid);
   if (index<0 || fKeyPNEId[index]!=uid) return NULL;
   return (TGeoPNEntry*)fArrayPNE->At(fValuePNEId[index]);
}

//_____________________________________________________________________________
Int_t TGeoManager::GetNAlignable(Bool_t with_uid) const
{
// Retreives number of PN entries with or without UID.
   if (!fHashPNE) return 0;
   if (with_uid) return fNPNEId;
   return fHashPNE->GetSize();
}

//_____________________________________________________________________________
Bool_t TGeoManager::InsertPNEId(Int_t uid, Int_t ientry)
{
// Insert a PN entry in the sorted array of indexes.
   if (!fSizePNEId) {
      // Create the arrays.
      fSizePNEId = 128;
      fKeyPNEId = new Int_t[fSizePNEId];
      memset(fKeyPNEId, 0, fSizePNEId*sizeof(Int_t));
      fValuePNEId = new Int_t[fSizePNEId];
      memset(fValuePNEId, 0, fSizePNEId*sizeof(Int_t));
      fKeyPNEId[fNPNEId] = uid;
      fValuePNEId[fNPNEId++] = ientry;
      return kTRUE;
   }
   // Search id in the existing array and return false if it already exists.
   Int_t index = TMath::BinarySearch(fNPNEId, fKeyPNEId, uid);
   if (index>0 && fKeyPNEId[index]==uid) return kFALSE;
   // Resize the arrays and insert the value
   Bool_t resize = (fNPNEId==fSizePNEId)?kTRUE:kFALSE;
   if (resize) {
      // Double the size of the array
      fSizePNEId *= 2;
      // Create new arrays of keys and values
      Int_t *keys = new Int_t[fSizePNEId];
      memset(keys, 0, fSizePNEId*sizeof(Int_t));
      Int_t *values = new Int_t[fSizePNEId];
      memset(values, 0, fSizePNEId*sizeof(Int_t));
      // Copy all keys<uid in the new keys array (0 to index)
      memcpy(keys,   fKeyPNEId,   (index+1)*sizeof(Int_t));
      memcpy(values, fValuePNEId, (index+1)*sizeof(Int_t));
      // Insert current key at index+1
      keys[index+1]   = uid;
      values[index+1] = ientry;
      // Copy all remaining keys from the old to new array
      memcpy(&keys[index+2],   &fKeyPNEId[index+1],   (fNPNEId-index-1)*sizeof(Int_t));
      memcpy(&values[index+2], &fValuePNEId[index+1], (fNPNEId-index-1)*sizeof(Int_t));
      delete [] fKeyPNEId;
      fKeyPNEId = keys;
      delete [] fValuePNEId;
      fValuePNEId = values;
      fNPNEId++;
      return kTRUE;
   }
   // Insert the value in the existing arrays
   Int_t i;
   for (i=fNPNEId-1; i>index; i--) {
      fKeyPNEId[i+1] = fKeyPNEId[i];
      fValuePNEId[i+1] = fValuePNEId[i];
   }
   fKeyPNEId[index+1] = uid;
   fValuePNEId[index+1] = ientry;
   fNPNEId++;
   return kTRUE;
}

//_____________________________________________________________________________
TGeoPhysicalNode *TGeoManager::MakeAlignablePN(const char *name)
{
// Make a physical node from the path pointed by an alignable object with a given name.
   TGeoPNEntry *entry = GetAlignableEntry(name);
   if (!entry) {
      Error("MakeAlignablePN","No alignable object named %s found !", name);
      return 0;
   }
   return MakeAlignablePN(entry);
}

//_____________________________________________________________________________
TGeoPhysicalNode *TGeoManager::MakeAlignablePN(TGeoPNEntry *entry)
{
// Make a physical node from the path pointed by a given alignable object.
   if (!entry) {
      Error("MakeAlignablePN","No alignable object specified !");
      return 0;
   }
   const char *path = entry->GetTitle();
   if (!cd(path)) {
      Error("MakeAlignablePN", "Alignable object %s poins to invalid path: %s",
            entry->GetName(), path);
      return 0;
   }
   TGeoPhysicalNode *node = MakePhysicalNode(path);
   entry->SetPhysicalNode(node);
   return node;
}

//_____________________________________________________________________________
TGeoPhysicalNode *TGeoManager::MakePhysicalNode(const char *path)
{
// Makes a physical node corresponding to a path. If PATH is not specified,
// makes physical node matching current modeller state.
   TGeoPhysicalNode *node;
   if (path) {
      if (!CheckPath(path)) {
         Error("MakePhysicalNode", "path: %s not valid", path);
         return NULL;
      }
      node = new TGeoPhysicalNode(path);
   } else {
      node = new TGeoPhysicalNode(GetPath());
   }
   fPhysicalNodes->Add(node);
   return node;
}

//_____________________________________________________________________________
void TGeoManager::RefreshPhysicalNodes(Bool_t lock)
{
// Refresh physical nodes to reflect the actual geometry paths after alignment
// was applied. Optionally locks physical nodes (default).
   TIter next(gGeoManager->GetListOfPhysicalNodes());
   TGeoPhysicalNode *pn;
   while ((pn=(TGeoPhysicalNode*)next())) pn->Refresh();
   if (fParallelWorld && fParallelWorld->IsClosed()) fParallelWorld->RefreshPhysicalNodes();
   if (lock) LockGeometry();
}

//_____________________________________________________________________________
void TGeoManager::ClearPhysicalNodes(Bool_t mustdelete)
{
// Clear the current list of physical nodes, so that we can start over with a new list.
// If MUSTDELETE is true, delete previous nodes.
   if (mustdelete) fPhysicalNodes->Delete();
   else fPhysicalNodes->Clear();
}

//_____________________________________________________________________________
TGeoVolumeAssembly *TGeoManager::MakeVolumeAssembly(const char *name)
{
// Make an assembly of volumes.
   return TGeoBuilder::Instance(this)->MakeVolumeAssembly(name);
}

//_____________________________________________________________________________
TGeoVolumeMulti *TGeoManager::MakeVolumeMulti(const char *name, TGeoMedium *medium)
{
// Make a TGeoVolumeMulti handling a list of volumes.
   return TGeoBuilder::Instance(this)->MakeVolumeMulti(name, medium);
}

//_____________________________________________________________________________
void TGeoManager::SetExplodedView(Int_t ibomb)
{
// Set type of exploding view (see TGeoPainter::SetExplodedView())
   if ((ibomb>=0) && (ibomb<4)) fExplodedView = ibomb;
   if (fPainter) fPainter->SetExplodedView(ibomb);
}

//_____________________________________________________________________________
void TGeoManager::SetPhiRange(Double_t phimin, Double_t phimax)
{
// Set cut phi range
   if ((phimin==0) && (phimax==360)) {
      fPhiCut = kFALSE;
      return;
   }
   fPhiCut = kTRUE;
   fPhimin = phimin;
   fPhimax = phimax;
}

//_____________________________________________________________________________
void TGeoManager::SetNsegments(Int_t nseg)
{
// Set number of segments for approximating circles in drawing.
   if (fNsegments==nseg) return;
   if (nseg>2) fNsegments = nseg;
   if (fPainter) fPainter->SetNsegments(nseg);
}

//_____________________________________________________________________________
Int_t TGeoManager::GetNsegments() const
{
// Get number of segments approximating circles
   return fNsegments;
}

//_____________________________________________________________________________
void TGeoManager::BuildDefaultMaterials()
{
// Now just a shortcut for GetElementTable.
   GetElementTable();
   TGeoVolume::CreateDummyMedium();
}

//_____________________________________________________________________________
TGeoElementTable *TGeoManager::GetElementTable()
{
// Returns material table. Creates it if not existing.
   if (!fElementTable) fElementTable = new TGeoElementTable(200);
   return fElementTable;
}

//_____________________________________________________________________________
TGeoNode *TGeoManager::Step(Bool_t is_geom, Bool_t cross)
{
// Make a rectiliniar step of length fStep from current point (fPoint) on current
// direction (fDirection). If the step is imposed by geometry, is_geom flag
// must be true (default). The cross flag specifies if the boundary should be
// crossed in case of a geometry step (default true). Returns new node after step.
// Set also on boundary condition.
   return GetCurrentNavigator()->Step(is_geom, cross);
}

//_____________________________________________________________________________
TGeoNode *TGeoManager::SamplePoints(Int_t npoints, Double_t &dist, Double_t epsil,
                                    const char* g3path)
{
// shoot npoints randomly in a box of 1E-5 arround current point.
// return minimum distance to points outside
   return GetGeomPainter()->SamplePoints(npoints, dist, epsil, g3path);
}

//_____________________________________________________________________________
void TGeoManager::SetTopVolume(TGeoVolume *vol)
{
// Set the top volume and corresponding node as starting point of the geometry.
   if (fTopVolume==vol) return;

   TSeqCollection *brlist = gROOT->GetListOfBrowsers();
   TIter next(brlist);
   TBrowser *browser = 0;

   if (fTopVolume) fTopVolume->SetTitle("");
   fTopVolume = vol;
   vol->SetTitle("Top volume");
   if (fTopNode) {
      TGeoNode *topn = fTopNode;
      fTopNode = 0;
      while ((browser=(TBrowser*)next())) browser->RecursiveRemove(topn);
      delete topn;
   } else {
      fMasterVolume = vol;
      fMasterVolume->Grab();
      fUniqueVolumes->AddAtAndExpand(vol,0);
      if (fgVerboseLevel>0) Info("SetTopVolume","Top volume is %s. Master volume is %s", fTopVolume->GetName(),
           fMasterVolume->GetName());
   }
//   fMasterVolume->FindMatrixOfDaughterVolume(vol);
//   fCurrentMatrix->Print();
   fTopNode = new TGeoNodeMatrix(vol, gGeoIdentity);
   fTopNode->SetName(TString::Format("%s_1",vol->GetName()));
   fTopNode->SetNumber(1);
   fTopNode->SetTitle("Top logical node");
   fNodes->AddAt(fTopNode, 0);
   if (!GetCurrentNavigator()) {
      fCurrentNavigator = AddNavigator();
      return;
   }
   Int_t nnavigators = 0;
   TGeoNavigatorArray *arr = GetListOfNavigators();
   if (!arr) return;
   nnavigators = arr->GetEntriesFast();
   for (Int_t i=0; i<nnavigators; i++) {
      TGeoNavigator *nav = (TGeoNavigator*)arr->At(i);
      nav->ResetAll();
      if (fClosed) nav->GetCache()->BuildInfoBranch();
   }
}
//_____________________________________________________________________________
void TGeoManager::SelectTrackingMedia()
{
// Define different tracking media.
//   printf("List of materials :\n");
/*
   Int_t nmat = fMaterials->GetSize();
   if (!nmat) {printf(" No materials !\n"); return;}
   Int_t *media = new Int_t[nmat];
   memset(media, 0, nmat*sizeof(Int_t));
   Int_t imedia = 1;
   TGeoMaterial *mat, *matref;
   mat = (TGeoMaterial*)fMaterials->At(0);
   if (mat->GetMedia()) {
      for (Int_t i=0; i<nmat; i++) {
         mat = (TGeoMaterial*)fMaterials->At(i);
         mat->Print();
      }
      return;
   }
   mat->SetMedia(imedia);
   media[0] = imedia++;
   mat->Print();
   for (Int_t i=0; i<nmat; i++) {
      mat = (TGeoMaterial*)fMaterials->At(i);
      for (Int_t j=0; j<i; j++) {
         matref = (TGeoMaterial*)fMaterials->At(j);
         if (mat->IsEq(matref)) {
            mat->SetMedia(media[j]);
            break;
         }
         if (j==(i-1)) {
         // different material
            mat->SetMedia(imedia);
            media[i] = imedia++;
            mat->Print();
         }
      }
   }
*/
}

//_____________________________________________________________________________
void TGeoManager::CheckBoundaryErrors(Int_t ntracks, Double_t radius)
{
// Check pushes and pulls needed to cross the next boundary with respect to the
// position given by FindNextBoundary. If radius is not mentioned the full bounding
// box will be sampled.
   GetGeomPainter()->CheckBoundaryErrors(ntracks, radius);
}

//_____________________________________________________________________________
void TGeoManager::CheckBoundaryReference(Int_t icheck)
{
// Check the boundary errors reference file created by CheckBoundaryErrors method.
// The shape for which the crossing failed is drawn with the starting point in red
// and the extrapolated point to boundary (+/- failing push/pull) in yellow.
   GetGeomPainter()->CheckBoundaryReference(icheck);
}

//_____________________________________________________________________________
void TGeoManager::CheckPoint(Double_t x, Double_t y, Double_t z, Option_t *option)
{
// Classify a given point. See TGeoChecker::CheckPoint().
   GetGeomPainter()->CheckPoint(x,y,z,option);
}

//_____________________________________________________________________________
void TGeoManager::CheckShape(TGeoShape *shape, Int_t testNo, Int_t nsamples, Option_t *option)
{
// Test for shape navigation methods. Summary for test numbers:
//  1: DistFromInside/Outside. Sample points inside the shape. Generate
//    directions randomly in cos(theta). Compute DistFromInside and move the
//    point with bigger distance. Compute DistFromOutside back from new point.
//    Plot d-(d1+d2)
//
   GetGeomPainter()->CheckShape(shape, testNo, nsamples, option);
}

//_____________________________________________________________________________
void TGeoManager::CheckGeometryFull(Int_t ntracks, Double_t vx, Double_t vy, Double_t vz, Option_t *option)
{
// Geometry checking.
// - if option contains 'o': Optional overlap checkings (by sampling and by mesh).
// - if option contains 'b': Optional boundary crossing check + timing per volume.
//
// STAGE 1: extensive overlap checking by sampling per volume. Stdout need to be
//  checked by user to get report, then TGeoVolume::CheckOverlaps(0.01, "s") can
//  be called for the suspicious volumes.
// STAGE2 : normal overlap checking using the shapes mesh - fills the list of
//  overlaps.
// STAGE3 : shooting NRAYS rays from VERTEX and counting the total number of
//  crossings per volume (rays propagated from boundary to boundary until
//  geometry exit). Timing computed and results stored in a histo.
// STAGE4 : shooting 1 mil. random rays inside EACH volume and calling
//  FindNextBoundary() + Safety() for each call. The timing is normalized by the
//  number of crossings computed at stage 2 and presented as percentage.
//  One can get a picture on which are the most "burned" volumes during
//  transportation from geometry point of view. Another plot of the timing per
//  volume vs. number of daughters is produced.
   TString opt(option);
   opt.ToLower();
   if (!opt.Length()) {
      Error("CheckGeometryFull","The option string must contain a letter. See method documentation.");
      return;
   }
   Bool_t checkoverlaps  = opt.Contains("o");
   Bool_t checkcrossings = opt.Contains("b");
   Double_t vertex[3];
   vertex[0] = vx;
   vertex[1] = vy;
   vertex[2] = vz;
   GetGeomPainter()->CheckGeometryFull(checkoverlaps,checkcrossings,ntracks,vertex);
}

//_____________________________________________________________________________
void TGeoManager::CheckGeometry(Option_t * /*option*/)
{
   // Perform last checks on the geometry
   if (fgVerboseLevel>0) Info("CheckGeometry","Fixing runtime shapes...");
   TIter next(fShapes);
   TIter nextv(fVolumes);
   TGeoShape *shape;
   TGeoVolume *vol;
   Bool_t has_runtime = kFALSE;
   while ((shape = (TGeoShape*)next())) {
      if (shape->IsRunTimeShape()) {
         has_runtime = kTRUE;
      }
      if (fIsGeomReading) shape->AfterStreamer();
      if (shape->TestShapeBit(TGeoShape::kGeoPcon) || shape->TestShapeBit(TGeoShape::kGeoArb8))
         if (!shape->TestShapeBit(TGeoShape::kGeoClosedShape)) shape->ComputeBBox();
   }
   if (has_runtime) fTopNode->CheckShapes();
   else if (fgVerboseLevel>0) Info("CheckGeometry","...Nothing to fix");
   // Compute bounding  box for assemblies
   TGeoMedium *dummy = TGeoVolume::DummyMedium();
   while ((vol = (TGeoVolume*)nextv())) {
      if (vol->IsAssembly()) vol->GetShape()->ComputeBBox();
      else if (vol->GetMedium() == dummy) {
         Warning("CheckGeometry", "Volume \"%s\" has no medium: assigned dummy medium and material", vol->GetName());
         vol->SetMedium(dummy);
      }
   }
}

//_____________________________________________________________________________
void TGeoManager::CheckOverlaps(Double_t ovlp, Option_t * option)
{
// Check all geometry for illegal overlaps within a limit OVLP.
   if (!fTopNode) {
      Error("CheckOverlaps","Top node not set");
      return;
   }
   fTopNode->CheckOverlaps(ovlp,option);
}

//_____________________________________________________________________________
void TGeoManager::PrintOverlaps() const
{
// Prints the current list of overlaps.
   if (!fOverlaps) return;
   Int_t novlp = fOverlaps->GetEntriesFast();
   if (!novlp) return;
   TGeoManager *geom = (TGeoManager*)this;
   geom->GetGeomPainter()->PrintOverlaps();
}

//_____________________________________________________________________________
Double_t TGeoManager::Weight(Double_t precision, Option_t *option)
{
// Estimate weight of volume VOL with a precision SIGMA(W)/W better than PRECISION.
// Option can be "v" - verbose (default)
   GetGeomPainter();
   TString opt(option);
   opt.ToLower();
   Double_t weight;
   TGeoVolume *volume = fTopVolume;
   if (opt.Contains("v")) {
      if (opt.Contains("a")) {
         if (fgVerboseLevel>0) Info("Weight", "Computing analytically weight of %s", volume->GetName());
         weight = volume->WeightA();
         if (fgVerboseLevel>0) Info("Weight", "Computed weight: %f [kg]\n", weight);
         return weight;
      }
      if (fgVerboseLevel>0) {
         Info("Weight", "Estimating weight of %s with %g %% precision", fTopVolume->GetName(), 100.*precision);
         printf("    event         weight         err\n");
         printf("========================================\n");
      }
   }
   weight = fPainter->Weight(precision, option);
   return weight;
}

//_____________________________________________________________________________
ULong_t TGeoManager::SizeOf(const TGeoNode * /*node*/, Option_t * /*option*/)
{
// computes the total size in bytes of the branch starting with node.
// The option can specify if all the branch has to be parsed or only the node
   return 0;
}

//______________________________________________________________________________
void TGeoManager::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGeoManager.
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TGeoManager::Class(), this);
      fIsGeomReading = kTRUE;
      CloseGeometry();
      fStreamVoxels = kFALSE;
      fIsGeomReading = kFALSE;
   } else {
      R__b.WriteClassBuffer(TGeoManager::Class(), this);
   }
}

//_____________________________________________________________________________
void TGeoManager::ExecuteEvent(Int_t event, Int_t px, Int_t py)
{
// Execute mouse actions on this manager.
   if (!fPainter) return;
   fPainter->ExecuteManagerEvent(this, event, px, py);
}

//______________________________________________________________________________
Int_t TGeoManager::Export(const char *filename, const char *name, Option_t *option)
{
   // Export this geometry to a file
   //
   // -Case 1: root file or root/xml file
   //  if filename end with ".root". The key will be named name
   //  By default the geometry is saved without the voxelisation info.
   //  Use option 'v" to save the voxelisation info.
   //  if filename end with ".xml" a root/xml file is produced.
   //
   // -Case 2: C++ script
   //  if filename end with ".C"
   //
   // -Case 3: gdml file
   //  if filename end with ".gdml"
   //  NOTE that to use this option, the PYTHONPATH must be defined like
   //      export PYTHONPATH=$ROOTSYS/lib:$ROOTSYS/geom/gdml
   //

   TString sfile(filename);
   if (sfile.Contains(".C")) {
      //Save geometry as a C++ script
      if (fgVerboseLevel>0) Info("Export","Exporting %s %s as C++ code", GetName(), GetTitle());
      fTopVolume->SaveAs(filename);
      return 1;
   }
   if (sfile.Contains(".gdml")) {
      //Save geometry as a gdml file
      if (fgVerboseLevel>0) Info("Export","Exporting %s %s as gdml code", GetName(), GetTitle());
      //C++ version
      TString cmd ;
      cmd = TString::Format("TGDMLWrite::StartGDMLWriting(gGeoManager,\"%s\",\"%s\")", filename, option);
      gROOT->ProcessLineFast(cmd);
      return 1;
   }
   if (sfile.Contains(".root") || sfile.Contains(".xml")) {
      //Save geometry as a root file
      TFile *f = TFile::Open(filename,"recreate");
      if (!f || f->IsZombie()) {
         Error("Export","Cannot open file");
         return 0;
      }
      TString keyname = name;
      if (keyname.IsNull()) keyname = GetName();
      TString opt = option;
      opt.ToLower();
      if (opt.Contains("v")) {
         fStreamVoxels = kTRUE;
         if (fgVerboseLevel>0) Info("Export","Exporting %s %s as root file. Optimizations streamed.", GetName(), GetTitle());
      } else {
         fStreamVoxels = kFALSE;
         if (fgVerboseLevel>0) Info("Export","Exporting %s %s as root file. Optimizations not streamed.", GetName(), GetTitle());
      }
      Int_t nbytes = Write(keyname);
      fStreamVoxels = kFALSE;
      delete f;
      return nbytes;
   }
   return 0;
}
//______________________________________________________________________________
void TGeoManager::LockGeometry()
{
// Lock current geometry so that no other geometry can be imported.
   fgLock = kTRUE;
}

//______________________________________________________________________________
void TGeoManager::UnlockGeometry()
{
// Unlock current geometry.
   fgLock = kFALSE;
}

//______________________________________________________________________________
Bool_t TGeoManager::IsLocked()
{
// Check lock state.
   return fgLock;
}

//______________________________________________________________________________
Int_t TGeoManager::GetVerboseLevel()
{
// Set verbosity level (static function).
// 0 - suppress messages related to geom-painter visibility level
// 1 - default value
   return fgVerboseLevel;
}

//______________________________________________________________________________
void TGeoManager::SetVerboseLevel(Int_t vl)
{
// Return current verbosity level (static function).
   fgVerboseLevel = vl;
}

//______________________________________________________________________________
TGeoManager *TGeoManager::Import(const char *filename, const char *name, Option_t * /*option*/)
{
   //static function
   //Import a geometry from a gdml or ROOT file
   //
   // -Case 1: gdml
   //  if filename ends with ".gdml" the foreign geometry described with gdml
   //  is imported executing some python scripts in $ROOTSYS/gdml.
   //  NOTE that to use this option, the PYTHONPATH must be defined like
   //      export PYTHONPATH=$ROOTSYS/lib:$ROOTSYS/gdml
   //
   // -Case 2: root file (.root) or root/xml file (.xml)
   //  Import in memory from filename the geometry with key=name.
   //  if name="" (default), the first TGeoManager object in the file is returned.
   //
   //Note that this function deletes the current gGeoManager (if one)
   //before importing the new object.

   if (fgLock) {
      ::Warning("TGeoManager::Import", "TGeoMananager in lock mode. NOT IMPORTING new geometry");
      return NULL;
   }
   if (!filename) return 0;
   if (fgVerboseLevel>0) ::Info("TGeoManager::Import","Reading geometry from file: %s",filename);

   if (gGeoManager) delete gGeoManager;
   gGeoManager = 0;

   if (strstr(filename,".gdml")) {
      // import from a gdml file
      new TGeoManager("GDMLImport", "Geometry imported from GDML");
      TString cmd = TString::Format("TGDMLParse::StartGDML(\"%s\")", filename);
      TGeoVolume* world = (TGeoVolume*)gROOT->ProcessLineFast(cmd);

      if(world == 0) {
         ::Error("TGeoManager::Import", "Cannot open file");
      }
      else {
         gGeoManager->SetTopVolume(world);
         gGeoManager->CloseGeometry();
         gGeoManager->DefaultColors();
      }
   } else {
      // import from a root file
      TDirectory::TContext ctxt;
      // in case a web file is specified, use the cacheread option to cache
      // this file in the cache directory
      TFile *f = 0;
      if (strstr(filename,"http")) f = TFile::Open(filename,"CACHEREAD");
      else                         f = TFile::Open(filename);
      if (!f || f->IsZombie()) {
         ::Error("TGeoManager::Import", "Cannot open file");
         return 0;
      }
      if (name && strlen(name) > 0) {
         gGeoManager = (TGeoManager*)f->Get(name);
      } else {
         TIter next(f->GetListOfKeys());
         TKey *key;
         while ((key = (TKey*)next())) {
            if (strcmp(key->GetClassName(),"TGeoManager") != 0) continue;
            gGeoManager = (TGeoManager*)key->ReadObj();
            break;
         }
      }
      delete f;
   }
   if (!gGeoManager) return 0;
   if (!gROOT->GetListOfGeometries()->FindObject(gGeoManager)) gROOT->GetListOfGeometries()->Add(gGeoManager);
   if (!gROOT->GetListOfBrowsables()->FindObject(gGeoManager)) gROOT->GetListOfBrowsables()->Add(gGeoManager);
   gGeoManager->UpdateElements();
   return gGeoManager;
}

//___________________________________________________________________________
void TGeoManager::UpdateElements()
{
// Update element flags when geometry is loaded from a file.
   if (!fElementTable) return;
   TIter next(fMaterials);
   TGeoMaterial *mat;
   TGeoMixture *mix;
   TGeoElement *elem, *elem_table;
   Int_t i, nelem;
   while ((mat=(TGeoMaterial*)next())) {
      if (mat->IsMixture()) {
         mix = (TGeoMixture*)mat;
         nelem = mix->GetNelements();
         for (i=0; i<nelem; i++) {
            elem = mix->GetElement(i);
            if (!elem) continue;
            elem_table = fElementTable->GetElement(elem->Z());
            if (!elem_table) continue;
            if (elem != elem_table) {
               elem_table->SetDefined(elem->IsDefined());
               elem_table->SetUsed(elem->IsUsed());
            } else {
               elem_table->SetDefined();
            }
         }
      } else {
         elem = mat->GetElement();
         if (!elem) continue;
         elem_table = fElementTable->GetElement(elem->Z());
         if (!elem_table) continue;
         if (elem != elem_table) {
            elem_table->SetDefined(elem->IsDefined());
            elem_table->SetUsed(elem->IsUsed());
         } else {
            elem_table->SetUsed();
         }
      }
   }
}

//___________________________________________________________________________
Bool_t TGeoManager::InitArrayPNE() const
{
// Initialize PNE array for fast access via index and unique-id.
   if (fHashPNE) {
     fArrayPNE = new TObjArray(fHashPNE->GetSize());
     TIter next(fHashPNE);
     TObject *obj;
     while ((obj = next())) {
       fArrayPNE->Add(obj);
     }
     return kTRUE;
   }
   return kFALSE;
}

//______________________________________________________________________________
Bool_t TGeoManager::GetTminTmax(Double_t &tmin, Double_t &tmax) const
{
// Get time cut for drawing tracks.
   tmin = fTmin;
   tmax = fTmax;
   return fTimeCut;
}

//______________________________________________________________________________
void TGeoManager::SetTminTmax(Double_t tmin, Double_t tmax)
{
// Set time cut interval for drawing tracks. If called with no arguments, time
// cut will be disabled.
   fTmin = tmin;
   fTmax = tmax;
   if (tmin==0 && tmax==999) fTimeCut = kFALSE;
   else fTimeCut = kTRUE;
   if (fTracks && !IsAnimatingTracks()) ModifiedPad();
}

//______________________________________________________________________________
void TGeoManager::MasterToTop(const Double_t *master, Double_t *top) const
{
// Convert coordinates from master volume frame to top.
   GetCurrentNavigator()->MasterToLocal(master, top);
}

//______________________________________________________________________________
void TGeoManager::TopToMaster(const Double_t *top, Double_t *master) const
{
 // Convert coordinates from top volume frame to master.
   GetCurrentNavigator()->LocalToMaster(top, master);
}

//______________________________________________________________________________
TGeoParallelWorld *TGeoManager::CreateParallelWorld(const char *name)
{
// Create a parallel world for prioritized navigation. This can be populated
// with physical nodes and can be navigated independently using its API.
// In case the flag SetUseParallelWorldNav is set, any navigation query in the
// main geometry is checked against the parallel geometry, which gets priority
// in case of overlaps with the main geometry volumes.
   fParallelWorld = new TGeoParallelWorld(name, this);
   return fParallelWorld;
}

//______________________________________________________________________________
void TGeoManager::SetUseParallelWorldNav(Bool_t flag)
{
// Activate/deactivate usage of parallel world navigation. Can only be done if
// there is a parallel world. Activating navigation will automatically close
// the parallel geometry.
   if (!fParallelWorld) {
      Error("SetUseParallelWorldNav", "No parallel world geometry defined. Use CreateParallelWorld.");
      return;
   }
   if (!flag) {
      fUsePWNav = flag;
      return;
   }
   if (!fClosed) {
      Error("SetUseParallelWorldNav", "The geometry must be closed first");
      return;
   }
   // Closing the parallel world geometry is mandatory
   if (fParallelWorld->CloseGeometry()) fUsePWNav=kTRUE;
}
 TGeoManager.cxx:1
 TGeoManager.cxx:2
 TGeoManager.cxx:3
 TGeoManager.cxx:4
 TGeoManager.cxx:5
 TGeoManager.cxx:6
 TGeoManager.cxx:7
 TGeoManager.cxx:8
 TGeoManager.cxx:9
 TGeoManager.cxx:10
 TGeoManager.cxx:11
 TGeoManager.cxx:12
 TGeoManager.cxx:13
 TGeoManager.cxx:14
 TGeoManager.cxx:15
 TGeoManager.cxx:16
 TGeoManager.cxx:17
 TGeoManager.cxx:18
 TGeoManager.cxx:19
 TGeoManager.cxx:20
 TGeoManager.cxx:21
 TGeoManager.cxx:22
 TGeoManager.cxx:23
 TGeoManager.cxx:24
 TGeoManager.cxx:25
 TGeoManager.cxx:26
 TGeoManager.cxx:27
 TGeoManager.cxx:28
 TGeoManager.cxx:29
 TGeoManager.cxx:30
 TGeoManager.cxx:31
 TGeoManager.cxx:32
 TGeoManager.cxx:33
 TGeoManager.cxx:34
 TGeoManager.cxx:35
 TGeoManager.cxx:36
 TGeoManager.cxx:37
 TGeoManager.cxx:38
 TGeoManager.cxx:39
 TGeoManager.cxx:40
 TGeoManager.cxx:41
 TGeoManager.cxx:42
 TGeoManager.cxx:43
 TGeoManager.cxx:44
 TGeoManager.cxx:45
 TGeoManager.cxx:46
 TGeoManager.cxx:47
 TGeoManager.cxx:48
 TGeoManager.cxx:49
 TGeoManager.cxx:50
 TGeoManager.cxx:51
 TGeoManager.cxx:52
 TGeoManager.cxx:53
 TGeoManager.cxx:54
 TGeoManager.cxx:55
 TGeoManager.cxx:56
 TGeoManager.cxx:57
 TGeoManager.cxx:58
 TGeoManager.cxx:59
 TGeoManager.cxx:60
 TGeoManager.cxx:61
 TGeoManager.cxx:62
 TGeoManager.cxx:63
 TGeoManager.cxx:64
 TGeoManager.cxx:65
 TGeoManager.cxx:66
 TGeoManager.cxx:67
 TGeoManager.cxx:68
 TGeoManager.cxx:69
 TGeoManager.cxx:70
 TGeoManager.cxx:71
 TGeoManager.cxx:72
 TGeoManager.cxx:73
 TGeoManager.cxx:74
 TGeoManager.cxx:75
 TGeoManager.cxx:76
 TGeoManager.cxx:77
 TGeoManager.cxx:78
 TGeoManager.cxx:79
 TGeoManager.cxx:80
 TGeoManager.cxx:81
 TGeoManager.cxx:82
 TGeoManager.cxx:83
 TGeoManager.cxx:84
 TGeoManager.cxx:85
 TGeoManager.cxx:86
 TGeoManager.cxx:87
 TGeoManager.cxx:88
 TGeoManager.cxx:89
 TGeoManager.cxx:90
 TGeoManager.cxx:91
 TGeoManager.cxx:92
 TGeoManager.cxx:93
 TGeoManager.cxx:94
 TGeoManager.cxx:95
 TGeoManager.cxx:96
 TGeoManager.cxx:97
 TGeoManager.cxx:98
 TGeoManager.cxx:99
 TGeoManager.cxx:100
 TGeoManager.cxx:101
 TGeoManager.cxx:102
 TGeoManager.cxx:103
 TGeoManager.cxx:104
 TGeoManager.cxx:105
 TGeoManager.cxx:106
 TGeoManager.cxx:107
 TGeoManager.cxx:108
 TGeoManager.cxx:109
 TGeoManager.cxx:110
 TGeoManager.cxx:111
 TGeoManager.cxx:112
 TGeoManager.cxx:113
 TGeoManager.cxx:114
 TGeoManager.cxx:115
 TGeoManager.cxx:116
 TGeoManager.cxx:117
 TGeoManager.cxx:118
 TGeoManager.cxx:119
 TGeoManager.cxx:120
 TGeoManager.cxx:121
 TGeoManager.cxx:122
 TGeoManager.cxx:123
 TGeoManager.cxx:124
 TGeoManager.cxx:125
 TGeoManager.cxx:126
 TGeoManager.cxx:127
 TGeoManager.cxx:128
 TGeoManager.cxx:129
 TGeoManager.cxx:130
 TGeoManager.cxx:131
 TGeoManager.cxx:132
 TGeoManager.cxx:133
 TGeoManager.cxx:134
 TGeoManager.cxx:135
 TGeoManager.cxx:136
 TGeoManager.cxx:137
 TGeoManager.cxx:138
 TGeoManager.cxx:139
 TGeoManager.cxx:140
 TGeoManager.cxx:141
 TGeoManager.cxx:142
 TGeoManager.cxx:143
 TGeoManager.cxx:144
 TGeoManager.cxx:145
 TGeoManager.cxx:146
 TGeoManager.cxx:147
 TGeoManager.cxx:148
 TGeoManager.cxx:149
 TGeoManager.cxx:150
 TGeoManager.cxx:151
 TGeoManager.cxx:152
 TGeoManager.cxx:153
 TGeoManager.cxx:154
 TGeoManager.cxx:155
 TGeoManager.cxx:156
 TGeoManager.cxx:157
 TGeoManager.cxx:158
 TGeoManager.cxx:159
 TGeoManager.cxx:160
 TGeoManager.cxx:161
 TGeoManager.cxx:162
 TGeoManager.cxx:163
 TGeoManager.cxx:164
 TGeoManager.cxx:165
 TGeoManager.cxx:166
 TGeoManager.cxx:167
 TGeoManager.cxx:168
 TGeoManager.cxx:169
 TGeoManager.cxx:170
 TGeoManager.cxx:171
 TGeoManager.cxx:172
 TGeoManager.cxx:173
 TGeoManager.cxx:174
 TGeoManager.cxx:175
 TGeoManager.cxx:176
 TGeoManager.cxx:177
 TGeoManager.cxx:178
 TGeoManager.cxx:179
 TGeoManager.cxx:180
 TGeoManager.cxx:181
 TGeoManager.cxx:182
 TGeoManager.cxx:183
 TGeoManager.cxx:184
 TGeoManager.cxx:185
 TGeoManager.cxx:186
 TGeoManager.cxx:187
 TGeoManager.cxx:188
 TGeoManager.cxx:189
 TGeoManager.cxx:190
 TGeoManager.cxx:191
 TGeoManager.cxx:192
 TGeoManager.cxx:193
 TGeoManager.cxx:194
 TGeoManager.cxx:195
 TGeoManager.cxx:196
 TGeoManager.cxx:197
 TGeoManager.cxx:198
 TGeoManager.cxx:199
 TGeoManager.cxx:200
 TGeoManager.cxx:201
 TGeoManager.cxx:202
 TGeoManager.cxx:203
 TGeoManager.cxx:204
 TGeoManager.cxx:205
 TGeoManager.cxx:206
 TGeoManager.cxx:207
 TGeoManager.cxx:208
 TGeoManager.cxx:209
 TGeoManager.cxx:210
 TGeoManager.cxx:211
 TGeoManager.cxx:212
 TGeoManager.cxx:213
 TGeoManager.cxx:214
 TGeoManager.cxx:215
 TGeoManager.cxx:216
 TGeoManager.cxx:217
 TGeoManager.cxx:218
 TGeoManager.cxx:219
 TGeoManager.cxx:220
 TGeoManager.cxx:221
 TGeoManager.cxx:222
 TGeoManager.cxx:223
 TGeoManager.cxx:224
 TGeoManager.cxx:225
 TGeoManager.cxx:226
 TGeoManager.cxx:227
 TGeoManager.cxx:228
 TGeoManager.cxx:229
 TGeoManager.cxx:230
 TGeoManager.cxx:231
 TGeoManager.cxx:232
 TGeoManager.cxx:233
 TGeoManager.cxx:234
 TGeoManager.cxx:235
 TGeoManager.cxx:236
 TGeoManager.cxx:237
 TGeoManager.cxx:238
 TGeoManager.cxx:239
 TGeoManager.cxx:240
 TGeoManager.cxx:241
 TGeoManager.cxx:242
 TGeoManager.cxx:243
 TGeoManager.cxx:244
 TGeoManager.cxx:245
 TGeoManager.cxx:246
 TGeoManager.cxx:247
 TGeoManager.cxx:248
 TGeoManager.cxx:249
 TGeoManager.cxx:250
 TGeoManager.cxx:251
 TGeoManager.cxx:252
 TGeoManager.cxx:253
 TGeoManager.cxx:254
 TGeoManager.cxx:255
 TGeoManager.cxx:256
 TGeoManager.cxx:257
 TGeoManager.cxx:258
 TGeoManager.cxx:259
 TGeoManager.cxx:260
 TGeoManager.cxx:261
 TGeoManager.cxx:262
 TGeoManager.cxx:263
 TGeoManager.cxx:264
 TGeoManager.cxx:265
 TGeoManager.cxx:266
 TGeoManager.cxx:267
 TGeoManager.cxx:268
 TGeoManager.cxx:269
 TGeoManager.cxx:270
 TGeoManager.cxx:271
 TGeoManager.cxx:272
 TGeoManager.cxx:273
 TGeoManager.cxx:274
 TGeoManager.cxx:275
 TGeoManager.cxx:276
 TGeoManager.cxx:277
 TGeoManager.cxx:278
 TGeoManager.cxx:279
 TGeoManager.cxx:280
 TGeoManager.cxx:281
 TGeoManager.cxx:282
 TGeoManager.cxx:283
 TGeoManager.cxx:284
 TGeoManager.cxx:285
 TGeoManager.cxx:286
 TGeoManager.cxx:287
 TGeoManager.cxx:288
 TGeoManager.cxx:289
 TGeoManager.cxx:290
 TGeoManager.cxx:291
 TGeoManager.cxx:292
 TGeoManager.cxx:293
 TGeoManager.cxx:294
 TGeoManager.cxx:295
 TGeoManager.cxx:296
 TGeoManager.cxx:297
 TGeoManager.cxx:298
 TGeoManager.cxx:299
 TGeoManager.cxx:300
 TGeoManager.cxx:301
 TGeoManager.cxx:302
 TGeoManager.cxx:303
 TGeoManager.cxx:304
 TGeoManager.cxx:305
 TGeoManager.cxx:306
 TGeoManager.cxx:307
 TGeoManager.cxx:308
 TGeoManager.cxx:309
 TGeoManager.cxx:310
 TGeoManager.cxx:311
 TGeoManager.cxx:312
 TGeoManager.cxx:313
 TGeoManager.cxx:314
 TGeoManager.cxx:315
 TGeoManager.cxx:316
 TGeoManager.cxx:317
 TGeoManager.cxx:318
 TGeoManager.cxx:319
 TGeoManager.cxx:320
 TGeoManager.cxx:321
 TGeoManager.cxx:322
 TGeoManager.cxx:323
 TGeoManager.cxx:324
 TGeoManager.cxx:325
 TGeoManager.cxx:326
 TGeoManager.cxx:327
 TGeoManager.cxx:328
 TGeoManager.cxx:329
 TGeoManager.cxx:330
 TGeoManager.cxx:331
 TGeoManager.cxx:332
 TGeoManager.cxx:333
 TGeoManager.cxx:334
 TGeoManager.cxx:335
 TGeoManager.cxx:336
 TGeoManager.cxx:337
 TGeoManager.cxx:338
 TGeoManager.cxx:339
 TGeoManager.cxx:340
 TGeoManager.cxx:341
 TGeoManager.cxx:342
 TGeoManager.cxx:343
 TGeoManager.cxx:344
 TGeoManager.cxx:345
 TGeoManager.cxx:346
 TGeoManager.cxx:347
 TGeoManager.cxx:348
 TGeoManager.cxx:349
 TGeoManager.cxx:350
 TGeoManager.cxx:351
 TGeoManager.cxx:352
 TGeoManager.cxx:353
 TGeoManager.cxx:354
 TGeoManager.cxx:355
 TGeoManager.cxx:356
 TGeoManager.cxx:357
 TGeoManager.cxx:358
 TGeoManager.cxx:359
 TGeoManager.cxx:360
 TGeoManager.cxx:361
 TGeoManager.cxx:362
 TGeoManager.cxx:363
 TGeoManager.cxx:364
 TGeoManager.cxx:365
 TGeoManager.cxx:366
 TGeoManager.cxx:367
 TGeoManager.cxx:368
 TGeoManager.cxx:369
 TGeoManager.cxx:370
 TGeoManager.cxx:371
 TGeoManager.cxx:372
 TGeoManager.cxx:373
 TGeoManager.cxx:374
 TGeoManager.cxx:375
 TGeoManager.cxx:376
 TGeoManager.cxx:377
 TGeoManager.cxx:378
 TGeoManager.cxx:379
 TGeoManager.cxx:380
 TGeoManager.cxx:381
 TGeoManager.cxx:382
 TGeoManager.cxx:383
 TGeoManager.cxx:384
 TGeoManager.cxx:385
 TGeoManager.cxx:386
 TGeoManager.cxx:387
 TGeoManager.cxx:388
 TGeoManager.cxx:389
 TGeoManager.cxx:390
 TGeoManager.cxx:391
 TGeoManager.cxx:392
 TGeoManager.cxx:393
 TGeoManager.cxx:394
 TGeoManager.cxx:395
 TGeoManager.cxx:396
 TGeoManager.cxx:397
 TGeoManager.cxx:398
 TGeoManager.cxx:399
 TGeoManager.cxx:400
 TGeoManager.cxx:401
 TGeoManager.cxx:402
 TGeoManager.cxx:403
 TGeoManager.cxx:404
 TGeoManager.cxx:405
 TGeoManager.cxx:406
 TGeoManager.cxx:407
 TGeoManager.cxx:408
 TGeoManager.cxx:409
 TGeoManager.cxx:410
 TGeoManager.cxx:411
 TGeoManager.cxx:412
 TGeoManager.cxx:413
 TGeoManager.cxx:414
 TGeoManager.cxx:415
 TGeoManager.cxx:416
 TGeoManager.cxx:417
 TGeoManager.cxx:418
 TGeoManager.cxx:419
 TGeoManager.cxx:420
 TGeoManager.cxx:421
 TGeoManager.cxx:422
 TGeoManager.cxx:423
 TGeoManager.cxx:424
 TGeoManager.cxx:425
 TGeoManager.cxx:426
 TGeoManager.cxx:427
 TGeoManager.cxx:428
 TGeoManager.cxx:429
 TGeoManager.cxx:430
 TGeoManager.cxx:431
 TGeoManager.cxx:432
 TGeoManager.cxx:433
 TGeoManager.cxx:434
 TGeoManager.cxx:435
 TGeoManager.cxx:436
 TGeoManager.cxx:437
 TGeoManager.cxx:438
 TGeoManager.cxx:439
 TGeoManager.cxx:440
 TGeoManager.cxx:441
 TGeoManager.cxx:442
 TGeoManager.cxx:443
 TGeoManager.cxx:444
 TGeoManager.cxx:445
 TGeoManager.cxx:446
 TGeoManager.cxx:447
 TGeoManager.cxx:448
 TGeoManager.cxx:449
 TGeoManager.cxx:450
 TGeoManager.cxx:451
 TGeoManager.cxx:452
 TGeoManager.cxx:453
 TGeoManager.cxx:454
 TGeoManager.cxx:455
 TGeoManager.cxx:456
 TGeoManager.cxx:457
 TGeoManager.cxx:458
 TGeoManager.cxx:459
 TGeoManager.cxx:460
 TGeoManager.cxx:461
 TGeoManager.cxx:462
 TGeoManager.cxx:463
 TGeoManager.cxx:464
 TGeoManager.cxx:465
 TGeoManager.cxx:466
 TGeoManager.cxx:467
 TGeoManager.cxx:468
 TGeoManager.cxx:469
 TGeoManager.cxx:470
 TGeoManager.cxx:471
 TGeoManager.cxx:472
 TGeoManager.cxx:473
 TGeoManager.cxx:474
 TGeoManager.cxx:475
 TGeoManager.cxx:476
 TGeoManager.cxx:477
 TGeoManager.cxx:478
 TGeoManager.cxx:479
 TGeoManager.cxx:480
 TGeoManager.cxx:481
 TGeoManager.cxx:482
 TGeoManager.cxx:483
 TGeoManager.cxx:484
 TGeoManager.cxx:485
 TGeoManager.cxx:486
 TGeoManager.cxx:487
 TGeoManager.cxx:488
 TGeoManager.cxx:489
 TGeoManager.cxx:490
 TGeoManager.cxx:491
 TGeoManager.cxx:492
 TGeoManager.cxx:493
 TGeoManager.cxx:494
 TGeoManager.cxx:495
 TGeoManager.cxx:496
 TGeoManager.cxx:497
 TGeoManager.cxx:498
 TGeoManager.cxx:499
 TGeoManager.cxx:500
 TGeoManager.cxx:501
 TGeoManager.cxx:502
 TGeoManager.cxx:503
 TGeoManager.cxx:504
 TGeoManager.cxx:505
 TGeoManager.cxx:506
 TGeoManager.cxx:507
 TGeoManager.cxx:508
 TGeoManager.cxx:509
 TGeoManager.cxx:510
 TGeoManager.cxx:511
 TGeoManager.cxx:512
 TGeoManager.cxx:513
 TGeoManager.cxx:514
 TGeoManager.cxx:515
 TGeoManager.cxx:516
 TGeoManager.cxx:517
 TGeoManager.cxx:518
 TGeoManager.cxx:519
 TGeoManager.cxx:520
 TGeoManager.cxx:521
 TGeoManager.cxx:522
 TGeoManager.cxx:523
 TGeoManager.cxx:524
 TGeoManager.cxx:525
 TGeoManager.cxx:526
 TGeoManager.cxx:527
 TGeoManager.cxx:528
 TGeoManager.cxx:529
 TGeoManager.cxx:530
 TGeoManager.cxx:531
 TGeoManager.cxx:532
 TGeoManager.cxx:533
 TGeoManager.cxx:534
 TGeoManager.cxx:535
 TGeoManager.cxx:536
 TGeoManager.cxx:537
 TGeoManager.cxx:538
 TGeoManager.cxx:539
 TGeoManager.cxx:540
 TGeoManager.cxx:541
 TGeoManager.cxx:542
 TGeoManager.cxx:543
 TGeoManager.cxx:544
 TGeoManager.cxx:545
 TGeoManager.cxx:546
 TGeoManager.cxx:547
 TGeoManager.cxx:548
 TGeoManager.cxx:549
 TGeoManager.cxx:550
 TGeoManager.cxx:551
 TGeoManager.cxx:552
 TGeoManager.cxx:553
 TGeoManager.cxx:554
 TGeoManager.cxx:555
 TGeoManager.cxx:556
 TGeoManager.cxx:557
 TGeoManager.cxx:558
 TGeoManager.cxx:559
 TGeoManager.cxx:560
 TGeoManager.cxx:561
 TGeoManager.cxx:562
 TGeoManager.cxx:563
 TGeoManager.cxx:564
 TGeoManager.cxx:565
 TGeoManager.cxx:566
 TGeoManager.cxx:567
 TGeoManager.cxx:568
 TGeoManager.cxx:569
 TGeoManager.cxx:570
 TGeoManager.cxx:571
 TGeoManager.cxx:572
 TGeoManager.cxx:573
 TGeoManager.cxx:574
 TGeoManager.cxx:575
 TGeoManager.cxx:576
 TGeoManager.cxx:577
 TGeoManager.cxx:578
 TGeoManager.cxx:579
 TGeoManager.cxx:580
 TGeoManager.cxx:581
 TGeoManager.cxx:582
 TGeoManager.cxx:583
 TGeoManager.cxx:584
 TGeoManager.cxx:585
 TGeoManager.cxx:586
 TGeoManager.cxx:587
 TGeoManager.cxx:588
 TGeoManager.cxx:589
 TGeoManager.cxx:590
 TGeoManager.cxx:591
 TGeoManager.cxx:592
 TGeoManager.cxx:593
 TGeoManager.cxx:594
 TGeoManager.cxx:595
 TGeoManager.cxx:596
 TGeoManager.cxx:597
 TGeoManager.cxx:598
 TGeoManager.cxx:599
 TGeoManager.cxx:600
 TGeoManager.cxx:601
 TGeoManager.cxx:602
 TGeoManager.cxx:603
 TGeoManager.cxx:604
 TGeoManager.cxx:605
 TGeoManager.cxx:606
 TGeoManager.cxx:607
 TGeoManager.cxx:608
 TGeoManager.cxx:609
 TGeoManager.cxx:610
 TGeoManager.cxx:611
 TGeoManager.cxx:612
 TGeoManager.cxx:613
 TGeoManager.cxx:614
 TGeoManager.cxx:615
 TGeoManager.cxx:616
 TGeoManager.cxx:617
 TGeoManager.cxx:618
 TGeoManager.cxx:619
 TGeoManager.cxx:620
 TGeoManager.cxx:621
 TGeoManager.cxx:622
 TGeoManager.cxx:623
 TGeoManager.cxx:624
 TGeoManager.cxx:625
 TGeoManager.cxx:626
 TGeoManager.cxx:627
 TGeoManager.cxx:628
 TGeoManager.cxx:629
 TGeoManager.cxx:630
 TGeoManager.cxx:631
 TGeoManager.cxx:632
 TGeoManager.cxx:633
 TGeoManager.cxx:634
 TGeoManager.cxx:635
 TGeoManager.cxx:636
 TGeoManager.cxx:637
 TGeoManager.cxx:638
 TGeoManager.cxx:639
 TGeoManager.cxx:640
 TGeoManager.cxx:641
 TGeoManager.cxx:642
 TGeoManager.cxx:643
 TGeoManager.cxx:644
 TGeoManager.cxx:645
 TGeoManager.cxx:646
 TGeoManager.cxx:647
 TGeoManager.cxx:648
 TGeoManager.cxx:649
 TGeoManager.cxx:650
 TGeoManager.cxx:651
 TGeoManager.cxx:652
 TGeoManager.cxx:653
 TGeoManager.cxx:654
 TGeoManager.cxx:655
 TGeoManager.cxx:656
 TGeoManager.cxx:657
 TGeoManager.cxx:658
 TGeoManager.cxx:659
 TGeoManager.cxx:660
 TGeoManager.cxx:661
 TGeoManager.cxx:662
 TGeoManager.cxx:663
 TGeoManager.cxx:664
 TGeoManager.cxx:665
 TGeoManager.cxx:666
 TGeoManager.cxx:667
 TGeoManager.cxx:668
 TGeoManager.cxx:669
 TGeoManager.cxx:670
 TGeoManager.cxx:671
 TGeoManager.cxx:672
 TGeoManager.cxx:673
 TGeoManager.cxx:674
 TGeoManager.cxx:675
 TGeoManager.cxx:676
 TGeoManager.cxx:677
 TGeoManager.cxx:678
 TGeoManager.cxx:679
 TGeoManager.cxx:680
 TGeoManager.cxx:681
 TGeoManager.cxx:682
 TGeoManager.cxx:683
 TGeoManager.cxx:684
 TGeoManager.cxx:685
 TGeoManager.cxx:686
 TGeoManager.cxx:687
 TGeoManager.cxx:688
 TGeoManager.cxx:689
 TGeoManager.cxx:690
 TGeoManager.cxx:691
 TGeoManager.cxx:692
 TGeoManager.cxx:693
 TGeoManager.cxx:694
 TGeoManager.cxx:695
 TGeoManager.cxx:696
 TGeoManager.cxx:697
 TGeoManager.cxx:698
 TGeoManager.cxx:699
 TGeoManager.cxx:700
 TGeoManager.cxx:701
 TGeoManager.cxx:702
 TGeoManager.cxx:703
 TGeoManager.cxx:704
 TGeoManager.cxx:705
 TGeoManager.cxx:706
 TGeoManager.cxx:707
 TGeoManager.cxx:708
 TGeoManager.cxx:709
 TGeoManager.cxx:710
 TGeoManager.cxx:711
 TGeoManager.cxx:712
 TGeoManager.cxx:713
 TGeoManager.cxx:714
 TGeoManager.cxx:715
 TGeoManager.cxx:716
 TGeoManager.cxx:717
 TGeoManager.cxx:718
 TGeoManager.cxx:719
 TGeoManager.cxx:720
 TGeoManager.cxx:721
 TGeoManager.cxx:722
 TGeoManager.cxx:723
 TGeoManager.cxx:724
 TGeoManager.cxx:725
 TGeoManager.cxx:726
 TGeoManager.cxx:727
 TGeoManager.cxx:728
 TGeoManager.cxx:729
 TGeoManager.cxx:730
 TGeoManager.cxx:731
 TGeoManager.cxx:732
 TGeoManager.cxx:733
 TGeoManager.cxx:734
 TGeoManager.cxx:735
 TGeoManager.cxx:736
 TGeoManager.cxx:737
 TGeoManager.cxx:738
 TGeoManager.cxx:739
 TGeoManager.cxx:740
 TGeoManager.cxx:741
 TGeoManager.cxx:742
 TGeoManager.cxx:743
 TGeoManager.cxx:744
 TGeoManager.cxx:745
 TGeoManager.cxx:746
 TGeoManager.cxx:747
 TGeoManager.cxx:748
 TGeoManager.cxx:749
 TGeoManager.cxx:750
 TGeoManager.cxx:751
 TGeoManager.cxx:752
 TGeoManager.cxx:753
 TGeoManager.cxx:754
 TGeoManager.cxx:755
 TGeoManager.cxx:756
 TGeoManager.cxx:757
 TGeoManager.cxx:758
 TGeoManager.cxx:759
 TGeoManager.cxx:760
 TGeoManager.cxx:761
 TGeoManager.cxx:762
 TGeoManager.cxx:763
 TGeoManager.cxx:764
 TGeoManager.cxx:765
 TGeoManager.cxx:766
 TGeoManager.cxx:767
 TGeoManager.cxx:768
 TGeoManager.cxx:769
 TGeoManager.cxx:770
 TGeoManager.cxx:771
 TGeoManager.cxx:772
 TGeoManager.cxx:773
 TGeoManager.cxx:774
 TGeoManager.cxx:775
 TGeoManager.cxx:776
 TGeoManager.cxx:777
 TGeoManager.cxx:778
 TGeoManager.cxx:779
 TGeoManager.cxx:780
 TGeoManager.cxx:781
 TGeoManager.cxx:782
 TGeoManager.cxx:783
 TGeoManager.cxx:784
 TGeoManager.cxx:785
 TGeoManager.cxx:786
 TGeoManager.cxx:787
 TGeoManager.cxx:788
 TGeoManager.cxx:789
 TGeoManager.cxx:790
 TGeoManager.cxx:791
 TGeoManager.cxx:792
 TGeoManager.cxx:793
 TGeoManager.cxx:794
 TGeoManager.cxx:795
 TGeoManager.cxx:796
 TGeoManager.cxx:797
 TGeoManager.cxx:798
 TGeoManager.cxx:799
 TGeoManager.cxx:800
 TGeoManager.cxx:801
 TGeoManager.cxx:802
 TGeoManager.cxx:803
 TGeoManager.cxx:804
 TGeoManager.cxx:805
 TGeoManager.cxx:806
 TGeoManager.cxx:807
 TGeoManager.cxx:808
 TGeoManager.cxx:809
 TGeoManager.cxx:810
 TGeoManager.cxx:811
 TGeoManager.cxx:812
 TGeoManager.cxx:813
 TGeoManager.cxx:814
 TGeoManager.cxx:815
 TGeoManager.cxx:816
 TGeoManager.cxx:817
 TGeoManager.cxx:818
 TGeoManager.cxx:819
 TGeoManager.cxx:820
 TGeoManager.cxx:821
 TGeoManager.cxx:822
 TGeoManager.cxx:823
 TGeoManager.cxx:824
 TGeoManager.cxx:825
 TGeoManager.cxx:826
 TGeoManager.cxx:827
 TGeoManager.cxx:828
 TGeoManager.cxx:829
 TGeoManager.cxx:830
 TGeoManager.cxx:831
 TGeoManager.cxx:832
 TGeoManager.cxx:833
 TGeoManager.cxx:834
 TGeoManager.cxx:835
 TGeoManager.cxx:836
 TGeoManager.cxx:837
 TGeoManager.cxx:838
 TGeoManager.cxx:839
 TGeoManager.cxx:840
 TGeoManager.cxx:841
 TGeoManager.cxx:842
 TGeoManager.cxx:843
 TGeoManager.cxx:844
 TGeoManager.cxx:845
 TGeoManager.cxx:846
 TGeoManager.cxx:847
 TGeoManager.cxx:848
 TGeoManager.cxx:849
 TGeoManager.cxx:850
 TGeoManager.cxx:851
 TGeoManager.cxx:852
 TGeoManager.cxx:853
 TGeoManager.cxx:854
 TGeoManager.cxx:855
 TGeoManager.cxx:856
 TGeoManager.cxx:857
 TGeoManager.cxx:858
 TGeoManager.cxx:859
 TGeoManager.cxx:860
 TGeoManager.cxx:861
 TGeoManager.cxx:862
 TGeoManager.cxx:863
 TGeoManager.cxx:864
 TGeoManager.cxx:865
 TGeoManager.cxx:866
 TGeoManager.cxx:867
 TGeoManager.cxx:868
 TGeoManager.cxx:869
 TGeoManager.cxx:870
 TGeoManager.cxx:871
 TGeoManager.cxx:872
 TGeoManager.cxx:873
 TGeoManager.cxx:874
 TGeoManager.cxx:875
 TGeoManager.cxx:876
 TGeoManager.cxx:877
 TGeoManager.cxx:878
 TGeoManager.cxx:879
 TGeoManager.cxx:880
 TGeoManager.cxx:881
 TGeoManager.cxx:882
 TGeoManager.cxx:883
 TGeoManager.cxx:884
 TGeoManager.cxx:885
 TGeoManager.cxx:886
 TGeoManager.cxx:887
 TGeoManager.cxx:888
 TGeoManager.cxx:889
 TGeoManager.cxx:890
 TGeoManager.cxx:891
 TGeoManager.cxx:892
 TGeoManager.cxx:893
 TGeoManager.cxx:894
 TGeoManager.cxx:895
 TGeoManager.cxx:896
 TGeoManager.cxx:897
 TGeoManager.cxx:898
 TGeoManager.cxx:899
 TGeoManager.cxx:900
 TGeoManager.cxx:901
 TGeoManager.cxx:902
 TGeoManager.cxx:903
 TGeoManager.cxx:904
 TGeoManager.cxx:905
 TGeoManager.cxx:906
 TGeoManager.cxx:907
 TGeoManager.cxx:908
 TGeoManager.cxx:909
 TGeoManager.cxx:910
 TGeoManager.cxx:911
 TGeoManager.cxx:912
 TGeoManager.cxx:913
 TGeoManager.cxx:914
 TGeoManager.cxx:915
 TGeoManager.cxx:916
 TGeoManager.cxx:917
 TGeoManager.cxx:918
 TGeoManager.cxx:919
 TGeoManager.cxx:920
 TGeoManager.cxx:921
 TGeoManager.cxx:922
 TGeoManager.cxx:923
 TGeoManager.cxx:924
 TGeoManager.cxx:925
 TGeoManager.cxx:926
 TGeoManager.cxx:927
 TGeoManager.cxx:928
 TGeoManager.cxx:929
 TGeoManager.cxx:930
 TGeoManager.cxx:931
 TGeoManager.cxx:932
 TGeoManager.cxx:933
 TGeoManager.cxx:934
 TGeoManager.cxx:935
 TGeoManager.cxx:936
 TGeoManager.cxx:937
 TGeoManager.cxx:938
 TGeoManager.cxx:939
 TGeoManager.cxx:940
 TGeoManager.cxx:941
 TGeoManager.cxx:942
 TGeoManager.cxx:943
 TGeoManager.cxx:944
 TGeoManager.cxx:945
 TGeoManager.cxx:946
 TGeoManager.cxx:947
 TGeoManager.cxx:948
 TGeoManager.cxx:949
 TGeoManager.cxx:950
 TGeoManager.cxx:951
 TGeoManager.cxx:952
 TGeoManager.cxx:953
 TGeoManager.cxx:954
 TGeoManager.cxx:955
 TGeoManager.cxx:956
 TGeoManager.cxx:957
 TGeoManager.cxx:958
 TGeoManager.cxx:959
 TGeoManager.cxx:960
 TGeoManager.cxx:961
 TGeoManager.cxx:962
 TGeoManager.cxx:963
 TGeoManager.cxx:964
 TGeoManager.cxx:965
 TGeoManager.cxx:966
 TGeoManager.cxx:967
 TGeoManager.cxx:968
 TGeoManager.cxx:969
 TGeoManager.cxx:970
 TGeoManager.cxx:971
 TGeoManager.cxx:972
 TGeoManager.cxx:973
 TGeoManager.cxx:974
 TGeoManager.cxx:975
 TGeoManager.cxx:976
 TGeoManager.cxx:977
 TGeoManager.cxx:978
 TGeoManager.cxx:979
 TGeoManager.cxx:980
 TGeoManager.cxx:981
 TGeoManager.cxx:982
 TGeoManager.cxx:983
 TGeoManager.cxx:984
 TGeoManager.cxx:985
 TGeoManager.cxx:986
 TGeoManager.cxx:987
 TGeoManager.cxx:988
 TGeoManager.cxx:989
 TGeoManager.cxx:990
 TGeoManager.cxx:991
 TGeoManager.cxx:992
 TGeoManager.cxx:993
 TGeoManager.cxx:994
 TGeoManager.cxx:995
 TGeoManager.cxx:996
 TGeoManager.cxx:997
 TGeoManager.cxx:998
 TGeoManager.cxx:999
 TGeoManager.cxx:1000
 TGeoManager.cxx:1001
 TGeoManager.cxx:1002
 TGeoManager.cxx:1003
 TGeoManager.cxx:1004
 TGeoManager.cxx:1005
 TGeoManager.cxx:1006
 TGeoManager.cxx:1007
 TGeoManager.cxx:1008
 TGeoManager.cxx:1009
 TGeoManager.cxx:1010
 TGeoManager.cxx:1011
 TGeoManager.cxx:1012
 TGeoManager.cxx:1013
 TGeoManager.cxx:1014
 TGeoManager.cxx:1015
 TGeoManager.cxx:1016
 TGeoManager.cxx:1017
 TGeoManager.cxx:1018
 TGeoManager.cxx:1019
 TGeoManager.cxx:1020
 TGeoManager.cxx:1021
 TGeoManager.cxx:1022
 TGeoManager.cxx:1023
 TGeoManager.cxx:1024
 TGeoManager.cxx:1025
 TGeoManager.cxx:1026
 TGeoManager.cxx:1027
 TGeoManager.cxx:1028
 TGeoManager.cxx:1029
 TGeoManager.cxx:1030
 TGeoManager.cxx:1031
 TGeoManager.cxx:1032
 TGeoManager.cxx:1033
 TGeoManager.cxx:1034
 TGeoManager.cxx:1035
 TGeoManager.cxx:1036
 TGeoManager.cxx:1037
 TGeoManager.cxx:1038
 TGeoManager.cxx:1039
 TGeoManager.cxx:1040
 TGeoManager.cxx:1041
 TGeoManager.cxx:1042
 TGeoManager.cxx:1043
 TGeoManager.cxx:1044
 TGeoManager.cxx:1045
 TGeoManager.cxx:1046
 TGeoManager.cxx:1047
 TGeoManager.cxx:1048
 TGeoManager.cxx:1049
 TGeoManager.cxx:1050
 TGeoManager.cxx:1051
 TGeoManager.cxx:1052
 TGeoManager.cxx:1053
 TGeoManager.cxx:1054
 TGeoManager.cxx:1055
 TGeoManager.cxx:1056
 TGeoManager.cxx:1057
 TGeoManager.cxx:1058
 TGeoManager.cxx:1059
 TGeoManager.cxx:1060
 TGeoManager.cxx:1061
 TGeoManager.cxx:1062
 TGeoManager.cxx:1063
 TGeoManager.cxx:1064
 TGeoManager.cxx:1065
 TGeoManager.cxx:1066
 TGeoManager.cxx:1067
 TGeoManager.cxx:1068
 TGeoManager.cxx:1069
 TGeoManager.cxx:1070
 TGeoManager.cxx:1071
 TGeoManager.cxx:1072
 TGeoManager.cxx:1073
 TGeoManager.cxx:1074
 TGeoManager.cxx:1075
 TGeoManager.cxx:1076
 TGeoManager.cxx:1077
 TGeoManager.cxx:1078
 TGeoManager.cxx:1079
 TGeoManager.cxx:1080
 TGeoManager.cxx:1081
 TGeoManager.cxx:1082
 TGeoManager.cxx:1083
 TGeoManager.cxx:1084
 TGeoManager.cxx:1085
 TGeoManager.cxx:1086
 TGeoManager.cxx:1087
 TGeoManager.cxx:1088
 TGeoManager.cxx:1089
 TGeoManager.cxx:1090
 TGeoManager.cxx:1091
 TGeoManager.cxx:1092
 TGeoManager.cxx:1093
 TGeoManager.cxx:1094
 TGeoManager.cxx:1095
 TGeoManager.cxx:1096
 TGeoManager.cxx:1097
 TGeoManager.cxx:1098
 TGeoManager.cxx:1099
 TGeoManager.cxx:1100
 TGeoManager.cxx:1101
 TGeoManager.cxx:1102
 TGeoManager.cxx:1103
 TGeoManager.cxx:1104
 TGeoManager.cxx:1105
 TGeoManager.cxx:1106
 TGeoManager.cxx:1107
 TGeoManager.cxx:1108
 TGeoManager.cxx:1109
 TGeoManager.cxx:1110
 TGeoManager.cxx:1111
 TGeoManager.cxx:1112
 TGeoManager.cxx:1113
 TGeoManager.cxx:1114
 TGeoManager.cxx:1115
 TGeoManager.cxx:1116
 TGeoManager.cxx:1117
 TGeoManager.cxx:1118
 TGeoManager.cxx:1119
 TGeoManager.cxx:1120
 TGeoManager.cxx:1121
 TGeoManager.cxx:1122
 TGeoManager.cxx:1123
 TGeoManager.cxx:1124
 TGeoManager.cxx:1125
 TGeoManager.cxx:1126
 TGeoManager.cxx:1127
 TGeoManager.cxx:1128
 TGeoManager.cxx:1129
 TGeoManager.cxx:1130
 TGeoManager.cxx:1131
 TGeoManager.cxx:1132
 TGeoManager.cxx:1133
 TGeoManager.cxx:1134
 TGeoManager.cxx:1135
 TGeoManager.cxx:1136
 TGeoManager.cxx:1137
 TGeoManager.cxx:1138
 TGeoManager.cxx:1139
 TGeoManager.cxx:1140
 TGeoManager.cxx:1141
 TGeoManager.cxx:1142
 TGeoManager.cxx:1143
 TGeoManager.cxx:1144
 TGeoManager.cxx:1145
 TGeoManager.cxx:1146
 TGeoManager.cxx:1147
 TGeoManager.cxx:1148
 TGeoManager.cxx:1149
 TGeoManager.cxx:1150
 TGeoManager.cxx:1151
 TGeoManager.cxx:1152
 TGeoManager.cxx:1153
 TGeoManager.cxx:1154
 TGeoManager.cxx:1155
 TGeoManager.cxx:1156
 TGeoManager.cxx:1157
 TGeoManager.cxx:1158
 TGeoManager.cxx:1159
 TGeoManager.cxx:1160
 TGeoManager.cxx:1161
 TGeoManager.cxx:1162
 TGeoManager.cxx:1163
 TGeoManager.cxx:1164
 TGeoManager.cxx:1165
 TGeoManager.cxx:1166
 TGeoManager.cxx:1167
 TGeoManager.cxx:1168
 TGeoManager.cxx:1169
 TGeoManager.cxx:1170
 TGeoManager.cxx:1171
 TGeoManager.cxx:1172
 TGeoManager.cxx:1173
 TGeoManager.cxx:1174
 TGeoManager.cxx:1175
 TGeoManager.cxx:1176
 TGeoManager.cxx:1177
 TGeoManager.cxx:1178
 TGeoManager.cxx:1179
 TGeoManager.cxx:1180
 TGeoManager.cxx:1181
 TGeoManager.cxx:1182
 TGeoManager.cxx:1183
 TGeoManager.cxx:1184
 TGeoManager.cxx:1185
 TGeoManager.cxx:1186
 TGeoManager.cxx:1187
 TGeoManager.cxx:1188
 TGeoManager.cxx:1189
 TGeoManager.cxx:1190
 TGeoManager.cxx:1191
 TGeoManager.cxx:1192
 TGeoManager.cxx:1193
 TGeoManager.cxx:1194
 TGeoManager.cxx:1195
 TGeoManager.cxx:1196
 TGeoManager.cxx:1197
 TGeoManager.cxx:1198
 TGeoManager.cxx:1199
 TGeoManager.cxx:1200
 TGeoManager.cxx:1201
 TGeoManager.cxx:1202
 TGeoManager.cxx:1203
 TGeoManager.cxx:1204
 TGeoManager.cxx:1205
 TGeoManager.cxx:1206
 TGeoManager.cxx:1207
 TGeoManager.cxx:1208
 TGeoManager.cxx:1209
 TGeoManager.cxx:1210
 TGeoManager.cxx:1211
 TGeoManager.cxx:1212
 TGeoManager.cxx:1213
 TGeoManager.cxx:1214
 TGeoManager.cxx:1215
 TGeoManager.cxx:1216
 TGeoManager.cxx:1217
 TGeoManager.cxx:1218
 TGeoManager.cxx:1219
 TGeoManager.cxx:1220
 TGeoManager.cxx:1221
 TGeoManager.cxx:1222
 TGeoManager.cxx:1223
 TGeoManager.cxx:1224
 TGeoManager.cxx:1225
 TGeoManager.cxx:1226
 TGeoManager.cxx:1227
 TGeoManager.cxx:1228
 TGeoManager.cxx:1229
 TGeoManager.cxx:1230
 TGeoManager.cxx:1231
 TGeoManager.cxx:1232
 TGeoManager.cxx:1233
 TGeoManager.cxx:1234
 TGeoManager.cxx:1235
 TGeoManager.cxx:1236
 TGeoManager.cxx:1237
 TGeoManager.cxx:1238
 TGeoManager.cxx:1239
 TGeoManager.cxx:1240
 TGeoManager.cxx:1241
 TGeoManager.cxx:1242
 TGeoManager.cxx:1243
 TGeoManager.cxx:1244
 TGeoManager.cxx:1245
 TGeoManager.cxx:1246
 TGeoManager.cxx:1247
 TGeoManager.cxx:1248
 TGeoManager.cxx:1249
 TGeoManager.cxx:1250
 TGeoManager.cxx:1251
 TGeoManager.cxx:1252
 TGeoManager.cxx:1253
 TGeoManager.cxx:1254
 TGeoManager.cxx:1255
 TGeoManager.cxx:1256
 TGeoManager.cxx:1257
 TGeoManager.cxx:1258
 TGeoManager.cxx:1259
 TGeoManager.cxx:1260
 TGeoManager.cxx:1261
 TGeoManager.cxx:1262
 TGeoManager.cxx:1263
 TGeoManager.cxx:1264
 TGeoManager.cxx:1265
 TGeoManager.cxx:1266
 TGeoManager.cxx:1267
 TGeoManager.cxx:1268
 TGeoManager.cxx:1269
 TGeoManager.cxx:1270
 TGeoManager.cxx:1271
 TGeoManager.cxx:1272
 TGeoManager.cxx:1273
 TGeoManager.cxx:1274
 TGeoManager.cxx:1275
 TGeoManager.cxx:1276
 TGeoManager.cxx:1277
 TGeoManager.cxx:1278
 TGeoManager.cxx:1279
 TGeoManager.cxx:1280
 TGeoManager.cxx:1281
 TGeoManager.cxx:1282
 TGeoManager.cxx:1283
 TGeoManager.cxx:1284
 TGeoManager.cxx:1285
 TGeoManager.cxx:1286
 TGeoManager.cxx:1287
 TGeoManager.cxx:1288
 TGeoManager.cxx:1289
 TGeoManager.cxx:1290
 TGeoManager.cxx:1291
 TGeoManager.cxx:1292
 TGeoManager.cxx:1293
 TGeoManager.cxx:1294
 TGeoManager.cxx:1295
 TGeoManager.cxx:1296
 TGeoManager.cxx:1297
 TGeoManager.cxx:1298
 TGeoManager.cxx:1299
 TGeoManager.cxx:1300
 TGeoManager.cxx:1301
 TGeoManager.cxx:1302
 TGeoManager.cxx:1303
 TGeoManager.cxx:1304
 TGeoManager.cxx:1305
 TGeoManager.cxx:1306
 TGeoManager.cxx:1307
 TGeoManager.cxx:1308
 TGeoManager.cxx:1309
 TGeoManager.cxx:1310
 TGeoManager.cxx:1311
 TGeoManager.cxx:1312
 TGeoManager.cxx:1313
 TGeoManager.cxx:1314
 TGeoManager.cxx:1315
 TGeoManager.cxx:1316
 TGeoManager.cxx:1317
 TGeoManager.cxx:1318
 TGeoManager.cxx:1319
 TGeoManager.cxx:1320
 TGeoManager.cxx:1321
 TGeoManager.cxx:1322
 TGeoManager.cxx:1323
 TGeoManager.cxx:1324
 TGeoManager.cxx:1325
 TGeoManager.cxx:1326
 TGeoManager.cxx:1327
 TGeoManager.cxx:1328
 TGeoManager.cxx:1329
 TGeoManager.cxx:1330
 TGeoManager.cxx:1331
 TGeoManager.cxx:1332
 TGeoManager.cxx:1333
 TGeoManager.cxx:1334
 TGeoManager.cxx:1335
 TGeoManager.cxx:1336
 TGeoManager.cxx:1337
 TGeoManager.cxx:1338
 TGeoManager.cxx:1339
 TGeoManager.cxx:1340
 TGeoManager.cxx:1341
 TGeoManager.cxx:1342
 TGeoManager.cxx:1343
 TGeoManager.cxx:1344
 TGeoManager.cxx:1345
 TGeoManager.cxx:1346
 TGeoManager.cxx:1347
 TGeoManager.cxx:1348
 TGeoManager.cxx:1349
 TGeoManager.cxx:1350
 TGeoManager.cxx:1351
 TGeoManager.cxx:1352
 TGeoManager.cxx:1353
 TGeoManager.cxx:1354
 TGeoManager.cxx:1355
 TGeoManager.cxx:1356
 TGeoManager.cxx:1357
 TGeoManager.cxx:1358
 TGeoManager.cxx:1359
 TGeoManager.cxx:1360
 TGeoManager.cxx:1361
 TGeoManager.cxx:1362
 TGeoManager.cxx:1363
 TGeoManager.cxx:1364
 TGeoManager.cxx:1365
 TGeoManager.cxx:1366
 TGeoManager.cxx:1367
 TGeoManager.cxx:1368
 TGeoManager.cxx:1369
 TGeoManager.cxx:1370
 TGeoManager.cxx:1371
 TGeoManager.cxx:1372
 TGeoManager.cxx:1373
 TGeoManager.cxx:1374
 TGeoManager.cxx:1375
 TGeoManager.cxx:1376
 TGeoManager.cxx:1377
 TGeoManager.cxx:1378
 TGeoManager.cxx:1379
 TGeoManager.cxx:1380
 TGeoManager.cxx:1381
 TGeoManager.cxx:1382
 TGeoManager.cxx:1383
 TGeoManager.cxx:1384
 TGeoManager.cxx:1385
 TGeoManager.cxx:1386
 TGeoManager.cxx:1387
 TGeoManager.cxx:1388
 TGeoManager.cxx:1389
 TGeoManager.cxx:1390
 TGeoManager.cxx:1391
 TGeoManager.cxx:1392
 TGeoManager.cxx:1393
 TGeoManager.cxx:1394
 TGeoManager.cxx:1395
 TGeoManager.cxx:1396
 TGeoManager.cxx:1397
 TGeoManager.cxx:1398
 TGeoManager.cxx:1399
 TGeoManager.cxx:1400
 TGeoManager.cxx:1401
 TGeoManager.cxx:1402
 TGeoManager.cxx:1403
 TGeoManager.cxx:1404
 TGeoManager.cxx:1405
 TGeoManager.cxx:1406
 TGeoManager.cxx:1407
 TGeoManager.cxx:1408
 TGeoManager.cxx:1409
 TGeoManager.cxx:1410
 TGeoManager.cxx:1411
 TGeoManager.cxx:1412
 TGeoManager.cxx:1413
 TGeoManager.cxx:1414
 TGeoManager.cxx:1415
 TGeoManager.cxx:1416
 TGeoManager.cxx:1417
 TGeoManager.cxx:1418
 TGeoManager.cxx:1419
 TGeoManager.cxx:1420
 TGeoManager.cxx:1421
 TGeoManager.cxx:1422
 TGeoManager.cxx:1423
 TGeoManager.cxx:1424
 TGeoManager.cxx:1425
 TGeoManager.cxx:1426
 TGeoManager.cxx:1427
 TGeoManager.cxx:1428
 TGeoManager.cxx:1429
 TGeoManager.cxx:1430
 TGeoManager.cxx:1431
 TGeoManager.cxx:1432
 TGeoManager.cxx:1433
 TGeoManager.cxx:1434
 TGeoManager.cxx:1435
 TGeoManager.cxx:1436
 TGeoManager.cxx:1437
 TGeoManager.cxx:1438
 TGeoManager.cxx:1439
 TGeoManager.cxx:1440
 TGeoManager.cxx:1441
 TGeoManager.cxx:1442
 TGeoManager.cxx:1443
 TGeoManager.cxx:1444
 TGeoManager.cxx:1445
 TGeoManager.cxx:1446
 TGeoManager.cxx:1447
 TGeoManager.cxx:1448
 TGeoManager.cxx:1449
 TGeoManager.cxx:1450
 TGeoManager.cxx:1451
 TGeoManager.cxx:1452
 TGeoManager.cxx:1453
 TGeoManager.cxx:1454
 TGeoManager.cxx:1455
 TGeoManager.cxx:1456
 TGeoManager.cxx:1457
 TGeoManager.cxx:1458
 TGeoManager.cxx:1459
 TGeoManager.cxx:1460
 TGeoManager.cxx:1461
 TGeoManager.cxx:1462
 TGeoManager.cxx:1463
 TGeoManager.cxx:1464
 TGeoManager.cxx:1465
 TGeoManager.cxx:1466
 TGeoManager.cxx:1467
 TGeoManager.cxx:1468
 TGeoManager.cxx:1469
 TGeoManager.cxx:1470
 TGeoManager.cxx:1471
 TGeoManager.cxx:1472
 TGeoManager.cxx:1473
 TGeoManager.cxx:1474
 TGeoManager.cxx:1475
 TGeoManager.cxx:1476
 TGeoManager.cxx:1477
 TGeoManager.cxx:1478
 TGeoManager.cxx:1479
 TGeoManager.cxx:1480
 TGeoManager.cxx:1481
 TGeoManager.cxx:1482
 TGeoManager.cxx:1483
 TGeoManager.cxx:1484
 TGeoManager.cxx:1485
 TGeoManager.cxx:1486
 TGeoManager.cxx:1487
 TGeoManager.cxx:1488
 TGeoManager.cxx:1489
 TGeoManager.cxx:1490
 TGeoManager.cxx:1491
 TGeoManager.cxx:1492
 TGeoManager.cxx:1493
 TGeoManager.cxx:1494
 TGeoManager.cxx:1495
 TGeoManager.cxx:1496
 TGeoManager.cxx:1497
 TGeoManager.cxx:1498
 TGeoManager.cxx:1499
 TGeoManager.cxx:1500
 TGeoManager.cxx:1501
 TGeoManager.cxx:1502
 TGeoManager.cxx:1503
 TGeoManager.cxx:1504
 TGeoManager.cxx:1505
 TGeoManager.cxx:1506
 TGeoManager.cxx:1507
 TGeoManager.cxx:1508
 TGeoManager.cxx:1509
 TGeoManager.cxx:1510
 TGeoManager.cxx:1511
 TGeoManager.cxx:1512
 TGeoManager.cxx:1513
 TGeoManager.cxx:1514
 TGeoManager.cxx:1515
 TGeoManager.cxx:1516
 TGeoManager.cxx:1517
 TGeoManager.cxx:1518
 TGeoManager.cxx:1519
 TGeoManager.cxx:1520
 TGeoManager.cxx:1521
 TGeoManager.cxx:1522
 TGeoManager.cxx:1523
 TGeoManager.cxx:1524
 TGeoManager.cxx:1525
 TGeoManager.cxx:1526
 TGeoManager.cxx:1527
 TGeoManager.cxx:1528
 TGeoManager.cxx:1529
 TGeoManager.cxx:1530
 TGeoManager.cxx:1531
 TGeoManager.cxx:1532
 TGeoManager.cxx:1533
 TGeoManager.cxx:1534
 TGeoManager.cxx:1535
 TGeoManager.cxx:1536
 TGeoManager.cxx:1537
 TGeoManager.cxx:1538
 TGeoManager.cxx:1539
 TGeoManager.cxx:1540
 TGeoManager.cxx:1541
 TGeoManager.cxx:1542
 TGeoManager.cxx:1543
 TGeoManager.cxx:1544
 TGeoManager.cxx:1545
 TGeoManager.cxx:1546
 TGeoManager.cxx:1547
 TGeoManager.cxx:1548
 TGeoManager.cxx:1549
 TGeoManager.cxx:1550
 TGeoManager.cxx:1551
 TGeoManager.cxx:1552
 TGeoManager.cxx:1553
 TGeoManager.cxx:1554
 TGeoManager.cxx:1555
 TGeoManager.cxx:1556
 TGeoManager.cxx:1557
 TGeoManager.cxx:1558
 TGeoManager.cxx:1559
 TGeoManager.cxx:1560
 TGeoManager.cxx:1561
 TGeoManager.cxx:1562
 TGeoManager.cxx:1563
 TGeoManager.cxx:1564
 TGeoManager.cxx:1565
 TGeoManager.cxx:1566
 TGeoManager.cxx:1567
 TGeoManager.cxx:1568
 TGeoManager.cxx:1569
 TGeoManager.cxx:1570
 TGeoManager.cxx:1571
 TGeoManager.cxx:1572
 TGeoManager.cxx:1573
 TGeoManager.cxx:1574
 TGeoManager.cxx:1575
 TGeoManager.cxx:1576
 TGeoManager.cxx:1577
 TGeoManager.cxx:1578
 TGeoManager.cxx:1579
 TGeoManager.cxx:1580
 TGeoManager.cxx:1581
 TGeoManager.cxx:1582
 TGeoManager.cxx:1583
 TGeoManager.cxx:1584
 TGeoManager.cxx:1585
 TGeoManager.cxx:1586
 TGeoManager.cxx:1587
 TGeoManager.cxx:1588
 TGeoManager.cxx:1589
 TGeoManager.cxx:1590
 TGeoManager.cxx:1591
 TGeoManager.cxx:1592
 TGeoManager.cxx:1593
 TGeoManager.cxx:1594
 TGeoManager.cxx:1595
 TGeoManager.cxx:1596
 TGeoManager.cxx:1597
 TGeoManager.cxx:1598
 TGeoManager.cxx:1599
 TGeoManager.cxx:1600
 TGeoManager.cxx:1601
 TGeoManager.cxx:1602
 TGeoManager.cxx:1603
 TGeoManager.cxx:1604
 TGeoManager.cxx:1605
 TGeoManager.cxx:1606
 TGeoManager.cxx:1607
 TGeoManager.cxx:1608
 TGeoManager.cxx:1609
 TGeoManager.cxx:1610
 TGeoManager.cxx:1611
 TGeoManager.cxx:1612
 TGeoManager.cxx:1613
 TGeoManager.cxx:1614
 TGeoManager.cxx:1615
 TGeoManager.cxx:1616
 TGeoManager.cxx:1617
 TGeoManager.cxx:1618
 TGeoManager.cxx:1619
 TGeoManager.cxx:1620
 TGeoManager.cxx:1621
 TGeoManager.cxx:1622
 TGeoManager.cxx:1623
 TGeoManager.cxx:1624
 TGeoManager.cxx:1625
 TGeoManager.cxx:1626
 TGeoManager.cxx:1627
 TGeoManager.cxx:1628
 TGeoManager.cxx:1629
 TGeoManager.cxx:1630
 TGeoManager.cxx:1631
 TGeoManager.cxx:1632
 TGeoManager.cxx:1633
 TGeoManager.cxx:1634
 TGeoManager.cxx:1635
 TGeoManager.cxx:1636
 TGeoManager.cxx:1637
 TGeoManager.cxx:1638
 TGeoManager.cxx:1639
 TGeoManager.cxx:1640
 TGeoManager.cxx:1641
 TGeoManager.cxx:1642
 TGeoManager.cxx:1643
 TGeoManager.cxx:1644
 TGeoManager.cxx:1645
 TGeoManager.cxx:1646
 TGeoManager.cxx:1647
 TGeoManager.cxx:1648
 TGeoManager.cxx:1649
 TGeoManager.cxx:1650
 TGeoManager.cxx:1651
 TGeoManager.cxx:1652
 TGeoManager.cxx:1653
 TGeoManager.cxx:1654
 TGeoManager.cxx:1655
 TGeoManager.cxx:1656
 TGeoManager.cxx:1657
 TGeoManager.cxx:1658
 TGeoManager.cxx:1659
 TGeoManager.cxx:1660
 TGeoManager.cxx:1661
 TGeoManager.cxx:1662
 TGeoManager.cxx:1663
 TGeoManager.cxx:1664
 TGeoManager.cxx:1665
 TGeoManager.cxx:1666
 TGeoManager.cxx:1667
 TGeoManager.cxx:1668
 TGeoManager.cxx:1669
 TGeoManager.cxx:1670
 TGeoManager.cxx:1671
 TGeoManager.cxx:1672
 TGeoManager.cxx:1673
 TGeoManager.cxx:1674
 TGeoManager.cxx:1675
 TGeoManager.cxx:1676
 TGeoManager.cxx:1677
 TGeoManager.cxx:1678
 TGeoManager.cxx:1679
 TGeoManager.cxx:1680
 TGeoManager.cxx:1681
 TGeoManager.cxx:1682
 TGeoManager.cxx:1683
 TGeoManager.cxx:1684
 TGeoManager.cxx:1685
 TGeoManager.cxx:1686
 TGeoManager.cxx:1687
 TGeoManager.cxx:1688
 TGeoManager.cxx:1689
 TGeoManager.cxx:1690
 TGeoManager.cxx:1691
 TGeoManager.cxx:1692
 TGeoManager.cxx:1693
 TGeoManager.cxx:1694
 TGeoManager.cxx:1695
 TGeoManager.cxx:1696
 TGeoManager.cxx:1697
 TGeoManager.cxx:1698
 TGeoManager.cxx:1699
 TGeoManager.cxx:1700
 TGeoManager.cxx:1701
 TGeoManager.cxx:1702
 TGeoManager.cxx:1703
 TGeoManager.cxx:1704
 TGeoManager.cxx:1705
 TGeoManager.cxx:1706
 TGeoManager.cxx:1707
 TGeoManager.cxx:1708
 TGeoManager.cxx:1709
 TGeoManager.cxx:1710
 TGeoManager.cxx:1711
 TGeoManager.cxx:1712
 TGeoManager.cxx:1713
 TGeoManager.cxx:1714
 TGeoManager.cxx:1715
 TGeoManager.cxx:1716
 TGeoManager.cxx:1717
 TGeoManager.cxx:1718
 TGeoManager.cxx:1719
 TGeoManager.cxx:1720
 TGeoManager.cxx:1721
 TGeoManager.cxx:1722
 TGeoManager.cxx:1723
 TGeoManager.cxx:1724
 TGeoManager.cxx:1725
 TGeoManager.cxx:1726
 TGeoManager.cxx:1727
 TGeoManager.cxx:1728
 TGeoManager.cxx:1729
 TGeoManager.cxx:1730
 TGeoManager.cxx:1731
 TGeoManager.cxx:1732
 TGeoManager.cxx:1733
 TGeoManager.cxx:1734
 TGeoManager.cxx:1735
 TGeoManager.cxx:1736
 TGeoManager.cxx:1737
 TGeoManager.cxx:1738
 TGeoManager.cxx:1739
 TGeoManager.cxx:1740
 TGeoManager.cxx:1741
 TGeoManager.cxx:1742
 TGeoManager.cxx:1743
 TGeoManager.cxx:1744
 TGeoManager.cxx:1745
 TGeoManager.cxx:1746
 TGeoManager.cxx:1747
 TGeoManager.cxx:1748
 TGeoManager.cxx:1749
 TGeoManager.cxx:1750
 TGeoManager.cxx:1751
 TGeoManager.cxx:1752
 TGeoManager.cxx:1753
 TGeoManager.cxx:1754
 TGeoManager.cxx:1755
 TGeoManager.cxx:1756
 TGeoManager.cxx:1757
 TGeoManager.cxx:1758
 TGeoManager.cxx:1759
 TGeoManager.cxx:1760
 TGeoManager.cxx:1761
 TGeoManager.cxx:1762
 TGeoManager.cxx:1763
 TGeoManager.cxx:1764
 TGeoManager.cxx:1765
 TGeoManager.cxx:1766
 TGeoManager.cxx:1767
 TGeoManager.cxx:1768
 TGeoManager.cxx:1769
 TGeoManager.cxx:1770
 TGeoManager.cxx:1771
 TGeoManager.cxx:1772
 TGeoManager.cxx:1773
 TGeoManager.cxx:1774
 TGeoManager.cxx:1775
 TGeoManager.cxx:1776
 TGeoManager.cxx:1777
 TGeoManager.cxx:1778
 TGeoManager.cxx:1779
 TGeoManager.cxx:1780
 TGeoManager.cxx:1781
 TGeoManager.cxx:1782
 TGeoManager.cxx:1783
 TGeoManager.cxx:1784
 TGeoManager.cxx:1785
 TGeoManager.cxx:1786
 TGeoManager.cxx:1787
 TGeoManager.cxx:1788
 TGeoManager.cxx:1789
 TGeoManager.cxx:1790
 TGeoManager.cxx:1791
 TGeoManager.cxx:1792
 TGeoManager.cxx:1793
 TGeoManager.cxx:1794
 TGeoManager.cxx:1795
 TGeoManager.cxx:1796
 TGeoManager.cxx:1797
 TGeoManager.cxx:1798
 TGeoManager.cxx:1799
 TGeoManager.cxx:1800
 TGeoManager.cxx:1801
 TGeoManager.cxx:1802
 TGeoManager.cxx:1803
 TGeoManager.cxx:1804
 TGeoManager.cxx:1805
 TGeoManager.cxx:1806
 TGeoManager.cxx:1807
 TGeoManager.cxx:1808
 TGeoManager.cxx:1809
 TGeoManager.cxx:1810
 TGeoManager.cxx:1811
 TGeoManager.cxx:1812
 TGeoManager.cxx:1813
 TGeoManager.cxx:1814
 TGeoManager.cxx:1815
 TGeoManager.cxx:1816
 TGeoManager.cxx:1817
 TGeoManager.cxx:1818
 TGeoManager.cxx:1819
 TGeoManager.cxx:1820
 TGeoManager.cxx:1821
 TGeoManager.cxx:1822
 TGeoManager.cxx:1823
 TGeoManager.cxx:1824
 TGeoManager.cxx:1825
 TGeoManager.cxx:1826
 TGeoManager.cxx:1827
 TGeoManager.cxx:1828
 TGeoManager.cxx:1829
 TGeoManager.cxx:1830
 TGeoManager.cxx:1831
 TGeoManager.cxx:1832
 TGeoManager.cxx:1833
 TGeoManager.cxx:1834
 TGeoManager.cxx:1835
 TGeoManager.cxx:1836
 TGeoManager.cxx:1837
 TGeoManager.cxx:1838
 TGeoManager.cxx:1839
 TGeoManager.cxx:1840
 TGeoManager.cxx:1841
 TGeoManager.cxx:1842
 TGeoManager.cxx:1843
 TGeoManager.cxx:1844
 TGeoManager.cxx:1845
 TGeoManager.cxx:1846
 TGeoManager.cxx:1847
 TGeoManager.cxx:1848
 TGeoManager.cxx:1849
 TGeoManager.cxx:1850
 TGeoManager.cxx:1851
 TGeoManager.cxx:1852
 TGeoManager.cxx:1853
 TGeoManager.cxx:1854
 TGeoManager.cxx:1855
 TGeoManager.cxx:1856
 TGeoManager.cxx:1857
 TGeoManager.cxx:1858
 TGeoManager.cxx:1859
 TGeoManager.cxx:1860
 TGeoManager.cxx:1861
 TGeoManager.cxx:1862
 TGeoManager.cxx:1863
 TGeoManager.cxx:1864
 TGeoManager.cxx:1865
 TGeoManager.cxx:1866
 TGeoManager.cxx:1867
 TGeoManager.cxx:1868
 TGeoManager.cxx:1869
 TGeoManager.cxx:1870
 TGeoManager.cxx:1871
 TGeoManager.cxx:1872
 TGeoManager.cxx:1873
 TGeoManager.cxx:1874
 TGeoManager.cxx:1875
 TGeoManager.cxx:1876
 TGeoManager.cxx:1877
 TGeoManager.cxx:1878
 TGeoManager.cxx:1879
 TGeoManager.cxx:1880
 TGeoManager.cxx:1881
 TGeoManager.cxx:1882
 TGeoManager.cxx:1883
 TGeoManager.cxx:1884
 TGeoManager.cxx:1885
 TGeoManager.cxx:1886
 TGeoManager.cxx:1887
 TGeoManager.cxx:1888
 TGeoManager.cxx:1889
 TGeoManager.cxx:1890
 TGeoManager.cxx:1891
 TGeoManager.cxx:1892
 TGeoManager.cxx:1893
 TGeoManager.cxx:1894
 TGeoManager.cxx:1895
 TGeoManager.cxx:1896
 TGeoManager.cxx:1897
 TGeoManager.cxx:1898
 TGeoManager.cxx:1899
 TGeoManager.cxx:1900
 TGeoManager.cxx:1901
 TGeoManager.cxx:1902
 TGeoManager.cxx:1903
 TGeoManager.cxx:1904
 TGeoManager.cxx:1905
 TGeoManager.cxx:1906
 TGeoManager.cxx:1907
 TGeoManager.cxx:1908
 TGeoManager.cxx:1909
 TGeoManager.cxx:1910
 TGeoManager.cxx:1911
 TGeoManager.cxx:1912
 TGeoManager.cxx:1913
 TGeoManager.cxx:1914
 TGeoManager.cxx:1915
 TGeoManager.cxx:1916
 TGeoManager.cxx:1917
 TGeoManager.cxx:1918
 TGeoManager.cxx:1919
 TGeoManager.cxx:1920
 TGeoManager.cxx:1921
 TGeoManager.cxx:1922
 TGeoManager.cxx:1923
 TGeoManager.cxx:1924
 TGeoManager.cxx:1925
 TGeoManager.cxx:1926
 TGeoManager.cxx:1927
 TGeoManager.cxx:1928
 TGeoManager.cxx:1929
 TGeoManager.cxx:1930
 TGeoManager.cxx:1931
 TGeoManager.cxx:1932
 TGeoManager.cxx:1933
 TGeoManager.cxx:1934
 TGeoManager.cxx:1935
 TGeoManager.cxx:1936
 TGeoManager.cxx:1937
 TGeoManager.cxx:1938
 TGeoManager.cxx:1939
 TGeoManager.cxx:1940
 TGeoManager.cxx:1941
 TGeoManager.cxx:1942
 TGeoManager.cxx:1943
 TGeoManager.cxx:1944
 TGeoManager.cxx:1945
 TGeoManager.cxx:1946
 TGeoManager.cxx:1947
 TGeoManager.cxx:1948
 TGeoManager.cxx:1949
 TGeoManager.cxx:1950
 TGeoManager.cxx:1951
 TGeoManager.cxx:1952
 TGeoManager.cxx:1953
 TGeoManager.cxx:1954
 TGeoManager.cxx:1955
 TGeoManager.cxx:1956
 TGeoManager.cxx:1957
 TGeoManager.cxx:1958
 TGeoManager.cxx:1959
 TGeoManager.cxx:1960
 TGeoManager.cxx:1961
 TGeoManager.cxx:1962
 TGeoManager.cxx:1963
 TGeoManager.cxx:1964
 TGeoManager.cxx:1965
 TGeoManager.cxx:1966
 TGeoManager.cxx:1967
 TGeoManager.cxx:1968
 TGeoManager.cxx:1969
 TGeoManager.cxx:1970
 TGeoManager.cxx:1971
 TGeoManager.cxx:1972
 TGeoManager.cxx:1973
 TGeoManager.cxx:1974
 TGeoManager.cxx:1975
 TGeoManager.cxx:1976
 TGeoManager.cxx:1977
 TGeoManager.cxx:1978
 TGeoManager.cxx:1979
 TGeoManager.cxx:1980
 TGeoManager.cxx:1981
 TGeoManager.cxx:1982
 TGeoManager.cxx:1983
 TGeoManager.cxx:1984
 TGeoManager.cxx:1985
 TGeoManager.cxx:1986
 TGeoManager.cxx:1987
 TGeoManager.cxx:1988
 TGeoManager.cxx:1989
 TGeoManager.cxx:1990
 TGeoManager.cxx:1991
 TGeoManager.cxx:1992
 TGeoManager.cxx:1993
 TGeoManager.cxx:1994
 TGeoManager.cxx:1995
 TGeoManager.cxx:1996
 TGeoManager.cxx:1997
 TGeoManager.cxx:1998
 TGeoManager.cxx:1999
 TGeoManager.cxx:2000
 TGeoManager.cxx:2001
 TGeoManager.cxx:2002
 TGeoManager.cxx:2003
 TGeoManager.cxx:2004
 TGeoManager.cxx:2005
 TGeoManager.cxx:2006
 TGeoManager.cxx:2007
 TGeoManager.cxx:2008
 TGeoManager.cxx:2009
 TGeoManager.cxx:2010
 TGeoManager.cxx:2011
 TGeoManager.cxx:2012
 TGeoManager.cxx:2013
 TGeoManager.cxx:2014
 TGeoManager.cxx:2015
 TGeoManager.cxx:2016
 TGeoManager.cxx:2017
 TGeoManager.cxx:2018
 TGeoManager.cxx:2019
 TGeoManager.cxx:2020
 TGeoManager.cxx:2021
 TGeoManager.cxx:2022
 TGeoManager.cxx:2023
 TGeoManager.cxx:2024
 TGeoManager.cxx:2025
 TGeoManager.cxx:2026
 TGeoManager.cxx:2027
 TGeoManager.cxx:2028
 TGeoManager.cxx:2029
 TGeoManager.cxx:2030
 TGeoManager.cxx:2031
 TGeoManager.cxx:2032
 TGeoManager.cxx:2033
 TGeoManager.cxx:2034
 TGeoManager.cxx:2035
 TGeoManager.cxx:2036
 TGeoManager.cxx:2037
 TGeoManager.cxx:2038
 TGeoManager.cxx:2039
 TGeoManager.cxx:2040
 TGeoManager.cxx:2041
 TGeoManager.cxx:2042
 TGeoManager.cxx:2043
 TGeoManager.cxx:2044
 TGeoManager.cxx:2045
 TGeoManager.cxx:2046
 TGeoManager.cxx:2047
 TGeoManager.cxx:2048
 TGeoManager.cxx:2049
 TGeoManager.cxx:2050
 TGeoManager.cxx:2051
 TGeoManager.cxx:2052
 TGeoManager.cxx:2053
 TGeoManager.cxx:2054
 TGeoManager.cxx:2055
 TGeoManager.cxx:2056
 TGeoManager.cxx:2057
 TGeoManager.cxx:2058
 TGeoManager.cxx:2059
 TGeoManager.cxx:2060
 TGeoManager.cxx:2061
 TGeoManager.cxx:2062
 TGeoManager.cxx:2063
 TGeoManager.cxx:2064
 TGeoManager.cxx:2065
 TGeoManager.cxx:2066
 TGeoManager.cxx:2067
 TGeoManager.cxx:2068
 TGeoManager.cxx:2069
 TGeoManager.cxx:2070
 TGeoManager.cxx:2071
 TGeoManager.cxx:2072
 TGeoManager.cxx:2073
 TGeoManager.cxx:2074
 TGeoManager.cxx:2075
 TGeoManager.cxx:2076
 TGeoManager.cxx:2077
 TGeoManager.cxx:2078
 TGeoManager.cxx:2079
 TGeoManager.cxx:2080
 TGeoManager.cxx:2081
 TGeoManager.cxx:2082
 TGeoManager.cxx:2083
 TGeoManager.cxx:2084
 TGeoManager.cxx:2085
 TGeoManager.cxx:2086
 TGeoManager.cxx:2087
 TGeoManager.cxx:2088
 TGeoManager.cxx:2089
 TGeoManager.cxx:2090
 TGeoManager.cxx:2091
 TGeoManager.cxx:2092
 TGeoManager.cxx:2093
 TGeoManager.cxx:2094
 TGeoManager.cxx:2095
 TGeoManager.cxx:2096
 TGeoManager.cxx:2097
 TGeoManager.cxx:2098
 TGeoManager.cxx:2099
 TGeoManager.cxx:2100
 TGeoManager.cxx:2101
 TGeoManager.cxx:2102
 TGeoManager.cxx:2103
 TGeoManager.cxx:2104
 TGeoManager.cxx:2105
 TGeoManager.cxx:2106
 TGeoManager.cxx:2107
 TGeoManager.cxx:2108
 TGeoManager.cxx:2109
 TGeoManager.cxx:2110
 TGeoManager.cxx:2111
 TGeoManager.cxx:2112
 TGeoManager.cxx:2113
 TGeoManager.cxx:2114
 TGeoManager.cxx:2115
 TGeoManager.cxx:2116
 TGeoManager.cxx:2117
 TGeoManager.cxx:2118
 TGeoManager.cxx:2119
 TGeoManager.cxx:2120
 TGeoManager.cxx:2121
 TGeoManager.cxx:2122
 TGeoManager.cxx:2123
 TGeoManager.cxx:2124
 TGeoManager.cxx:2125
 TGeoManager.cxx:2126
 TGeoManager.cxx:2127
 TGeoManager.cxx:2128
 TGeoManager.cxx:2129
 TGeoManager.cxx:2130
 TGeoManager.cxx:2131
 TGeoManager.cxx:2132
 TGeoManager.cxx:2133
 TGeoManager.cxx:2134
 TGeoManager.cxx:2135
 TGeoManager.cxx:2136
 TGeoManager.cxx:2137
 TGeoManager.cxx:2138
 TGeoManager.cxx:2139
 TGeoManager.cxx:2140
 TGeoManager.cxx:2141
 TGeoManager.cxx:2142
 TGeoManager.cxx:2143
 TGeoManager.cxx:2144
 TGeoManager.cxx:2145
 TGeoManager.cxx:2146
 TGeoManager.cxx:2147
 TGeoManager.cxx:2148
 TGeoManager.cxx:2149
 TGeoManager.cxx:2150
 TGeoManager.cxx:2151
 TGeoManager.cxx:2152
 TGeoManager.cxx:2153
 TGeoManager.cxx:2154
 TGeoManager.cxx:2155
 TGeoManager.cxx:2156
 TGeoManager.cxx:2157
 TGeoManager.cxx:2158
 TGeoManager.cxx:2159
 TGeoManager.cxx:2160
 TGeoManager.cxx:2161
 TGeoManager.cxx:2162
 TGeoManager.cxx:2163
 TGeoManager.cxx:2164
 TGeoManager.cxx:2165
 TGeoManager.cxx:2166
 TGeoManager.cxx:2167
 TGeoManager.cxx:2168
 TGeoManager.cxx:2169
 TGeoManager.cxx:2170
 TGeoManager.cxx:2171
 TGeoManager.cxx:2172
 TGeoManager.cxx:2173
 TGeoManager.cxx:2174
 TGeoManager.cxx:2175
 TGeoManager.cxx:2176
 TGeoManager.cxx:2177
 TGeoManager.cxx:2178
 TGeoManager.cxx:2179
 TGeoManager.cxx:2180
 TGeoManager.cxx:2181
 TGeoManager.cxx:2182
 TGeoManager.cxx:2183
 TGeoManager.cxx:2184
 TGeoManager.cxx:2185
 TGeoManager.cxx:2186
 TGeoManager.cxx:2187
 TGeoManager.cxx:2188
 TGeoManager.cxx:2189
 TGeoManager.cxx:2190
 TGeoManager.cxx:2191
 TGeoManager.cxx:2192
 TGeoManager.cxx:2193
 TGeoManager.cxx:2194
 TGeoManager.cxx:2195
 TGeoManager.cxx:2196
 TGeoManager.cxx:2197
 TGeoManager.cxx:2198
 TGeoManager.cxx:2199
 TGeoManager.cxx:2200
 TGeoManager.cxx:2201
 TGeoManager.cxx:2202
 TGeoManager.cxx:2203
 TGeoManager.cxx:2204
 TGeoManager.cxx:2205
 TGeoManager.cxx:2206
 TGeoManager.cxx:2207
 TGeoManager.cxx:2208
 TGeoManager.cxx:2209
 TGeoManager.cxx:2210
 TGeoManager.cxx:2211
 TGeoManager.cxx:2212
 TGeoManager.cxx:2213
 TGeoManager.cxx:2214
 TGeoManager.cxx:2215
 TGeoManager.cxx:2216
 TGeoManager.cxx:2217
 TGeoManager.cxx:2218
 TGeoManager.cxx:2219
 TGeoManager.cxx:2220
 TGeoManager.cxx:2221
 TGeoManager.cxx:2222
 TGeoManager.cxx:2223
 TGeoManager.cxx:2224
 TGeoManager.cxx:2225
 TGeoManager.cxx:2226
 TGeoManager.cxx:2227
 TGeoManager.cxx:2228
 TGeoManager.cxx:2229
 TGeoManager.cxx:2230
 TGeoManager.cxx:2231
 TGeoManager.cxx:2232
 TGeoManager.cxx:2233
 TGeoManager.cxx:2234
 TGeoManager.cxx:2235
 TGeoManager.cxx:2236
 TGeoManager.cxx:2237
 TGeoManager.cxx:2238
 TGeoManager.cxx:2239
 TGeoManager.cxx:2240
 TGeoManager.cxx:2241
 TGeoManager.cxx:2242
 TGeoManager.cxx:2243
 TGeoManager.cxx:2244
 TGeoManager.cxx:2245
 TGeoManager.cxx:2246
 TGeoManager.cxx:2247
 TGeoManager.cxx:2248
 TGeoManager.cxx:2249
 TGeoManager.cxx:2250
 TGeoManager.cxx:2251
 TGeoManager.cxx:2252
 TGeoManager.cxx:2253
 TGeoManager.cxx:2254
 TGeoManager.cxx:2255
 TGeoManager.cxx:2256
 TGeoManager.cxx:2257
 TGeoManager.cxx:2258
 TGeoManager.cxx:2259
 TGeoManager.cxx:2260
 TGeoManager.cxx:2261
 TGeoManager.cxx:2262
 TGeoManager.cxx:2263
 TGeoManager.cxx:2264
 TGeoManager.cxx:2265
 TGeoManager.cxx:2266
 TGeoManager.cxx:2267
 TGeoManager.cxx:2268
 TGeoManager.cxx:2269
 TGeoManager.cxx:2270
 TGeoManager.cxx:2271
 TGeoManager.cxx:2272
 TGeoManager.cxx:2273
 TGeoManager.cxx:2274
 TGeoManager.cxx:2275
 TGeoManager.cxx:2276
 TGeoManager.cxx:2277
 TGeoManager.cxx:2278
 TGeoManager.cxx:2279
 TGeoManager.cxx:2280
 TGeoManager.cxx:2281
 TGeoManager.cxx:2282
 TGeoManager.cxx:2283
 TGeoManager.cxx:2284
 TGeoManager.cxx:2285
 TGeoManager.cxx:2286
 TGeoManager.cxx:2287
 TGeoManager.cxx:2288
 TGeoManager.cxx:2289
 TGeoManager.cxx:2290
 TGeoManager.cxx:2291
 TGeoManager.cxx:2292
 TGeoManager.cxx:2293
 TGeoManager.cxx:2294
 TGeoManager.cxx:2295
 TGeoManager.cxx:2296
 TGeoManager.cxx:2297
 TGeoManager.cxx:2298
 TGeoManager.cxx:2299
 TGeoManager.cxx:2300
 TGeoManager.cxx:2301
 TGeoManager.cxx:2302
 TGeoManager.cxx:2303
 TGeoManager.cxx:2304
 TGeoManager.cxx:2305
 TGeoManager.cxx:2306
 TGeoManager.cxx:2307
 TGeoManager.cxx:2308
 TGeoManager.cxx:2309
 TGeoManager.cxx:2310
 TGeoManager.cxx:2311
 TGeoManager.cxx:2312
 TGeoManager.cxx:2313
 TGeoManager.cxx:2314
 TGeoManager.cxx:2315
 TGeoManager.cxx:2316
 TGeoManager.cxx:2317
 TGeoManager.cxx:2318
 TGeoManager.cxx:2319
 TGeoManager.cxx:2320
 TGeoManager.cxx:2321
 TGeoManager.cxx:2322
 TGeoManager.cxx:2323
 TGeoManager.cxx:2324
 TGeoManager.cxx:2325
 TGeoManager.cxx:2326
 TGeoManager.cxx:2327
 TGeoManager.cxx:2328
 TGeoManager.cxx:2329
 TGeoManager.cxx:2330
 TGeoManager.cxx:2331
 TGeoManager.cxx:2332
 TGeoManager.cxx:2333
 TGeoManager.cxx:2334
 TGeoManager.cxx:2335
 TGeoManager.cxx:2336
 TGeoManager.cxx:2337
 TGeoManager.cxx:2338
 TGeoManager.cxx:2339
 TGeoManager.cxx:2340
 TGeoManager.cxx:2341
 TGeoManager.cxx:2342
 TGeoManager.cxx:2343
 TGeoManager.cxx:2344
 TGeoManager.cxx:2345
 TGeoManager.cxx:2346
 TGeoManager.cxx:2347
 TGeoManager.cxx:2348
 TGeoManager.cxx:2349
 TGeoManager.cxx:2350
 TGeoManager.cxx:2351
 TGeoManager.cxx:2352
 TGeoManager.cxx:2353
 TGeoManager.cxx:2354
 TGeoManager.cxx:2355
 TGeoManager.cxx:2356
 TGeoManager.cxx:2357
 TGeoManager.cxx:2358
 TGeoManager.cxx:2359
 TGeoManager.cxx:2360
 TGeoManager.cxx:2361
 TGeoManager.cxx:2362
 TGeoManager.cxx:2363
 TGeoManager.cxx:2364
 TGeoManager.cxx:2365
 TGeoManager.cxx:2366
 TGeoManager.cxx:2367
 TGeoManager.cxx:2368
 TGeoManager.cxx:2369
 TGeoManager.cxx:2370
 TGeoManager.cxx:2371
 TGeoManager.cxx:2372
 TGeoManager.cxx:2373
 TGeoManager.cxx:2374
 TGeoManager.cxx:2375
 TGeoManager.cxx:2376
 TGeoManager.cxx:2377
 TGeoManager.cxx:2378
 TGeoManager.cxx:2379
 TGeoManager.cxx:2380
 TGeoManager.cxx:2381
 TGeoManager.cxx:2382
 TGeoManager.cxx:2383
 TGeoManager.cxx:2384
 TGeoManager.cxx:2385
 TGeoManager.cxx:2386
 TGeoManager.cxx:2387
 TGeoManager.cxx:2388
 TGeoManager.cxx:2389
 TGeoManager.cxx:2390
 TGeoManager.cxx:2391
 TGeoManager.cxx:2392
 TGeoManager.cxx:2393
 TGeoManager.cxx:2394
 TGeoManager.cxx:2395
 TGeoManager.cxx:2396
 TGeoManager.cxx:2397
 TGeoManager.cxx:2398
 TGeoManager.cxx:2399
 TGeoManager.cxx:2400
 TGeoManager.cxx:2401
 TGeoManager.cxx:2402
 TGeoManager.cxx:2403
 TGeoManager.cxx:2404
 TGeoManager.cxx:2405
 TGeoManager.cxx:2406
 TGeoManager.cxx:2407
 TGeoManager.cxx:2408
 TGeoManager.cxx:2409
 TGeoManager.cxx:2410
 TGeoManager.cxx:2411
 TGeoManager.cxx:2412
 TGeoManager.cxx:2413
 TGeoManager.cxx:2414
 TGeoManager.cxx:2415
 TGeoManager.cxx:2416
 TGeoManager.cxx:2417
 TGeoManager.cxx:2418
 TGeoManager.cxx:2419
 TGeoManager.cxx:2420
 TGeoManager.cxx:2421
 TGeoManager.cxx:2422
 TGeoManager.cxx:2423
 TGeoManager.cxx:2424
 TGeoManager.cxx:2425
 TGeoManager.cxx:2426
 TGeoManager.cxx:2427
 TGeoManager.cxx:2428
 TGeoManager.cxx:2429
 TGeoManager.cxx:2430
 TGeoManager.cxx:2431
 TGeoManager.cxx:2432
 TGeoManager.cxx:2433
 TGeoManager.cxx:2434
 TGeoManager.cxx:2435
 TGeoManager.cxx:2436
 TGeoManager.cxx:2437
 TGeoManager.cxx:2438
 TGeoManager.cxx:2439
 TGeoManager.cxx:2440
 TGeoManager.cxx:2441
 TGeoManager.cxx:2442
 TGeoManager.cxx:2443
 TGeoManager.cxx:2444
 TGeoManager.cxx:2445
 TGeoManager.cxx:2446
 TGeoManager.cxx:2447
 TGeoManager.cxx:2448
 TGeoManager.cxx:2449
 TGeoManager.cxx:2450
 TGeoManager.cxx:2451
 TGeoManager.cxx:2452
 TGeoManager.cxx:2453
 TGeoManager.cxx:2454
 TGeoManager.cxx:2455
 TGeoManager.cxx:2456
 TGeoManager.cxx:2457
 TGeoManager.cxx:2458
 TGeoManager.cxx:2459
 TGeoManager.cxx:2460
 TGeoManager.cxx:2461
 TGeoManager.cxx:2462
 TGeoManager.cxx:2463
 TGeoManager.cxx:2464
 TGeoManager.cxx:2465
 TGeoManager.cxx:2466
 TGeoManager.cxx:2467
 TGeoManager.cxx:2468
 TGeoManager.cxx:2469
 TGeoManager.cxx:2470
 TGeoManager.cxx:2471
 TGeoManager.cxx:2472
 TGeoManager.cxx:2473
 TGeoManager.cxx:2474
 TGeoManager.cxx:2475
 TGeoManager.cxx:2476
 TGeoManager.cxx:2477
 TGeoManager.cxx:2478
 TGeoManager.cxx:2479
 TGeoManager.cxx:2480
 TGeoManager.cxx:2481
 TGeoManager.cxx:2482
 TGeoManager.cxx:2483
 TGeoManager.cxx:2484
 TGeoManager.cxx:2485
 TGeoManager.cxx:2486
 TGeoManager.cxx:2487
 TGeoManager.cxx:2488
 TGeoManager.cxx:2489
 TGeoManager.cxx:2490
 TGeoManager.cxx:2491
 TGeoManager.cxx:2492
 TGeoManager.cxx:2493
 TGeoManager.cxx:2494
 TGeoManager.cxx:2495
 TGeoManager.cxx:2496
 TGeoManager.cxx:2497
 TGeoManager.cxx:2498
 TGeoManager.cxx:2499
 TGeoManager.cxx:2500
 TGeoManager.cxx:2501
 TGeoManager.cxx:2502
 TGeoManager.cxx:2503
 TGeoManager.cxx:2504
 TGeoManager.cxx:2505
 TGeoManager.cxx:2506
 TGeoManager.cxx:2507
 TGeoManager.cxx:2508
 TGeoManager.cxx:2509
 TGeoManager.cxx:2510
 TGeoManager.cxx:2511
 TGeoManager.cxx:2512
 TGeoManager.cxx:2513
 TGeoManager.cxx:2514
 TGeoManager.cxx:2515
 TGeoManager.cxx:2516
 TGeoManager.cxx:2517
 TGeoManager.cxx:2518
 TGeoManager.cxx:2519
 TGeoManager.cxx:2520
 TGeoManager.cxx:2521
 TGeoManager.cxx:2522
 TGeoManager.cxx:2523
 TGeoManager.cxx:2524
 TGeoManager.cxx:2525
 TGeoManager.cxx:2526
 TGeoManager.cxx:2527
 TGeoManager.cxx:2528
 TGeoManager.cxx:2529
 TGeoManager.cxx:2530
 TGeoManager.cxx:2531
 TGeoManager.cxx:2532
 TGeoManager.cxx:2533
 TGeoManager.cxx:2534
 TGeoManager.cxx:2535
 TGeoManager.cxx:2536
 TGeoManager.cxx:2537
 TGeoManager.cxx:2538
 TGeoManager.cxx:2539
 TGeoManager.cxx:2540
 TGeoManager.cxx:2541
 TGeoManager.cxx:2542
 TGeoManager.cxx:2543
 TGeoManager.cxx:2544
 TGeoManager.cxx:2545
 TGeoManager.cxx:2546
 TGeoManager.cxx:2547
 TGeoManager.cxx:2548
 TGeoManager.cxx:2549
 TGeoManager.cxx:2550
 TGeoManager.cxx:2551
 TGeoManager.cxx:2552
 TGeoManager.cxx:2553
 TGeoManager.cxx:2554
 TGeoManager.cxx:2555
 TGeoManager.cxx:2556
 TGeoManager.cxx:2557
 TGeoManager.cxx:2558
 TGeoManager.cxx:2559
 TGeoManager.cxx:2560
 TGeoManager.cxx:2561
 TGeoManager.cxx:2562
 TGeoManager.cxx:2563
 TGeoManager.cxx:2564
 TGeoManager.cxx:2565
 TGeoManager.cxx:2566
 TGeoManager.cxx:2567
 TGeoManager.cxx:2568
 TGeoManager.cxx:2569
 TGeoManager.cxx:2570
 TGeoManager.cxx:2571
 TGeoManager.cxx:2572
 TGeoManager.cxx:2573
 TGeoManager.cxx:2574
 TGeoManager.cxx:2575
 TGeoManager.cxx:2576
 TGeoManager.cxx:2577
 TGeoManager.cxx:2578
 TGeoManager.cxx:2579
 TGeoManager.cxx:2580
 TGeoManager.cxx:2581
 TGeoManager.cxx:2582
 TGeoManager.cxx:2583
 TGeoManager.cxx:2584
 TGeoManager.cxx:2585
 TGeoManager.cxx:2586
 TGeoManager.cxx:2587
 TGeoManager.cxx:2588
 TGeoManager.cxx:2589
 TGeoManager.cxx:2590
 TGeoManager.cxx:2591
 TGeoManager.cxx:2592
 TGeoManager.cxx:2593
 TGeoManager.cxx:2594
 TGeoManager.cxx:2595
 TGeoManager.cxx:2596
 TGeoManager.cxx:2597
 TGeoManager.cxx:2598
 TGeoManager.cxx:2599
 TGeoManager.cxx:2600
 TGeoManager.cxx:2601
 TGeoManager.cxx:2602
 TGeoManager.cxx:2603
 TGeoManager.cxx:2604
 TGeoManager.cxx:2605
 TGeoManager.cxx:2606
 TGeoManager.cxx:2607
 TGeoManager.cxx:2608
 TGeoManager.cxx:2609
 TGeoManager.cxx:2610
 TGeoManager.cxx:2611
 TGeoManager.cxx:2612
 TGeoManager.cxx:2613
 TGeoManager.cxx:2614
 TGeoManager.cxx:2615
 TGeoManager.cxx:2616
 TGeoManager.cxx:2617
 TGeoManager.cxx:2618
 TGeoManager.cxx:2619
 TGeoManager.cxx:2620
 TGeoManager.cxx:2621
 TGeoManager.cxx:2622
 TGeoManager.cxx:2623
 TGeoManager.cxx:2624
 TGeoManager.cxx:2625
 TGeoManager.cxx:2626
 TGeoManager.cxx:2627
 TGeoManager.cxx:2628
 TGeoManager.cxx:2629
 TGeoManager.cxx:2630
 TGeoManager.cxx:2631
 TGeoManager.cxx:2632
 TGeoManager.cxx:2633
 TGeoManager.cxx:2634
 TGeoManager.cxx:2635
 TGeoManager.cxx:2636
 TGeoManager.cxx:2637
 TGeoManager.cxx:2638
 TGeoManager.cxx:2639
 TGeoManager.cxx:2640
 TGeoManager.cxx:2641
 TGeoManager.cxx:2642
 TGeoManager.cxx:2643
 TGeoManager.cxx:2644
 TGeoManager.cxx:2645
 TGeoManager.cxx:2646
 TGeoManager.cxx:2647
 TGeoManager.cxx:2648
 TGeoManager.cxx:2649
 TGeoManager.cxx:2650
 TGeoManager.cxx:2651
 TGeoManager.cxx:2652
 TGeoManager.cxx:2653
 TGeoManager.cxx:2654
 TGeoManager.cxx:2655
 TGeoManager.cxx:2656
 TGeoManager.cxx:2657
 TGeoManager.cxx:2658
 TGeoManager.cxx:2659
 TGeoManager.cxx:2660
 TGeoManager.cxx:2661
 TGeoManager.cxx:2662
 TGeoManager.cxx:2663
 TGeoManager.cxx:2664
 TGeoManager.cxx:2665
 TGeoManager.cxx:2666
 TGeoManager.cxx:2667
 TGeoManager.cxx:2668
 TGeoManager.cxx:2669
 TGeoManager.cxx:2670
 TGeoManager.cxx:2671
 TGeoManager.cxx:2672
 TGeoManager.cxx:2673
 TGeoManager.cxx:2674
 TGeoManager.cxx:2675
 TGeoManager.cxx:2676
 TGeoManager.cxx:2677
 TGeoManager.cxx:2678
 TGeoManager.cxx:2679
 TGeoManager.cxx:2680
 TGeoManager.cxx:2681
 TGeoManager.cxx:2682
 TGeoManager.cxx:2683
 TGeoManager.cxx:2684
 TGeoManager.cxx:2685
 TGeoManager.cxx:2686
 TGeoManager.cxx:2687
 TGeoManager.cxx:2688
 TGeoManager.cxx:2689
 TGeoManager.cxx:2690
 TGeoManager.cxx:2691
 TGeoManager.cxx:2692
 TGeoManager.cxx:2693
 TGeoManager.cxx:2694
 TGeoManager.cxx:2695
 TGeoManager.cxx:2696
 TGeoManager.cxx:2697
 TGeoManager.cxx:2698
 TGeoManager.cxx:2699
 TGeoManager.cxx:2700
 TGeoManager.cxx:2701
 TGeoManager.cxx:2702
 TGeoManager.cxx:2703
 TGeoManager.cxx:2704
 TGeoManager.cxx:2705
 TGeoManager.cxx:2706
 TGeoManager.cxx:2707
 TGeoManager.cxx:2708
 TGeoManager.cxx:2709
 TGeoManager.cxx:2710
 TGeoManager.cxx:2711
 TGeoManager.cxx:2712
 TGeoManager.cxx:2713
 TGeoManager.cxx:2714
 TGeoManager.cxx:2715
 TGeoManager.cxx:2716
 TGeoManager.cxx:2717
 TGeoManager.cxx:2718
 TGeoManager.cxx:2719
 TGeoManager.cxx:2720
 TGeoManager.cxx:2721
 TGeoManager.cxx:2722
 TGeoManager.cxx:2723
 TGeoManager.cxx:2724
 TGeoManager.cxx:2725
 TGeoManager.cxx:2726
 TGeoManager.cxx:2727
 TGeoManager.cxx:2728
 TGeoManager.cxx:2729
 TGeoManager.cxx:2730
 TGeoManager.cxx:2731
 TGeoManager.cxx:2732
 TGeoManager.cxx:2733
 TGeoManager.cxx:2734
 TGeoManager.cxx:2735
 TGeoManager.cxx:2736
 TGeoManager.cxx:2737
 TGeoManager.cxx:2738
 TGeoManager.cxx:2739
 TGeoManager.cxx:2740
 TGeoManager.cxx:2741
 TGeoManager.cxx:2742
 TGeoManager.cxx:2743
 TGeoManager.cxx:2744
 TGeoManager.cxx:2745
 TGeoManager.cxx:2746
 TGeoManager.cxx:2747
 TGeoManager.cxx:2748
 TGeoManager.cxx:2749
 TGeoManager.cxx:2750
 TGeoManager.cxx:2751
 TGeoManager.cxx:2752
 TGeoManager.cxx:2753
 TGeoManager.cxx:2754
 TGeoManager.cxx:2755
 TGeoManager.cxx:2756
 TGeoManager.cxx:2757
 TGeoManager.cxx:2758
 TGeoManager.cxx:2759
 TGeoManager.cxx:2760
 TGeoManager.cxx:2761
 TGeoManager.cxx:2762
 TGeoManager.cxx:2763
 TGeoManager.cxx:2764
 TGeoManager.cxx:2765
 TGeoManager.cxx:2766
 TGeoManager.cxx:2767
 TGeoManager.cxx:2768
 TGeoManager.cxx:2769
 TGeoManager.cxx:2770
 TGeoManager.cxx:2771
 TGeoManager.cxx:2772
 TGeoManager.cxx:2773
 TGeoManager.cxx:2774
 TGeoManager.cxx:2775
 TGeoManager.cxx:2776
 TGeoManager.cxx:2777
 TGeoManager.cxx:2778
 TGeoManager.cxx:2779
 TGeoManager.cxx:2780
 TGeoManager.cxx:2781
 TGeoManager.cxx:2782
 TGeoManager.cxx:2783
 TGeoManager.cxx:2784
 TGeoManager.cxx:2785
 TGeoManager.cxx:2786
 TGeoManager.cxx:2787
 TGeoManager.cxx:2788
 TGeoManager.cxx:2789
 TGeoManager.cxx:2790
 TGeoManager.cxx:2791
 TGeoManager.cxx:2792
 TGeoManager.cxx:2793
 TGeoManager.cxx:2794
 TGeoManager.cxx:2795
 TGeoManager.cxx:2796
 TGeoManager.cxx:2797
 TGeoManager.cxx:2798
 TGeoManager.cxx:2799
 TGeoManager.cxx:2800
 TGeoManager.cxx:2801
 TGeoManager.cxx:2802
 TGeoManager.cxx:2803
 TGeoManager.cxx:2804
 TGeoManager.cxx:2805
 TGeoManager.cxx:2806
 TGeoManager.cxx:2807
 TGeoManager.cxx:2808
 TGeoManager.cxx:2809
 TGeoManager.cxx:2810
 TGeoManager.cxx:2811
 TGeoManager.cxx:2812
 TGeoManager.cxx:2813
 TGeoManager.cxx:2814
 TGeoManager.cxx:2815
 TGeoManager.cxx:2816
 TGeoManager.cxx:2817
 TGeoManager.cxx:2818
 TGeoManager.cxx:2819
 TGeoManager.cxx:2820
 TGeoManager.cxx:2821
 TGeoManager.cxx:2822
 TGeoManager.cxx:2823
 TGeoManager.cxx:2824
 TGeoManager.cxx:2825
 TGeoManager.cxx:2826
 TGeoManager.cxx:2827
 TGeoManager.cxx:2828
 TGeoManager.cxx:2829
 TGeoManager.cxx:2830
 TGeoManager.cxx:2831
 TGeoManager.cxx:2832
 TGeoManager.cxx:2833
 TGeoManager.cxx:2834
 TGeoManager.cxx:2835
 TGeoManager.cxx:2836
 TGeoManager.cxx:2837
 TGeoManager.cxx:2838
 TGeoManager.cxx:2839
 TGeoManager.cxx:2840
 TGeoManager.cxx:2841
 TGeoManager.cxx:2842
 TGeoManager.cxx:2843
 TGeoManager.cxx:2844
 TGeoManager.cxx:2845
 TGeoManager.cxx:2846
 TGeoManager.cxx:2847
 TGeoManager.cxx:2848
 TGeoManager.cxx:2849
 TGeoManager.cxx:2850
 TGeoManager.cxx:2851
 TGeoManager.cxx:2852
 TGeoManager.cxx:2853
 TGeoManager.cxx:2854
 TGeoManager.cxx:2855
 TGeoManager.cxx:2856
 TGeoManager.cxx:2857
 TGeoManager.cxx:2858
 TGeoManager.cxx:2859
 TGeoManager.cxx:2860
 TGeoManager.cxx:2861
 TGeoManager.cxx:2862
 TGeoManager.cxx:2863
 TGeoManager.cxx:2864
 TGeoManager.cxx:2865
 TGeoManager.cxx:2866
 TGeoManager.cxx:2867
 TGeoManager.cxx:2868
 TGeoManager.cxx:2869
 TGeoManager.cxx:2870
 TGeoManager.cxx:2871
 TGeoManager.cxx:2872
 TGeoManager.cxx:2873
 TGeoManager.cxx:2874
 TGeoManager.cxx:2875
 TGeoManager.cxx:2876
 TGeoManager.cxx:2877
 TGeoManager.cxx:2878
 TGeoManager.cxx:2879
 TGeoManager.cxx:2880
 TGeoManager.cxx:2881
 TGeoManager.cxx:2882
 TGeoManager.cxx:2883
 TGeoManager.cxx:2884
 TGeoManager.cxx:2885
 TGeoManager.cxx:2886
 TGeoManager.cxx:2887
 TGeoManager.cxx:2888
 TGeoManager.cxx:2889
 TGeoManager.cxx:2890
 TGeoManager.cxx:2891
 TGeoManager.cxx:2892
 TGeoManager.cxx:2893
 TGeoManager.cxx:2894
 TGeoManager.cxx:2895
 TGeoManager.cxx:2896
 TGeoManager.cxx:2897
 TGeoManager.cxx:2898
 TGeoManager.cxx:2899
 TGeoManager.cxx:2900
 TGeoManager.cxx:2901
 TGeoManager.cxx:2902
 TGeoManager.cxx:2903
 TGeoManager.cxx:2904
 TGeoManager.cxx:2905
 TGeoManager.cxx:2906
 TGeoManager.cxx:2907
 TGeoManager.cxx:2908
 TGeoManager.cxx:2909
 TGeoManager.cxx:2910
 TGeoManager.cxx:2911
 TGeoManager.cxx:2912
 TGeoManager.cxx:2913
 TGeoManager.cxx:2914
 TGeoManager.cxx:2915
 TGeoManager.cxx:2916
 TGeoManager.cxx:2917
 TGeoManager.cxx:2918
 TGeoManager.cxx:2919
 TGeoManager.cxx:2920
 TGeoManager.cxx:2921
 TGeoManager.cxx:2922
 TGeoManager.cxx:2923
 TGeoManager.cxx:2924
 TGeoManager.cxx:2925
 TGeoManager.cxx:2926
 TGeoManager.cxx:2927
 TGeoManager.cxx:2928
 TGeoManager.cxx:2929
 TGeoManager.cxx:2930
 TGeoManager.cxx:2931
 TGeoManager.cxx:2932
 TGeoManager.cxx:2933
 TGeoManager.cxx:2934
 TGeoManager.cxx:2935
 TGeoManager.cxx:2936
 TGeoManager.cxx:2937
 TGeoManager.cxx:2938
 TGeoManager.cxx:2939
 TGeoManager.cxx:2940
 TGeoManager.cxx:2941
 TGeoManager.cxx:2942
 TGeoManager.cxx:2943
 TGeoManager.cxx:2944
 TGeoManager.cxx:2945
 TGeoManager.cxx:2946
 TGeoManager.cxx:2947
 TGeoManager.cxx:2948
 TGeoManager.cxx:2949
 TGeoManager.cxx:2950
 TGeoManager.cxx:2951
 TGeoManager.cxx:2952
 TGeoManager.cxx:2953
 TGeoManager.cxx:2954
 TGeoManager.cxx:2955
 TGeoManager.cxx:2956
 TGeoManager.cxx:2957
 TGeoManager.cxx:2958
 TGeoManager.cxx:2959
 TGeoManager.cxx:2960
 TGeoManager.cxx:2961
 TGeoManager.cxx:2962
 TGeoManager.cxx:2963
 TGeoManager.cxx:2964
 TGeoManager.cxx:2965
 TGeoManager.cxx:2966
 TGeoManager.cxx:2967
 TGeoManager.cxx:2968
 TGeoManager.cxx:2969
 TGeoManager.cxx:2970
 TGeoManager.cxx:2971
 TGeoManager.cxx:2972
 TGeoManager.cxx:2973
 TGeoManager.cxx:2974
 TGeoManager.cxx:2975
 TGeoManager.cxx:2976
 TGeoManager.cxx:2977
 TGeoManager.cxx:2978
 TGeoManager.cxx:2979
 TGeoManager.cxx:2980
 TGeoManager.cxx:2981
 TGeoManager.cxx:2982
 TGeoManager.cxx:2983
 TGeoManager.cxx:2984
 TGeoManager.cxx:2985
 TGeoManager.cxx:2986
 TGeoManager.cxx:2987
 TGeoManager.cxx:2988
 TGeoManager.cxx:2989
 TGeoManager.cxx:2990
 TGeoManager.cxx:2991
 TGeoManager.cxx:2992
 TGeoManager.cxx:2993
 TGeoManager.cxx:2994
 TGeoManager.cxx:2995
 TGeoManager.cxx:2996
 TGeoManager.cxx:2997
 TGeoManager.cxx:2998
 TGeoManager.cxx:2999
 TGeoManager.cxx:3000
 TGeoManager.cxx:3001
 TGeoManager.cxx:3002
 TGeoManager.cxx:3003
 TGeoManager.cxx:3004
 TGeoManager.cxx:3005
 TGeoManager.cxx:3006
 TGeoManager.cxx:3007
 TGeoManager.cxx:3008
 TGeoManager.cxx:3009
 TGeoManager.cxx:3010
 TGeoManager.cxx:3011
 TGeoManager.cxx:3012
 TGeoManager.cxx:3013
 TGeoManager.cxx:3014
 TGeoManager.cxx:3015
 TGeoManager.cxx:3016
 TGeoManager.cxx:3017
 TGeoManager.cxx:3018
 TGeoManager.cxx:3019
 TGeoManager.cxx:3020
 TGeoManager.cxx:3021
 TGeoManager.cxx:3022
 TGeoManager.cxx:3023
 TGeoManager.cxx:3024
 TGeoManager.cxx:3025
 TGeoManager.cxx:3026
 TGeoManager.cxx:3027
 TGeoManager.cxx:3028
 TGeoManager.cxx:3029
 TGeoManager.cxx:3030
 TGeoManager.cxx:3031
 TGeoManager.cxx:3032
 TGeoManager.cxx:3033
 TGeoManager.cxx:3034
 TGeoManager.cxx:3035
 TGeoManager.cxx:3036
 TGeoManager.cxx:3037
 TGeoManager.cxx:3038
 TGeoManager.cxx:3039
 TGeoManager.cxx:3040
 TGeoManager.cxx:3041
 TGeoManager.cxx:3042
 TGeoManager.cxx:3043
 TGeoManager.cxx:3044
 TGeoManager.cxx:3045
 TGeoManager.cxx:3046
 TGeoManager.cxx:3047
 TGeoManager.cxx:3048
 TGeoManager.cxx:3049
 TGeoManager.cxx:3050
 TGeoManager.cxx:3051
 TGeoManager.cxx:3052
 TGeoManager.cxx:3053
 TGeoManager.cxx:3054
 TGeoManager.cxx:3055
 TGeoManager.cxx:3056
 TGeoManager.cxx:3057
 TGeoManager.cxx:3058
 TGeoManager.cxx:3059
 TGeoManager.cxx:3060
 TGeoManager.cxx:3061
 TGeoManager.cxx:3062
 TGeoManager.cxx:3063
 TGeoManager.cxx:3064
 TGeoManager.cxx:3065
 TGeoManager.cxx:3066
 TGeoManager.cxx:3067
 TGeoManager.cxx:3068
 TGeoManager.cxx:3069
 TGeoManager.cxx:3070
 TGeoManager.cxx:3071
 TGeoManager.cxx:3072
 TGeoManager.cxx:3073
 TGeoManager.cxx:3074
 TGeoManager.cxx:3075
 TGeoManager.cxx:3076
 TGeoManager.cxx:3077
 TGeoManager.cxx:3078
 TGeoManager.cxx:3079
 TGeoManager.cxx:3080
 TGeoManager.cxx:3081
 TGeoManager.cxx:3082
 TGeoManager.cxx:3083
 TGeoManager.cxx:3084
 TGeoManager.cxx:3085
 TGeoManager.cxx:3086
 TGeoManager.cxx:3087
 TGeoManager.cxx:3088
 TGeoManager.cxx:3089
 TGeoManager.cxx:3090
 TGeoManager.cxx:3091
 TGeoManager.cxx:3092
 TGeoManager.cxx:3093
 TGeoManager.cxx:3094
 TGeoManager.cxx:3095
 TGeoManager.cxx:3096
 TGeoManager.cxx:3097
 TGeoManager.cxx:3098
 TGeoManager.cxx:3099
 TGeoManager.cxx:3100
 TGeoManager.cxx:3101
 TGeoManager.cxx:3102
 TGeoManager.cxx:3103
 TGeoManager.cxx:3104
 TGeoManager.cxx:3105
 TGeoManager.cxx:3106
 TGeoManager.cxx:3107
 TGeoManager.cxx:3108
 TGeoManager.cxx:3109
 TGeoManager.cxx:3110
 TGeoManager.cxx:3111
 TGeoManager.cxx:3112
 TGeoManager.cxx:3113
 TGeoManager.cxx:3114
 TGeoManager.cxx:3115
 TGeoManager.cxx:3116
 TGeoManager.cxx:3117
 TGeoManager.cxx:3118
 TGeoManager.cxx:3119
 TGeoManager.cxx:3120
 TGeoManager.cxx:3121
 TGeoManager.cxx:3122
 TGeoManager.cxx:3123
 TGeoManager.cxx:3124
 TGeoManager.cxx:3125
 TGeoManager.cxx:3126
 TGeoManager.cxx:3127
 TGeoManager.cxx:3128
 TGeoManager.cxx:3129
 TGeoManager.cxx:3130
 TGeoManager.cxx:3131
 TGeoManager.cxx:3132
 TGeoManager.cxx:3133
 TGeoManager.cxx:3134
 TGeoManager.cxx:3135
 TGeoManager.cxx:3136
 TGeoManager.cxx:3137
 TGeoManager.cxx:3138
 TGeoManager.cxx:3139
 TGeoManager.cxx:3140
 TGeoManager.cxx:3141
 TGeoManager.cxx:3142
 TGeoManager.cxx:3143
 TGeoManager.cxx:3144
 TGeoManager.cxx:3145
 TGeoManager.cxx:3146
 TGeoManager.cxx:3147
 TGeoManager.cxx:3148
 TGeoManager.cxx:3149
 TGeoManager.cxx:3150
 TGeoManager.cxx:3151
 TGeoManager.cxx:3152
 TGeoManager.cxx:3153
 TGeoManager.cxx:3154
 TGeoManager.cxx:3155
 TGeoManager.cxx:3156
 TGeoManager.cxx:3157
 TGeoManager.cxx:3158
 TGeoManager.cxx:3159
 TGeoManager.cxx:3160
 TGeoManager.cxx:3161
 TGeoManager.cxx:3162
 TGeoManager.cxx:3163
 TGeoManager.cxx:3164
 TGeoManager.cxx:3165
 TGeoManager.cxx:3166
 TGeoManager.cxx:3167
 TGeoManager.cxx:3168
 TGeoManager.cxx:3169
 TGeoManager.cxx:3170
 TGeoManager.cxx:3171
 TGeoManager.cxx:3172
 TGeoManager.cxx:3173
 TGeoManager.cxx:3174
 TGeoManager.cxx:3175
 TGeoManager.cxx:3176
 TGeoManager.cxx:3177
 TGeoManager.cxx:3178
 TGeoManager.cxx:3179
 TGeoManager.cxx:3180
 TGeoManager.cxx:3181
 TGeoManager.cxx:3182
 TGeoManager.cxx:3183
 TGeoManager.cxx:3184
 TGeoManager.cxx:3185
 TGeoManager.cxx:3186
 TGeoManager.cxx:3187
 TGeoManager.cxx:3188
 TGeoManager.cxx:3189
 TGeoManager.cxx:3190
 TGeoManager.cxx:3191
 TGeoManager.cxx:3192
 TGeoManager.cxx:3193
 TGeoManager.cxx:3194
 TGeoManager.cxx:3195
 TGeoManager.cxx:3196
 TGeoManager.cxx:3197
 TGeoManager.cxx:3198
 TGeoManager.cxx:3199
 TGeoManager.cxx:3200
 TGeoManager.cxx:3201
 TGeoManager.cxx:3202
 TGeoManager.cxx:3203
 TGeoManager.cxx:3204
 TGeoManager.cxx:3205
 TGeoManager.cxx:3206
 TGeoManager.cxx:3207
 TGeoManager.cxx:3208
 TGeoManager.cxx:3209
 TGeoManager.cxx:3210
 TGeoManager.cxx:3211
 TGeoManager.cxx:3212
 TGeoManager.cxx:3213
 TGeoManager.cxx:3214
 TGeoManager.cxx:3215
 TGeoManager.cxx:3216
 TGeoManager.cxx:3217
 TGeoManager.cxx:3218
 TGeoManager.cxx:3219
 TGeoManager.cxx:3220
 TGeoManager.cxx:3221
 TGeoManager.cxx:3222
 TGeoManager.cxx:3223
 TGeoManager.cxx:3224
 TGeoManager.cxx:3225
 TGeoManager.cxx:3226
 TGeoManager.cxx:3227
 TGeoManager.cxx:3228
 TGeoManager.cxx:3229
 TGeoManager.cxx:3230
 TGeoManager.cxx:3231
 TGeoManager.cxx:3232
 TGeoManager.cxx:3233
 TGeoManager.cxx:3234
 TGeoManager.cxx:3235
 TGeoManager.cxx:3236
 TGeoManager.cxx:3237
 TGeoManager.cxx:3238
 TGeoManager.cxx:3239
 TGeoManager.cxx:3240
 TGeoManager.cxx:3241
 TGeoManager.cxx:3242
 TGeoManager.cxx:3243
 TGeoManager.cxx:3244
 TGeoManager.cxx:3245
 TGeoManager.cxx:3246
 TGeoManager.cxx:3247
 TGeoManager.cxx:3248
 TGeoManager.cxx:3249
 TGeoManager.cxx:3250
 TGeoManager.cxx:3251
 TGeoManager.cxx:3252
 TGeoManager.cxx:3253
 TGeoManager.cxx:3254
 TGeoManager.cxx:3255
 TGeoManager.cxx:3256
 TGeoManager.cxx:3257
 TGeoManager.cxx:3258
 TGeoManager.cxx:3259
 TGeoManager.cxx:3260
 TGeoManager.cxx:3261
 TGeoManager.cxx:3262
 TGeoManager.cxx:3263
 TGeoManager.cxx:3264
 TGeoManager.cxx:3265
 TGeoManager.cxx:3266
 TGeoManager.cxx:3267
 TGeoManager.cxx:3268
 TGeoManager.cxx:3269
 TGeoManager.cxx:3270
 TGeoManager.cxx:3271
 TGeoManager.cxx:3272
 TGeoManager.cxx:3273
 TGeoManager.cxx:3274
 TGeoManager.cxx:3275
 TGeoManager.cxx:3276
 TGeoManager.cxx:3277
 TGeoManager.cxx:3278
 TGeoManager.cxx:3279
 TGeoManager.cxx:3280
 TGeoManager.cxx:3281
 TGeoManager.cxx:3282
 TGeoManager.cxx:3283
 TGeoManager.cxx:3284
 TGeoManager.cxx:3285
 TGeoManager.cxx:3286
 TGeoManager.cxx:3287
 TGeoManager.cxx:3288
 TGeoManager.cxx:3289
 TGeoManager.cxx:3290
 TGeoManager.cxx:3291
 TGeoManager.cxx:3292
 TGeoManager.cxx:3293
 TGeoManager.cxx:3294
 TGeoManager.cxx:3295
 TGeoManager.cxx:3296
 TGeoManager.cxx:3297
 TGeoManager.cxx:3298
 TGeoManager.cxx:3299
 TGeoManager.cxx:3300
 TGeoManager.cxx:3301
 TGeoManager.cxx:3302
 TGeoManager.cxx:3303
 TGeoManager.cxx:3304
 TGeoManager.cxx:3305
 TGeoManager.cxx:3306
 TGeoManager.cxx:3307
 TGeoManager.cxx:3308
 TGeoManager.cxx:3309
 TGeoManager.cxx:3310
 TGeoManager.cxx:3311
 TGeoManager.cxx:3312
 TGeoManager.cxx:3313
 TGeoManager.cxx:3314
 TGeoManager.cxx:3315
 TGeoManager.cxx:3316
 TGeoManager.cxx:3317
 TGeoManager.cxx:3318
 TGeoManager.cxx:3319
 TGeoManager.cxx:3320
 TGeoManager.cxx:3321
 TGeoManager.cxx:3322
 TGeoManager.cxx:3323
 TGeoManager.cxx:3324
 TGeoManager.cxx:3325
 TGeoManager.cxx:3326
 TGeoManager.cxx:3327
 TGeoManager.cxx:3328
 TGeoManager.cxx:3329
 TGeoManager.cxx:3330
 TGeoManager.cxx:3331
 TGeoManager.cxx:3332
 TGeoManager.cxx:3333
 TGeoManager.cxx:3334
 TGeoManager.cxx:3335
 TGeoManager.cxx:3336
 TGeoManager.cxx:3337
 TGeoManager.cxx:3338
 TGeoManager.cxx:3339
 TGeoManager.cxx:3340
 TGeoManager.cxx:3341
 TGeoManager.cxx:3342
 TGeoManager.cxx:3343
 TGeoManager.cxx:3344
 TGeoManager.cxx:3345
 TGeoManager.cxx:3346
 TGeoManager.cxx:3347
 TGeoManager.cxx:3348
 TGeoManager.cxx:3349
 TGeoManager.cxx:3350
 TGeoManager.cxx:3351
 TGeoManager.cxx:3352
 TGeoManager.cxx:3353
 TGeoManager.cxx:3354
 TGeoManager.cxx:3355
 TGeoManager.cxx:3356
 TGeoManager.cxx:3357
 TGeoManager.cxx:3358
 TGeoManager.cxx:3359
 TGeoManager.cxx:3360
 TGeoManager.cxx:3361
 TGeoManager.cxx:3362
 TGeoManager.cxx:3363
 TGeoManager.cxx:3364
 TGeoManager.cxx:3365
 TGeoManager.cxx:3366
 TGeoManager.cxx:3367
 TGeoManager.cxx:3368
 TGeoManager.cxx:3369
 TGeoManager.cxx:3370
 TGeoManager.cxx:3371
 TGeoManager.cxx:3372
 TGeoManager.cxx:3373
 TGeoManager.cxx:3374
 TGeoManager.cxx:3375
 TGeoManager.cxx:3376
 TGeoManager.cxx:3377
 TGeoManager.cxx:3378
 TGeoManager.cxx:3379
 TGeoManager.cxx:3380
 TGeoManager.cxx:3381
 TGeoManager.cxx:3382
 TGeoManager.cxx:3383
 TGeoManager.cxx:3384
 TGeoManager.cxx:3385
 TGeoManager.cxx:3386
 TGeoManager.cxx:3387
 TGeoManager.cxx:3388
 TGeoManager.cxx:3389
 TGeoManager.cxx:3390
 TGeoManager.cxx:3391
 TGeoManager.cxx:3392
 TGeoManager.cxx:3393
 TGeoManager.cxx:3394
 TGeoManager.cxx:3395
 TGeoManager.cxx:3396
 TGeoManager.cxx:3397
 TGeoManager.cxx:3398
 TGeoManager.cxx:3399
 TGeoManager.cxx:3400
 TGeoManager.cxx:3401
 TGeoManager.cxx:3402
 TGeoManager.cxx:3403
 TGeoManager.cxx:3404
 TGeoManager.cxx:3405
 TGeoManager.cxx:3406
 TGeoManager.cxx:3407
 TGeoManager.cxx:3408
 TGeoManager.cxx:3409
 TGeoManager.cxx:3410
 TGeoManager.cxx:3411
 TGeoManager.cxx:3412
 TGeoManager.cxx:3413
 TGeoManager.cxx:3414
 TGeoManager.cxx:3415
 TGeoManager.cxx:3416
 TGeoManager.cxx:3417
 TGeoManager.cxx:3418
 TGeoManager.cxx:3419
 TGeoManager.cxx:3420
 TGeoManager.cxx:3421
 TGeoManager.cxx:3422
 TGeoManager.cxx:3423
 TGeoManager.cxx:3424
 TGeoManager.cxx:3425
 TGeoManager.cxx:3426
 TGeoManager.cxx:3427
 TGeoManager.cxx:3428
 TGeoManager.cxx:3429
 TGeoManager.cxx:3430
 TGeoManager.cxx:3431
 TGeoManager.cxx:3432
 TGeoManager.cxx:3433
 TGeoManager.cxx:3434
 TGeoManager.cxx:3435
 TGeoManager.cxx:3436
 TGeoManager.cxx:3437
 TGeoManager.cxx:3438
 TGeoManager.cxx:3439
 TGeoManager.cxx:3440
 TGeoManager.cxx:3441
 TGeoManager.cxx:3442
 TGeoManager.cxx:3443
 TGeoManager.cxx:3444
 TGeoManager.cxx:3445
 TGeoManager.cxx:3446
 TGeoManager.cxx:3447
 TGeoManager.cxx:3448
 TGeoManager.cxx:3449
 TGeoManager.cxx:3450
 TGeoManager.cxx:3451
 TGeoManager.cxx:3452
 TGeoManager.cxx:3453
 TGeoManager.cxx:3454
 TGeoManager.cxx:3455
 TGeoManager.cxx:3456
 TGeoManager.cxx:3457
 TGeoManager.cxx:3458
 TGeoManager.cxx:3459
 TGeoManager.cxx:3460
 TGeoManager.cxx:3461
 TGeoManager.cxx:3462
 TGeoManager.cxx:3463
 TGeoManager.cxx:3464
 TGeoManager.cxx:3465
 TGeoManager.cxx:3466
 TGeoManager.cxx:3467
 TGeoManager.cxx:3468
 TGeoManager.cxx:3469
 TGeoManager.cxx:3470
 TGeoManager.cxx:3471
 TGeoManager.cxx:3472
 TGeoManager.cxx:3473
 TGeoManager.cxx:3474
 TGeoManager.cxx:3475
 TGeoManager.cxx:3476
 TGeoManager.cxx:3477
 TGeoManager.cxx:3478
 TGeoManager.cxx:3479
 TGeoManager.cxx:3480
 TGeoManager.cxx:3481
 TGeoManager.cxx:3482
 TGeoManager.cxx:3483
 TGeoManager.cxx:3484
 TGeoManager.cxx:3485
 TGeoManager.cxx:3486
 TGeoManager.cxx:3487
 TGeoManager.cxx:3488
 TGeoManager.cxx:3489
 TGeoManager.cxx:3490
 TGeoManager.cxx:3491
 TGeoManager.cxx:3492
 TGeoManager.cxx:3493
 TGeoManager.cxx:3494
 TGeoManager.cxx:3495
 TGeoManager.cxx:3496
 TGeoManager.cxx:3497
 TGeoManager.cxx:3498
 TGeoManager.cxx:3499
 TGeoManager.cxx:3500
 TGeoManager.cxx:3501
 TGeoManager.cxx:3502
 TGeoManager.cxx:3503
 TGeoManager.cxx:3504
 TGeoManager.cxx:3505
 TGeoManager.cxx:3506
 TGeoManager.cxx:3507
 TGeoManager.cxx:3508
 TGeoManager.cxx:3509
 TGeoManager.cxx:3510
 TGeoManager.cxx:3511
 TGeoManager.cxx:3512
 TGeoManager.cxx:3513
 TGeoManager.cxx:3514
 TGeoManager.cxx:3515
 TGeoManager.cxx:3516
 TGeoManager.cxx:3517
 TGeoManager.cxx:3518
 TGeoManager.cxx:3519
 TGeoManager.cxx:3520
 TGeoManager.cxx:3521
 TGeoManager.cxx:3522
 TGeoManager.cxx:3523
 TGeoManager.cxx:3524
 TGeoManager.cxx:3525
 TGeoManager.cxx:3526
 TGeoManager.cxx:3527
 TGeoManager.cxx:3528
 TGeoManager.cxx:3529
 TGeoManager.cxx:3530
 TGeoManager.cxx:3531
 TGeoManager.cxx:3532
 TGeoManager.cxx:3533
 TGeoManager.cxx:3534
 TGeoManager.cxx:3535
 TGeoManager.cxx:3536
 TGeoManager.cxx:3537
 TGeoManager.cxx:3538
 TGeoManager.cxx:3539
 TGeoManager.cxx:3540
 TGeoManager.cxx:3541
 TGeoManager.cxx:3542
 TGeoManager.cxx:3543
 TGeoManager.cxx:3544
 TGeoManager.cxx:3545
 TGeoManager.cxx:3546
 TGeoManager.cxx:3547
 TGeoManager.cxx:3548
 TGeoManager.cxx:3549
 TGeoManager.cxx:3550
 TGeoManager.cxx:3551
 TGeoManager.cxx:3552
 TGeoManager.cxx:3553
 TGeoManager.cxx:3554
 TGeoManager.cxx:3555
 TGeoManager.cxx:3556
 TGeoManager.cxx:3557
 TGeoManager.cxx:3558
 TGeoManager.cxx:3559
 TGeoManager.cxx:3560
 TGeoManager.cxx:3561
 TGeoManager.cxx:3562
 TGeoManager.cxx:3563
 TGeoManager.cxx:3564
 TGeoManager.cxx:3565
 TGeoManager.cxx:3566
 TGeoManager.cxx:3567
 TGeoManager.cxx:3568
 TGeoManager.cxx:3569
 TGeoManager.cxx:3570
 TGeoManager.cxx:3571
 TGeoManager.cxx:3572
 TGeoManager.cxx:3573
 TGeoManager.cxx:3574
 TGeoManager.cxx:3575
 TGeoManager.cxx:3576
 TGeoManager.cxx:3577
 TGeoManager.cxx:3578
 TGeoManager.cxx:3579
 TGeoManager.cxx:3580
 TGeoManager.cxx:3581
 TGeoManager.cxx:3582
 TGeoManager.cxx:3583
 TGeoManager.cxx:3584
 TGeoManager.cxx:3585
 TGeoManager.cxx:3586
 TGeoManager.cxx:3587
 TGeoManager.cxx:3588
 TGeoManager.cxx:3589
 TGeoManager.cxx:3590
 TGeoManager.cxx:3591
 TGeoManager.cxx:3592
 TGeoManager.cxx:3593
 TGeoManager.cxx:3594
 TGeoManager.cxx:3595
 TGeoManager.cxx:3596
 TGeoManager.cxx:3597
 TGeoManager.cxx:3598
 TGeoManager.cxx:3599
 TGeoManager.cxx:3600
 TGeoManager.cxx:3601
 TGeoManager.cxx:3602
 TGeoManager.cxx:3603
 TGeoManager.cxx:3604
 TGeoManager.cxx:3605
 TGeoManager.cxx:3606
 TGeoManager.cxx:3607
 TGeoManager.cxx:3608
 TGeoManager.cxx:3609
 TGeoManager.cxx:3610
 TGeoManager.cxx:3611
 TGeoManager.cxx:3612
 TGeoManager.cxx:3613
 TGeoManager.cxx:3614
 TGeoManager.cxx:3615
 TGeoManager.cxx:3616
 TGeoManager.cxx:3617
 TGeoManager.cxx:3618
 TGeoManager.cxx:3619
 TGeoManager.cxx:3620
 TGeoManager.cxx:3621
 TGeoManager.cxx:3622
 TGeoManager.cxx:3623
 TGeoManager.cxx:3624
 TGeoManager.cxx:3625
 TGeoManager.cxx:3626
 TGeoManager.cxx:3627
 TGeoManager.cxx:3628
 TGeoManager.cxx:3629
 TGeoManager.cxx:3630
 TGeoManager.cxx:3631
 TGeoManager.cxx:3632
 TGeoManager.cxx:3633
 TGeoManager.cxx:3634
 TGeoManager.cxx:3635
 TGeoManager.cxx:3636
 TGeoManager.cxx:3637
 TGeoManager.cxx:3638
 TGeoManager.cxx:3639
 TGeoManager.cxx:3640
 TGeoManager.cxx:3641
 TGeoManager.cxx:3642
 TGeoManager.cxx:3643
 TGeoManager.cxx:3644
 TGeoManager.cxx:3645
 TGeoManager.cxx:3646
 TGeoManager.cxx:3647
 TGeoManager.cxx:3648
 TGeoManager.cxx:3649
 TGeoManager.cxx:3650
 TGeoManager.cxx:3651
 TGeoManager.cxx:3652
 TGeoManager.cxx:3653
 TGeoManager.cxx:3654
 TGeoManager.cxx:3655
 TGeoManager.cxx:3656
 TGeoManager.cxx:3657
 TGeoManager.cxx:3658
 TGeoManager.cxx:3659
 TGeoManager.cxx:3660
 TGeoManager.cxx:3661
 TGeoManager.cxx:3662
 TGeoManager.cxx:3663
 TGeoManager.cxx:3664
 TGeoManager.cxx:3665
 TGeoManager.cxx:3666
 TGeoManager.cxx:3667
 TGeoManager.cxx:3668
 TGeoManager.cxx:3669
 TGeoManager.cxx:3670
 TGeoManager.cxx:3671
 TGeoManager.cxx:3672
 TGeoManager.cxx:3673
 TGeoManager.cxx:3674
 TGeoManager.cxx:3675
 TGeoManager.cxx:3676
 TGeoManager.cxx:3677
 TGeoManager.cxx:3678
 TGeoManager.cxx:3679
 TGeoManager.cxx:3680
 TGeoManager.cxx:3681
 TGeoManager.cxx:3682
 TGeoManager.cxx:3683
 TGeoManager.cxx:3684
 TGeoManager.cxx:3685
 TGeoManager.cxx:3686
 TGeoManager.cxx:3687
 TGeoManager.cxx:3688
 TGeoManager.cxx:3689
 TGeoManager.cxx:3690
 TGeoManager.cxx:3691
 TGeoManager.cxx:3692
 TGeoManager.cxx:3693
 TGeoManager.cxx:3694
 TGeoManager.cxx:3695
 TGeoManager.cxx:3696
 TGeoManager.cxx:3697
 TGeoManager.cxx:3698
 TGeoManager.cxx:3699
 TGeoManager.cxx:3700
 TGeoManager.cxx:3701
 TGeoManager.cxx:3702
 TGeoManager.cxx:3703
 TGeoManager.cxx:3704
 TGeoManager.cxx:3705
 TGeoManager.cxx:3706
 TGeoManager.cxx:3707
 TGeoManager.cxx:3708
 TGeoManager.cxx:3709
 TGeoManager.cxx:3710
 TGeoManager.cxx:3711
 TGeoManager.cxx:3712
 TGeoManager.cxx:3713
 TGeoManager.cxx:3714
 TGeoManager.cxx:3715
 TGeoManager.cxx:3716
 TGeoManager.cxx:3717
 TGeoManager.cxx:3718
 TGeoManager.cxx:3719
 TGeoManager.cxx:3720
 TGeoManager.cxx:3721
 TGeoManager.cxx:3722
 TGeoManager.cxx:3723
 TGeoManager.cxx:3724
 TGeoManager.cxx:3725
 TGeoManager.cxx:3726
 TGeoManager.cxx:3727
 TGeoManager.cxx:3728
 TGeoManager.cxx:3729
 TGeoManager.cxx:3730
 TGeoManager.cxx:3731
 TGeoManager.cxx:3732
 TGeoManager.cxx:3733
 TGeoManager.cxx:3734
 TGeoManager.cxx:3735
 TGeoManager.cxx:3736
 TGeoManager.cxx:3737
 TGeoManager.cxx:3738
 TGeoManager.cxx:3739
 TGeoManager.cxx:3740
 TGeoManager.cxx:3741
 TGeoManager.cxx:3742
 TGeoManager.cxx:3743
 TGeoManager.cxx:3744
 TGeoManager.cxx:3745
 TGeoManager.cxx:3746
 TGeoManager.cxx:3747
 TGeoManager.cxx:3748
 TGeoManager.cxx:3749
 TGeoManager.cxx:3750
 TGeoManager.cxx:3751
 TGeoManager.cxx:3752
 TGeoManager.cxx:3753
 TGeoManager.cxx:3754
 TGeoManager.cxx:3755
 TGeoManager.cxx:3756
 TGeoManager.cxx:3757
 TGeoManager.cxx:3758
 TGeoManager.cxx:3759
 TGeoManager.cxx:3760
 TGeoManager.cxx:3761
 TGeoManager.cxx:3762
 TGeoManager.cxx:3763
 TGeoManager.cxx:3764
 TGeoManager.cxx:3765
 TGeoManager.cxx:3766
 TGeoManager.cxx:3767
 TGeoManager.cxx:3768
 TGeoManager.cxx:3769
 TGeoManager.cxx:3770
 TGeoManager.cxx:3771
 TGeoManager.cxx:3772
 TGeoManager.cxx:3773
 TGeoManager.cxx:3774
 TGeoManager.cxx:3775
 TGeoManager.cxx:3776
 TGeoManager.cxx:3777
 TGeoManager.cxx:3778
 TGeoManager.cxx:3779
 TGeoManager.cxx:3780
 TGeoManager.cxx:3781
 TGeoManager.cxx:3782
 TGeoManager.cxx:3783
 TGeoManager.cxx:3784
 TGeoManager.cxx:3785
 TGeoManager.cxx:3786
 TGeoManager.cxx:3787
 TGeoManager.cxx:3788
 TGeoManager.cxx:3789
 TGeoManager.cxx:3790
 TGeoManager.cxx:3791
 TGeoManager.cxx:3792
 TGeoManager.cxx:3793
 TGeoManager.cxx:3794
 TGeoManager.cxx:3795
 TGeoManager.cxx:3796
 TGeoManager.cxx:3797
 TGeoManager.cxx:3798
 TGeoManager.cxx:3799
 TGeoManager.cxx:3800
 TGeoManager.cxx:3801
 TGeoManager.cxx:3802
 TGeoManager.cxx:3803
 TGeoManager.cxx:3804
 TGeoManager.cxx:3805
 TGeoManager.cxx:3806
 TGeoManager.cxx:3807