ROOT logo
ROOT » GEOM » GEOM » TGeoNavigator

class TGeoNavigator: public TObject

 TGeoNavigator


   Class providing navigation API for TGeo geometries. Several instances are
 allowed for a single geometry.
 A default navigator is provided for any geometry but one may add several
 others for parallel navigation:

	TGeoNavigator *navig = new TGeoNavigator(gGeoManager);
	Int_t inav = gGeoManager->AddNavigator(navig);
	gGeoManager->SetCurrentNavigator(inav);

	.... and then switch back to the default navigator:

	gGeoManager->SetCurrentNavigator(0);

Function Members (Methods)

public:
TGeoNavigator()
TGeoNavigator(TGeoManager* geom)
virtual~TGeoNavigator()
voidTObject::AbstractMethod(const char* method) const
virtual voidTObject::AppendPad(Option_t* option = "")
virtual voidTObject::Browse(TBrowser* b)
voidBuildCache(Bool_t dummy = kFALSE, Bool_t nodeid = kFALSE)
Bool_tcd(const char* path = "")
voidCdDown(Int_t index)
voidCdNext()
voidCdNode(Int_t nodeid)
voidCdTop()
voidCdUp()
Bool_tCheckPath(const char* path) const
static TClass*Class()
virtual const char*TObject::ClassName() const
virtual voidTObject::Clear(Option_t* = "")
virtual TObject*TObject::Clone(const char* newname = "") const
virtual Int_tTObject::Compare(const TObject* obj) const
virtual voidTObject::Copy(TObject& object) const
TGeoNode*CrossBoundaryAndLocate(Bool_t downwards, TGeoNode* skipnode)
virtual voidTObject::Delete(Option_t* option = "")MENU
virtual Int_tTObject::DistancetoPrimitive(Int_t px, Int_t py)
voidDoBackupState()
voidDoRestoreState()
virtual voidTObject::Draw(Option_t* option = "")
virtual voidTObject::DrawClass() constMENU
virtual TObject*TObject::DrawClone(Option_t* option = "") constMENU
virtual voidTObject::Dump() constMENU
virtual voidTObject::Error(const char* method, const char* msgfmt) const
virtual voidTObject::Execute(const char* method, const char* params, Int_t* error = 0)
virtual voidTObject::Execute(TMethod* method, TObjArray* params, Int_t* error = 0)
virtual voidTObject::ExecuteEvent(Int_t event, Int_t px, Int_t py)
virtual voidTObject::Fatal(const char* method, const char* msgfmt) const
TGeoNode*FindNextBoundary(Double_t stepmax = TGeoShape::Big(), const char* path = "", Bool_t frombdr = kFALSE)
TGeoNode*FindNextBoundaryAndStep(Double_t stepmax = TGeoShape::Big(), Bool_t compsafe = kFALSE)
TGeoNode*FindNextDaughterBoundary(Double_t* point, Double_t* dir, Int_t& idaughter, Bool_t compmatrix = kFALSE)
TGeoNode*FindNode(Bool_t safe_start = kTRUE)
TGeoNode*FindNode(Double_t x, Double_t y, Double_t z)
Double_t*FindNormal(Bool_t forward = kTRUE)
Double_t*FindNormalFast()
virtual TObject*TObject::FindObject(const char* name) const
virtual TObject*TObject::FindObject(const TObject* obj) const
voidGetBranchNames(Int_t* names) const
voidGetBranchNumbers(Int_t* copyNumbers, Int_t* volumeNumbers) const
voidGetBranchOnlys(Int_t* isonly) const
TGeoNodeCache*GetCache() const
const Double_t*GetCldir() const
const Double_t*GetCldirChecked() const
const Double_t*GetCurrentDirection() const
TGeoHMatrix*GetCurrentMatrix() const
TGeoNode*GetCurrentNode() const
Int_tGetCurrentNodeId() const
const Double_t*GetCurrentPoint() const
TGeoVolume*GetCurrentVolume() const
virtual Option_t*TObject::GetDrawOption() const
static Long_tTObject::GetDtorOnly()
TGeoHMatrix*GetHMatrix()
virtual const char*TObject::GetIconName() const
const Double_t*GetLastPoint() const
Double_tGetLastSafety() const
Int_tGetLevel() const
TGeoNode*GetMother(Int_t up = 1) const
TGeoHMatrix*GetMotherMatrix(Int_t up = 1) const
virtual const char*TObject::GetName() const
Int_tGetNextDaughterIndex() const
TGeoNode*GetNextNode() const
Int_tGetNmany() const
Int_tGetNodeId() const
const Double_t*GetNormal() const
virtual char*TObject::GetObjectInfo(Int_t px, Int_t py) const
static Bool_tTObject::GetObjectStat()
virtual Option_t*TObject::GetOption() const
const char*GetPath() const
Double_tGetSafeDistance() const
Int_tGetSafeLevel() const
Int_tGetStackLevel() const
Double_tGetStep() const
virtual const char*TObject::GetTitle() const
virtual UInt_tTObject::GetUniqueID() const
Int_tGetVirtualLevel()
Bool_tGotoSafeLevel()
virtual Bool_tTObject::HandleTimer(TTimer* timer)
virtual ULong_tTObject::Hash() const
virtual voidTObject::Info(const char* method, const char* msgfmt) const
virtual Bool_tTObject::InheritsFrom(const char* classname) const
virtual Bool_tTObject::InheritsFrom(const TClass* cl) const
TGeoNode*InitTrack(const Double_t* point, const Double_t* dir)
TGeoNode*InitTrack(Double_t x, Double_t y, Double_t z, Double_t nx, Double_t ny, Double_t nz)
virtual voidTObject::Inspect() constMENU
voidInspectState() const
voidTObject::InvertBit(UInt_t f)
virtual TClass*IsA() const
Bool_tIsCheckingOverlaps() const
Bool_tIsCurrentOverlapping() const
Bool_tIsEntering() const
virtual Bool_tTObject::IsEqual(const TObject* obj) const
Bool_tIsExiting() const
virtual Bool_tTObject::IsFolder() const
Bool_tIsNullStep() const
Bool_tIsOnBoundary() const
Bool_tTObject::IsOnHeap() const
Bool_tIsOutside() const
Bool_tIsSafeStep(Double_t proposed, Double_t& newsafety) const
Bool_tIsSameLocation() const
Bool_tIsSameLocation(Double_t x, Double_t y, Double_t z, Bool_t change = kFALSE)
Bool_tIsSamePoint(Double_t x, Double_t y, Double_t z) const
virtual Bool_tTObject::IsSortable() const
Bool_tIsStartSafe() const
Bool_tIsStepEntering() const
Bool_tIsStepExiting() const
Bool_tTObject::IsZombie() const
voidLocalToMaster(const Double_t* local, Double_t* master) const
voidLocalToMasterBomb(const Double_t* local, Double_t* master) const
voidLocalToMasterVect(const Double_t* local, Double_t* master) const
virtual voidTObject::ls(Option_t* option = "") const
voidMasterToLocal(const Double_t* master, Double_t* local) const
voidMasterToLocalBomb(const Double_t* master, Double_t* local) const
voidMasterToLocalVect(const Double_t* master, Double_t* local) const
voidMasterToTop(const Double_t* master, Double_t* top) const
voidTObject::MayNotUse(const char* method) const
virtual Bool_tTObject::Notify()
voidTObject::Obsolete(const char* method, const char* asOfVers, const char* removedFromVers) const
static voidTObject::operator delete(void* ptr)
static voidTObject::operator delete(void* ptr, void* vp)
static voidTObject::operator delete[](void* ptr)
static voidTObject::operator delete[](void* ptr, void* vp)
void*TObject::operator new(size_t sz)
void*TObject::operator new(size_t sz, void* vp)
void*TObject::operator new[](size_t sz)
void*TObject::operator new[](size_t sz, void* vp)
virtual voidTObject::Paint(Option_t* option = "")
virtual voidTObject::Pop()
voidPopDummy(Int_t ipop = 9999)
Bool_tPopPath()
Bool_tPopPath(Int_t index)
Bool_tPopPoint()
Bool_tPopPoint(Int_t index)
virtual voidTObject::Print(Option_t* option = "") const
Int_tPushPath(Int_t startlevel = 0)
Int_tPushPoint(Int_t startlevel = 0)
virtual Int_tTObject::Read(const char* name)
virtual voidTObject::RecursiveRemove(TObject* obj)
voidResetAll()
voidTObject::ResetBit(UInt_t f)
voidResetState()
Double_tSafety(Bool_t inside = kFALSE)
virtual voidTObject::SaveAs(const char* filename = "", Option_t* option = "") constMENU
virtual voidTObject::SavePrimitive(ostream& out, Option_t* option = "")
TGeoNode*SearchNode(Bool_t downwards = kFALSE, const TGeoNode* skipnode = 0)
voidTObject::SetBit(UInt_t f)
voidTObject::SetBit(UInt_t f, Bool_t set)
voidSetCheckingOverlaps(Bool_t flag = kTRUE)
voidSetCldirChecked(Double_t* dir)
voidSetCurrentDirection(const Double_t* dir)
voidSetCurrentDirection(Double_t nx, Double_t ny, Double_t nz)
voidSetCurrentPoint(const Double_t* point)
voidSetCurrentPoint(Double_t x, Double_t y, Double_t z)
virtual voidTObject::SetDrawOption(Option_t* option = "")MENU
static voidTObject::SetDtorOnly(void* obj)
voidSetLastPoint(Double_t x, Double_t y, Double_t z)
voidSetLastSafetyForPoint(Double_t safe, const Double_t* point)
static voidTObject::SetObjectStat(Bool_t stat)
voidSetOutside(Bool_t flag = kTRUE)
voidSetStartSafe(Bool_t flag = kTRUE)
voidSetStep(Double_t step)
virtual voidTObject::SetUniqueID(UInt_t uid)
virtual voidShowMembers(TMemberInspector& insp)
TGeoNode*Step(Bool_t is_geom = kTRUE, Bool_t cross = kTRUE)
virtual voidStreamer(TBuffer& b)
voidStreamerNVirtual(TBuffer& b)
virtual voidTObject::SysError(const char* method, const char* msgfmt) const
Bool_tTObject::TestBit(UInt_t f) const
Int_tTObject::TestBits(UInt_t f) const
voidTopToMaster(const Double_t* top, Double_t* master) const
virtual voidTObject::UseCurrentStyle()
virtual voidTObject::Warning(const char* method, const char* msgfmt) const
virtual Int_tTObject::Write(const char* name = 0, Int_t option = 0, Int_t bufsize = 0)
virtual Int_tTObject::Write(const char* name = 0, Int_t option = 0, Int_t bufsize = 0) const
protected:
TGeoNavigator(const TGeoNavigator&)
TGeoNode*CrossDivisionCell()
virtual voidTObject::DoError(int level, const char* location, const char* fmt, va_list va) const
TGeoNode*FindInCluster(Int_t* cluster, Int_t nc)
Int_tGetTouchedCluster(Int_t start, Double_t* point, Int_t* check_list, Int_t ncheck, Int_t* result)
voidTObject::MakeZombie()
TGeoNavigator&operator=(const TGeoNavigator&)
voidSafetyOverlaps()

Data Members

private:
TGeoCacheState*fBackupState! backup state
TGeoNodeCache*fCache! cache of states
Double_tfCldir[3]! unit vector to current closest shape
Double_tfCldirChecked[3]! unit vector to current checked shape
TGeoHMatrix*fCurrentMatrix! current stored global matrix
TGeoNode*fCurrentNode! current node
Bool_tfCurrentOverlapping! flags the type of the current node
TGeoVolume*fCurrentVolume! current volume
Double_tfDirection[3]! current direction
TGeoNode*fForcedNode! current point is supposed to be inside this node
TGeoManager*fGeometry! current geometry
TGeoHMatrix*fGlobalMatrix! current pointer to cached global matrix
Bool_tfIsEntering! flag if current step just got into a new node
Bool_tfIsExiting! flag that current track is about to leave current node
Bool_tfIsNullStep! flag that last geometric step was null
Bool_tfIsOnBoundary! flag that current point is on some boundary
Bool_tfIsOutside! flag that current point is outside geometry
Bool_tfIsSameLocation! flag that a new point is in the same node as previous
Bool_tfIsStepEntering! flag that next geometric step will enter new volume
Bool_tfIsStepExiting! flaag that next geometric step will exit current volume
TGeoNode*fLastNode! last searched node
Double_tfLastPoint[3]! last point for which safety was computed
Double_tfLastSafety! last computed safety radius
Int_tfLevel! current geometry level;
Int_tfNextDaughterIndex! next daughter index after FindNextBoundary
TGeoNode*fNextNode! next node that will be crossed
Int_tfNmany! number of overlapping nodes on current branch
Double_tfNormal[3]! cosine of incident angle on current checked surface
Int_t*fOverlapClusters! internal array for overlaps
Int_tfOverlapMark! current recursive position in fOverlapClusters
Int_tfOverlapSize! current size of fOverlapClusters
TStringfPath! path to current node
Double_tfPoint[3]! current point
Double_tfSafety! safety radius from current point
Bool_tfSearchOverlaps! flag set when an overlapping cluster is searched
Bool_tfStartSafe! flag a safe start for point classification
Double_tfStep! step to be done from current point and direction
TGeoNode*fTopNode! top physical node

Class Charts

Inheritance Inherited Members Includes Libraries
Class Charts

Function documentation

TGeoNavigator()
 dummy constructor
TGeoNavigator(TGeoManager* geom)
 Default constructor.
TGeoNavigator(const TGeoNavigator& )
 Copy constructor.
TGeoNavigator& operator=(const TGeoNavigator& )
assignment operator
~TGeoNavigator()
 Destructor.
void BuildCache(Bool_t dummy = kFALSE, Bool_t nodeid = kFALSE)
 Builds the cache for physical nodes and global matrices.
Bool_t cd(const char* path = "")
 Browse the tree of nodes starting from top node according to pathname.
 Changes the path accordingly.
Bool_t CheckPath(const char* path) const
 Check if a geometry path is valid without changing the state of the navigator.
void 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)
void 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.
void CdUp()
 Go one level up in geometry. Updates cache accordingly.
 Determine the overlapping state of current node.
void CdTop()
 Make top level node the current node. Updates the cache accordingly.
 Determine the overlapping state of current node.
void CdNext()
 Do a cd to the node found next by FindNextBoundary
void GetBranchNames(Int_t* names) const
 Fill volume names of current branch into an array.
void GetBranchNumbers(Int_t* copyNumbers, Int_t* volumeNumbers) const
 Fill node copy numbers of current branch into an array.
void GetBranchOnlys(Int_t* isonly) const
 Fill node copy numbers of current branch into an array.
TGeoNode * CrossDivisionCell()
 Cross a division cell. Distance to exit contained in fStep, current node
 points to the cell node.
TGeoNode * CrossBoundaryAndLocate(Bool_t downwards, TGeoNode* skipnode)
 Cross next boundary and locate within current node
 The current point must be on the boundary of fCurrentNode.
TGeoNode * FindNextBoundary(Double_t stepmax = TGeoShape::Big(), const char* path = "", Bool_t frombdr = kFALSE)
 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.
TGeoNode * FindNextDaughterBoundary(Double_t* point, Double_t* dir, Int_t& idaughter, Bool_t compmatrix = kFALSE)
 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.
TGeoNode * FindNextBoundaryAndStep(Double_t stepmax = TGeoShape::Big(), Bool_t compsafe = kFALSE)
 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.
TGeoNode * FindNode(Bool_t safe_start = kTRUE)
 Returns deepest node containing current point.
TGeoNode * FindNode(Double_t x, Double_t y, Double_t z)
 Returns deepest node containing current point.
Double_t * FindNormalFast()
 Computes fast normal to next crossed boundary, assuming that the current point
 is close enough to the boundary. Works only after calling FindNextBoundary.
Double_t * FindNormal(Bool_t forward = kTRUE)
 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.
TGeoNode * InitTrack(const Double_t* point, const Double_t* dir)
 Initialize current point and current direction vector (normalized)
 in MARS. Return corresponding node.
TGeoNode * 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.
void ResetState()
 Reset current state flags.
Double_t Safety(Bool_t inside = kFALSE)
 Compute safe distance from the current point. This represent the distance
 from POINT to the closest boundary.
void SafetyOverlaps()
 Compute safe distance from the current point within an overlapping node
TGeoNode * SearchNode(Bool_t downwards = kFALSE, const TGeoNode* skipnode = 0)
 Returns the deepest node containing fPoint, which must be set a priori.
TGeoNode * FindInCluster(Int_t* cluster, Int_t nc)
 Find a node inside a cluster of overlapping nodes. Current node must
 be on top of all the nodes in cluster. Always nc>1.
Int_t GetTouchedCluster(Int_t start, Double_t* point, Int_t* check_list, Int_t ncheck, Int_t* result)
 Make the cluster of overlapping nodes in a voxel, containing point in reference
 of the mother. Returns number of nodes containing the point. Nodes should not be
 offsets.
TGeoNode * Step(Bool_t is_geom = kTRUE, Bool_t cross = kTRUE)
 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.
Int_t GetVirtualLevel()
 Find level of virtuality of current overlapping node (number of levels
 up having the same tracking media.
Bool_t GotoSafeLevel()
 Go upwards the tree until a non-overlaping node
Int_t GetSafeLevel() const
 Go upwards the tree until a non-overlaping node
void InspectState() const
 Inspects path and all flags for the current state.
Bool_t IsSameLocation(Double_t x, Double_t y, Double_t z, Bool_t change = kFALSE)
 Checks if point (x,y,z) is still in the current node.
 check if this is an overlapping node
Bool_t IsSafeStep(Double_t proposed, Double_t& newsafety) const
 In case a previous safety value was computed, check if the safety region is
 still safe for the current point and proposed step. Return value changed only
 if proposed distance is safe.
Bool_t 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.
void DoBackupState()
 Backup the current state without affecting the cache stack.
void DoRestoreState()
 Restore a backed-up state without affecting the cache stack.
TGeoHMatrix * GetHMatrix()
 Return stored current matrix (global matrix of the next touched node).
const char * GetPath() const
 Get path to the current node in the form /node0/node1/...
void MasterToTop(const Double_t* master, Double_t* top) const
 Convert coordinates from master volume frame to top.
void TopToMaster(const Double_t* top, Double_t* master) const
 Convert coordinates from top volume frame to master.
void ResetAll()
 Reset the navigator.
Int_t GetNmany() const
--- geometry queries
{return fNmany;}
const Double_t * GetLastPoint() const
{return fLastPoint;}
Double_t GetSafeDistance() const
{return fSafety;}
Double_t GetLastSafety() const
{return fLastSafety;}
Double_t GetStep() const
{return fStep;}
Bool_t IsSameLocation(Double_t x, Double_t y, Double_t z, Bool_t change = kFALSE)
Bool_t IsStartSafe() const
{return fStartSafe;}
void SetStartSafe(Bool_t flag = kTRUE)
{fStartSafe=flag;}
void SetStep(Double_t step)
{fStep=step;}
Bool_t IsCheckingOverlaps() const
{return fSearchOverlaps;}
Bool_t IsCurrentOverlapping() const
Bool_t IsEntering() const
{return fIsEntering;}
Bool_t IsExiting() const
{return fIsExiting;}
Bool_t IsStepEntering() const
{return fIsStepEntering;}
Bool_t IsStepExiting() const
{return fIsStepExiting;}
Bool_t IsOutside() const
{return fIsOutside;}
Bool_t IsOnBoundary() const
{return fIsOnBoundary;}
Bool_t IsNullStep() const
{return fIsNullStep;}
void SetCheckingOverlaps(Bool_t flag = kTRUE)
{fSearchOverlaps = flag;}
void SetOutside(Bool_t flag = kTRUE)
--- modeler state getters/setters
{fIsOutside = flag;}
Int_t GetNodeId() const
{return fCache->GetNodeId();}
Int_t GetNextDaughterIndex() const
TGeoNode * GetNextNode() const
{return fNextNode;}
TGeoNode * GetMother(Int_t up = 1) const
{return fCache->GetMother(up);}
TGeoHMatrix * GetMotherMatrix(Int_t up = 1) const
{return fCache->GetMotherMatrix(up);}
TGeoHMatrix * GetCurrentMatrix() const
TGeoNode * GetCurrentNode() const
{return fCurrentNode;}
Int_t GetCurrentNodeId() const
const Double_t * GetCurrentPoint() const
{return fPoint;}
const Double_t * GetCurrentDirection() const
{return fDirection;}
TGeoVolume * GetCurrentVolume() const
{return fCurrentNode->GetVolume();}
const Double_t * GetCldirChecked() const
{return fCldirChecked;}
const Double_t * GetCldir() const
   Double_t               GetNormalChecked() const {return fNormalChecked;}
{return fCldir;}
const Double_t * GetNormal() const
{return fNormal;}
Int_t GetLevel() const
{return fLevel;}
Int_t GetStackLevel() const
{return fCache->GetStackLevel();}
void SetCurrentPoint(const Double_t* point)
{memcpy(fPoint,point,3*sizeof(Double_t));}
void SetCurrentPoint(Double_t x, Double_t y, Double_t z)
void SetLastPoint(Double_t x, Double_t y, Double_t z)
void SetCurrentDirection(const Double_t* dir)
{memcpy(fDirection,dir,3*sizeof(Double_t));}
void SetCurrentDirection(Double_t nx, Double_t ny, Double_t nz)
void SetCldirChecked(Double_t* dir)
   void                   SetNormalChecked(Double_t norm) {fNormalChecked=norm;}
{memcpy(fCldirChecked, dir, 3*sizeof(Double_t));}
void SetLastSafetyForPoint(Double_t safe, const Double_t* point)
{fLastSafety=safe; memcpy(fLastPoint,point,3*sizeof(Double_t));}
void LocalToMaster(const Double_t* local, Double_t* master) const
--- point/vector reference frame conversion
{fCache->LocalToMaster(local, master);}
void LocalToMasterVect(const Double_t* local, Double_t* master) const
{fCache->LocalToMasterVect(local, master);}
void LocalToMasterBomb(const Double_t* local, Double_t* master) const
{fCache->LocalToMasterBomb(local, master);}
void MasterToLocal(const Double_t* master, Double_t* local) const
{fCache->MasterToLocal(master, local);}
void MasterToLocalVect(const Double_t* master, Double_t* local) const
{fCache->MasterToLocalVect(master, local);}
void MasterToLocalBomb(const Double_t* master, Double_t* local) const
{fCache->MasterToLocalBomb(master, local);}
TGeoNodeCache * GetCache() const
   void                   SetCache(const TGeoNodeCache *cache) {fCache = (TGeoNodeCache*)cache;}
--- stack manipulation
{return fCache;}
Int_t PushPath(Int_t startlevel = 0)
{return fCache->PushState(fCurrentOverlapping, startlevel, fNmany);}
Bool_t PopPath()
Bool_t PopPath(Int_t index)
Int_t PushPoint(Int_t startlevel = 0)
Bool_t PopPoint()
Bool_t PopPoint(Int_t index)
void PopDummy(Int_t ipop = 9999)
{fCache->PopDummy(ipop);}