Logo ROOT  
Reference Guide
TGeoNavigator.h
Go to the documentation of this file.
1// @(#)root/geom:$Id$
2// Author: Mihaela Gheata 30/05/07
3
4/*************************************************************************
5 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
6 * All rights reserved. *
7 * *
8 * For the licensing terms see $ROOTSYS/LICENSE. *
9 * For the list of contributors see $ROOTSYS/README/CREDITS. *
10 *************************************************************************/
11
12#ifndef ROOT_TGeoNavigator
13#define ROOT_TGeoNavigator
14
15#include "TObject.h"
16
17#include "TGeoCache.h"
18
19////////////////////////////////////////////////////////////////////////////
20// //
21// TGeoNavigator - Class containing the implementation of all navigation //
22// methods.
23// //
24////////////////////////////////////////////////////////////////////////////
25
26class TGeoManager;
27class TGeoNode;
28class TGeoVolume;
29class TGeoMatrix;
30class TGeoHMatrix;
31
32
33class TGeoNavigator : public TObject
34{
35
36protected:
37 TGeoNavigator(const TGeoNavigator &) = delete;
39 TGeoNode *FindInCluster(Int_t *cluster, Int_t nc);
40 Int_t GetTouchedCluster(Int_t start, Double_t *point, Int_t *check_list,
41 Int_t ncheck, Int_t *result);
43 void SafetyOverlaps();
44
45private :
46 Double_t fStep; //! step to be done from current point and direction
47 Double_t fSafety; //! safety radius from current point
48 Double_t fLastSafety; //! last computed safety radius
49 Double_t fNormal[3]; //! cosine of incident angle on current checked surface
50 Double_t fCldir[3]; //! unit vector to current closest shape
51 Double_t fCldirChecked[3]; //! unit vector to current checked shape
52 Double_t fPoint[3]; //! current point
53 Double_t fDirection[3]; //! current direction
54 Double_t fLastPoint[3]; //! last point for which safety was computed
55 Int_t fThreadId; //! thread id for this navigator
56 Int_t fLevel; //! current geometry level;
57 Int_t fNmany; //! number of overlapping nodes on current branch
58 Int_t fNextDaughterIndex; //! next daughter index after FindNextBoundary
59 Int_t fOverlapSize; //! current size of fOverlapClusters
60 Int_t fOverlapMark; //! current recursive position in fOverlapClusters
61 Int_t *fOverlapClusters; //! internal array for overlaps
62 Bool_t fSearchOverlaps; //! flag set when an overlapping cluster is searched
63 Bool_t fCurrentOverlapping; //! flags the type of the current node
64 Bool_t fStartSafe; //! flag a safe start for point classification
65 Bool_t fIsEntering; //! flag if current step just got into a new node
66 Bool_t fIsExiting; //! flag that current track is about to leave current node
67 Bool_t fIsStepEntering; //! flag that next geometric step will enter new volume
68 Bool_t fIsStepExiting; //! flag that next geometric step will exit current volume
69 Bool_t fIsOutside; //! flag that current point is outside geometry
70 Bool_t fIsOnBoundary; //! flag that current point is on some boundary
71 Bool_t fIsSameLocation; //! flag that a new point is in the same node as previous
72 Bool_t fIsNullStep; //! flag that last geometric step was null
73 TGeoManager *fGeometry; //! current geometry
74 TGeoNodeCache *fCache; //! cache of states
75 TGeoVolume *fCurrentVolume; //! current volume
76 TGeoNode *fCurrentNode; //! current node
77 TGeoNode *fTopNode; //! top physical node
78 TGeoNode *fLastNode; //! last searched node
79 TGeoNode *fNextNode; //! next node that will be crossed
80 TGeoNode *fForcedNode; //! current point is supposed to be inside this node
81 TGeoCacheState *fBackupState; //! backup state
82 TGeoHMatrix *fCurrentMatrix; //! current stored global matrix
83 TGeoHMatrix *fGlobalMatrix; //! current pointer to cached global matrix
84 TGeoHMatrix *fDivMatrix; //! current local matrix of the selected division cell
85 TString fPath; //! path to current node
86
87public :
90 virtual ~TGeoNavigator();
91
92 void BuildCache(Bool_t dummy=kFALSE, Bool_t nodeid=kFALSE);
93 Bool_t cd(const char *path="");
94 Bool_t CheckPath(const char *path) const;
95 void CdNode(Int_t nodeid);
96 void CdDown(Int_t index);
97 void CdDown(TGeoNode *node);
98 void CdUp();
99 void CdTop();
100 void CdNext();
101 void GetBranchNames(Int_t *names) const;
102 void GetBranchNumbers(Int_t *copyNumbers, Int_t *volumeNumbers) const;
103 void GetBranchOnlys(Int_t *isonly) const;
104 Int_t GetNmany() const {return fNmany;}
105 //--- geometry queries
106 TGeoNode *CrossBoundaryAndLocate(Bool_t downwards, TGeoNode *skipnode);
107 TGeoNode *FindNextBoundary(Double_t stepmax=TGeoShape::Big(),const char *path="", Bool_t frombdr=kFALSE);
108 TGeoNode *FindNextDaughterBoundary(Double_t *point, Double_t *dir, Int_t &idaughter, Bool_t compmatrix=kFALSE);
110 TGeoNode *FindNode(Bool_t safe_start=kTRUE);
114 TGeoNode *InitTrack(const Double_t *point, const Double_t *dir);
116 void ResetState();
117 void ResetAll();
119 TGeoNode *SearchNode(Bool_t downwards=kFALSE, const TGeoNode *skipnode=0);
120 TGeoNode *Step(Bool_t is_geom=kTRUE, Bool_t cross=kTRUE);
121 const Double_t *GetLastPoint() const {return fLastPoint;}
124 Int_t GetSafeLevel() const;
127 Double_t GetStep() const {return fStep;}
128 Int_t GetThreadId() const {return fThreadId;}
129 void InspectState() const;
130 Bool_t IsSafeStep(Double_t proposed, Double_t &newsafety) const;
134 Bool_t IsStartSafe() const {return fStartSafe;}
136 void SetStep(Double_t step) {fStep=step;}
139 Bool_t IsEntering() const {return fIsEntering;}
140 Bool_t IsExiting() const {return fIsExiting;}
143 Bool_t IsOutside() const {return fIsOutside;}
145 Bool_t IsNullStep() const {return fIsNullStep;}
147 void SetOutside(Bool_t flag=kTRUE) {fIsOutside = flag;}
148 //--- modeler state getters/setters
149 void DoBackupState();
150 void DoRestoreState();
151 Int_t GetNodeId() const {return fCache->GetNodeId();}
153 TGeoNode *GetNextNode() const {return fNextNode;}
154 TGeoNode *GetMother(Int_t up=1) const {return fCache->GetMother(up);}
160 const Double_t *GetCurrentPoint() const {return fPoint;}
161 const Double_t *GetCurrentDirection() const {return fDirection;}
163 const Double_t *GetCldirChecked() const {return fCldirChecked;}
164 const Double_t *GetCldir() const {return fCldir;}
166// Double_t GetNormalChecked() const {return fNormalChecked;}
167 const Double_t *GetNormal() const {return fNormal;}
168 Int_t GetLevel() const {return fLevel;}
169 const char *GetPath() const;
171 void SetCurrentPoint(const Double_t *point) {memcpy(fPoint,point,3*sizeof(Double_t));}
173 fPoint[0]=x; fPoint[1]=y; fPoint[2]=z;}
175 fLastPoint[0]=x; fLastPoint[1]=y; fLastPoint[2]=z;}
176 void SetCurrentDirection(const Double_t *dir) {memcpy(fDirection,dir,3*sizeof(Double_t));}
178 fDirection[0]=nx; fDirection[1]=ny; fDirection[2]=nz;}
179// void SetNormalChecked(Double_t norm) {fNormalChecked=norm;}
180 void SetCldirChecked(Double_t *dir) {memcpy(fCldirChecked, dir, 3*sizeof(Double_t));}
181 void SetLastSafetyForPoint(Double_t safe, const Double_t *point) {fLastSafety=safe; memcpy(fLastPoint,point,3*sizeof(Double_t));}
183
184 //--- point/vector reference frame conversion
185 void LocalToMaster(const Double_t *local, Double_t *master) const {fCache->LocalToMaster(local, master);}
186 void LocalToMasterVect(const Double_t *local, Double_t *master) const {fCache->LocalToMasterVect(local, master);}
187 void LocalToMasterBomb(const Double_t *local, Double_t *master) const {fCache->LocalToMasterBomb(local, master);}
188 void MasterToLocal(const Double_t *master, Double_t *local) const {fCache->MasterToLocal(master, local);}
189 void MasterToLocalVect(const Double_t *master, Double_t *local) const {fCache->MasterToLocalVect(master, local);}
190 void MasterToLocalBomb(const Double_t *master, Double_t *local) const {fCache->MasterToLocalBomb(master, local);}
191 void MasterToTop(const Double_t *master, Double_t *top) const;
192 void TopToMaster(const Double_t *top, Double_t *master) const;
193 TGeoNodeCache *GetCache() const {return fCache;}
194// void SetCache(const TGeoNodeCache *cache) {fCache = (TGeoNodeCache*)cache;}
195 //--- stack manipulation
196 Int_t PushPath(Int_t startlevel=0) {return fCache->PushState(fCurrentOverlapping, startlevel, fNmany);}
199 Int_t PushPoint(Int_t startlevel=0) {return fCache->PushState(fCurrentOverlapping, startlevel,fNmany,fPoint);}
202 void PopDummy(Int_t ipop=9999) {fCache->PopDummy(ipop);}
203
204 ClassDef(TGeoNavigator, 0) // geometry navigator class
205};
206
207#include "TObjArray.h"
208
209////////////////////////////////////////////////////////////////////////////
210// //
211// TGeoNavigatorArray - Class representing an array of navigators working //
212// in a single thread. //
213// //
214////////////////////////////////////////////////////////////////////////////
215
217{
218private:
219 TGeoNavigator *fCurrentNavigator; // Current navigator
220 TGeoManager *fGeoManager; // Manager to which it applies
221
224
225public:
229
233
234 ClassDef(TGeoNavigatorArray, 0) // An array of navigators
235};
236#endif
237
int Int_t
Definition: RtypesCore.h:45
const Bool_t kFALSE
Definition: RtypesCore.h:101
bool Bool_t
Definition: RtypesCore.h:63
double Double_t
Definition: RtypesCore.h:59
const Bool_t kTRUE
Definition: RtypesCore.h:100
#define ClassDef(name, id)
Definition: Rtypes.h:325
virtual void SetOwner(Bool_t enable=kTRUE)
Set whether this collection is the owner (enable==true) of its content.
Class storing the state of the cache at a given moment.
Definition: TGeoCache.h:29
Matrix class used for computing global transformations Should NOT be used for node definition.
Definition: TGeoMatrix.h:421
The manager class for any TGeo geometry.
Definition: TGeoManager.h:45
Geometrical transformation package.
Definition: TGeoMatrix.h:41
virtual ~TGeoNavigatorArray()
TGeoNavigatorArray(TGeoManager *mgr)
TGeoNavigator * fCurrentNavigator
TGeoNavigatorArray(const TGeoNavigatorArray &)
TGeoNavigator * AddNavigator()
Add a new navigator to the array.
TGeoNavigator * GetCurrentNavigator() const
TGeoNavigatorArray & operator=(const TGeoNavigatorArray &)
TGeoManager * fGeoManager
TGeoNavigator * SetCurrentNavigator(Int_t inav)
Class providing navigation API for TGeo geometries.
Definition: TGeoNavigator.h:34
void CdUp()
Go one level up in geometry.
void DoBackupState()
Backup the current state without affecting the cache stack.
TGeoNode * GetMother(Int_t up=1) const
void SetCurrentPoint(Double_t x, Double_t y, Double_t z)
void DoRestoreState()
Restore a backed-up state without affecting the cache stack.
Double_t fPoint[3]
unit vector to current checked shape
Definition: TGeoNavigator.h:52
Bool_t IsStepExiting() const
Bool_t fSearchOverlaps
internal array for overlaps
Definition: TGeoNavigator.h:62
Bool_t fIsExiting
flag if current step just got into a new node
Definition: TGeoNavigator.h:66
TString fPath
current local matrix of the selected division cell
Definition: TGeoNavigator.h:85
TGeoHMatrix * fDivMatrix
current pointer to cached global matrix
Definition: TGeoNavigator.h:84
Bool_t PopPath()
TGeoNode * CrossBoundaryAndLocate(Bool_t downwards, TGeoNode *skipnode)
Cross next boundary and locate within current node The current point must be on the boundary of fCurr...
TGeoHMatrix * GetHMatrix()
Return stored current matrix (global matrix of the next touched node).
Bool_t IsCheckingOverlaps() const
virtual ~TGeoNavigator()
Destructor.
void LocalToMaster(const Double_t *local, Double_t *master) const
TGeoNodeCache * fCache
current geometry
Definition: TGeoNavigator.h:74
Bool_t fStartSafe
flags the type of the current node
Definition: TGeoNavigator.h:64
void CdNext()
Do a cd to the node found next by FindNextBoundary.
TGeoNode * GetNextNode() const
Double_t Safety(Bool_t inside=kFALSE)
Compute safe distance from the current point.
const Double_t * GetCldirChecked() const
Bool_t GotoSafeLevel()
Go upwards the tree until a non-overlapping node.
Double_t fNormal[3]
last computed safety radius
Definition: TGeoNavigator.h:49
Double_t GetLastSafety() const
Bool_t PopPoint(Int_t index)
Bool_t cd(const char *path="")
Browse the tree of nodes starting from top node according to pathname.
Double_t fLastPoint[3]
current direction
Definition: TGeoNavigator.h:54
Double_t GetStep() const
Bool_t IsSameLocation() const
Double_t fCldir[3]
cosine of incident angle on current checked surface
Definition: TGeoNavigator.h:50
Bool_t fIsStepEntering
flag that current track is about to leave current node
Definition: TGeoNavigator.h:67
void SetLastPoint(Double_t x, Double_t y, Double_t z)
Int_t GetNodeId() const
void MasterToLocal(const Double_t *master, Double_t *local) const
TGeoNode * SearchNode(Bool_t downwards=kFALSE, const TGeoNode *skipnode=0)
Returns the deepest node containing fPoint, which must be set a priori.
Int_t GetVirtualLevel()
Find level of virtuality of current overlapping node (number of levels up having the same tracking me...
Bool_t PopPoint()
Int_t fOverlapSize
next daughter index after FindNextBoundary
Definition: TGeoNavigator.h:59
TGeoNode * InitTrack(const Double_t *point, const Double_t *dir)
Initialize current point and current direction vector (normalized) in MARS.
const Double_t * GetLastPoint() const
void InspectState() const
Inspects path and all flags for the current state.
Int_t PushPoint(Int_t startlevel=0)
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)...
TGeoNode * FindInCluster(Int_t *cluster, Int_t nc)
Find a node inside a cluster of overlapping nodes.
TGeoNavigator(const TGeoNavigator &)=delete
Double_t fStep
Definition: TGeoNavigator.h:46
Bool_t IsNullStep() const
TGeoVolume * GetCurrentVolume() const
Int_t GetNextDaughterIndex() const
void SafetyOverlaps()
Compute safe distance from the current point within an overlapping node.
TGeoHMatrix * GetCurrentMatrix() const
TGeoNode * CrossDivisionCell()
Cross a division cell.
void ResetState()
Reset current state flags.
Double_t GetSafeDistance() const
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.
Bool_t fIsSameLocation
flag that current point is on some boundary
Definition: TGeoNavigator.h:71
void SetCheckingOverlaps(Bool_t flag=kTRUE)
void GetBranchNumbers(Int_t *copyNumbers, Int_t *volumeNumbers) const
Fill node copy numbers of current branch into an array.
Bool_t CheckPath(const char *path) const
Check if a geometry path is valid without changing the state of the navigator.
void SetOutside(Bool_t flag=kTRUE)
void SetStartSafe(Bool_t flag=kTRUE)
Bool_t IsEntering() const
TGeoHMatrix * GetMotherMatrix(Int_t up=1) const
TGeoVolume * fCurrentVolume
cache of states
Definition: TGeoNavigator.h:75
TGeoNode * fLastNode
top physical node
Definition: TGeoNavigator.h:78
void SetCldirChecked(Double_t *dir)
Int_t fThreadId
last point for which safety was computed
Definition: TGeoNavigator.h:55
void LocalToMasterBomb(const Double_t *local, Double_t *master) const
Double_t fDirection[3]
current point
Definition: TGeoNavigator.h:53
void PopDummy(Int_t ipop=9999)
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.
TGeoNode * FindNextBoundary(Double_t stepmax=TGeoShape::Big(), const char *path="", Bool_t frombdr=kFALSE)
Find distance to next boundary and store it in fStep.
TGeoNode * GetCurrentNode() const
TGeoNode * FindNode(Bool_t safe_start=kTRUE)
Returns deepest node containing current point.
Int_t fOverlapMark
current size of fOverlapClusters
Definition: TGeoNavigator.h:60
TGeoNode * FindNextBoundaryAndStep(Double_t stepmax=TGeoShape::Big(), Bool_t compsafe=kFALSE)
Compute distance to next boundary within STEPMAX.
Bool_t IsOutside() const
Int_t GetThreadId() const
void CdTop()
Make top level node the current node.
void SetStep(Double_t step)
Int_t fNmany
current geometry level;
Definition: TGeoNavigator.h:57
TGeoManager * fGeometry
flag that last geometric step was null
Definition: TGeoNavigator.h:73
TGeoHMatrix * fGlobalMatrix
current stored global matrix
Definition: TGeoNavigator.h:83
void MasterToTop(const Double_t *master, Double_t *top) const
Convert coordinates from master volume frame to top.
Int_t GetCurrentNodeId() const
Double_t * FindNormalFast()
Computes fast normal to next crossed boundary, assuming that the current point is close enough to the...
const Double_t * GetCurrentDirection() const
Bool_t IsExiting() const
Int_t PushPath(Int_t startlevel=0)
Bool_t fIsStepExiting
flag that next geometric step will enter new volume
Definition: TGeoNavigator.h:68
Bool_t fIsOnBoundary
flag that current point is outside geometry
Definition: TGeoNavigator.h:70
void GetBranchOnlys(Int_t *isonly) const
Fill node copy numbers of current branch into an array.
void SetCurrentDirection(Double_t nx, Double_t ny, Double_t nz)
Int_t GetStackLevel() const
const Double_t * GetNormal() const
void TopToMaster(const Double_t *top, Double_t *master) const
Convert coordinates from top volume frame to master.
void SetCurrentPoint(const Double_t *point)
TGeoHMatrix * fCurrentMatrix
backup state
Definition: TGeoNavigator.h:82
Int_t * fOverlapClusters
current recursive position in fOverlapClusters
Definition: TGeoNavigator.h:61
const Double_t * GetCldir() const
TGeoNode * fTopNode
current node
Definition: TGeoNavigator.h:77
void LocalToMasterVect(const Double_t *local, Double_t *master) const
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 curren...
Double_t fLastSafety
safety radius from current point
Definition: TGeoNavigator.h:48
TGeoNavigator()
path to current node
void SetCurrentDirection(const Double_t *dir)
void BuildCache(Bool_t dummy=kFALSE, Bool_t nodeid=kFALSE)
Builds the cache for physical nodes and global matrices.
Int_t fNextDaughterIndex
number of overlapping nodes on current branch
Definition: TGeoNavigator.h:58
Bool_t PopPath(Int_t index)
Bool_t fIsNullStep
flag that a new point is in the same node as previous
Definition: TGeoNavigator.h:72
void SetLastSafetyForPoint(Double_t safe, const Double_t *point)
void CdNode(Int_t nodeid)
Change current path to point to the node having this id.
Bool_t IsCurrentOverlapping() const
TGeoNavigator & operator=(const TGeoNavigator &)=delete
Int_t GetNmany() const
TGeoNodeCache * GetCache() const
TGeoNode * fNextNode
last searched node
Definition: TGeoNavigator.h:79
Double_t fCldirChecked[3]
unit vector to current closest shape
Definition: TGeoNavigator.h:51
void SetLastSafetyForPoint(Double_t safe, Double_t x, Double_t y, Double_t z)
Int_t fLevel
thread id for this navigator
Definition: TGeoNavigator.h:56
void ResetAll()
Reset the navigator.
TGeoCacheState * fBackupState
current point is supposed to be inside this node
Definition: TGeoNavigator.h:81
Int_t GetLevel() const
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.
Bool_t fCurrentOverlapping
flag set when an overlapping cluster is searched
Definition: TGeoNavigator.h:63
Bool_t IsOnBoundary() const
Bool_t fIsOutside
flag that next geometric step will exit current volume
Definition: TGeoNavigator.h:69
void CdDown(Int_t index)
Make a daughter of current node current.
Bool_t fIsEntering
flag a safe start for point classification
Definition: TGeoNavigator.h:65
const Double_t * GetCurrentPoint() const
Bool_t IsStartSafe() const
TGeoNode * fForcedNode
next node that will be crossed
Definition: TGeoNavigator.h:80
TGeoHMatrix * GetDivMatrix() const
void MasterToLocalVect(const Double_t *master, Double_t *local) const
void MasterToLocalBomb(const Double_t *master, Double_t *local) const
const char * GetPath() const
Get path to the current node in the form /node0/node1/...
Bool_t IsStepEntering() const
Int_t GetSafeLevel() const
Go upwards the tree until a non-overlapping node.
TGeoNode * fCurrentNode
current volume
Definition: TGeoNavigator.h:76
Double_t fSafety
step to be done from current point and direction
Definition: TGeoNavigator.h:47
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 ...
void GetBranchNames(Int_t *names) const
Fill volume names of current branch into an array.
Special pool of reusable nodes.
Definition: TGeoCache.h:58
TGeoNode * GetNode() const
Definition: TGeoCache.h:107
void MasterToLocal(const Double_t *master, Double_t *local) const
Point in master frame defined by current matrix converted to local one.
Definition: TGeoCache.cxx:411
void PopDummy(Int_t ipop=9999)
Definition: TGeoCache.h:128
Int_t GetNodeId() const
Get unique node id.
Definition: TGeoCache.cxx:273
TGeoHMatrix * GetMotherMatrix(Int_t up=1) const
Definition: TGeoCache.h:106
void MasterToLocalVect(const Double_t *master, Double_t *local) const
Vector in master frame defined by current matrix converted to local one.
Definition: TGeoCache.cxx:427
void MasterToLocalBomb(const Double_t *master, Double_t *local) const
Point in master frame defined by current matrix converted to local one and rescaled with bomb factor.
Definition: TGeoCache.cxx:443
Bool_t PopState(Int_t &nmany, Double_t *point=0)
Pop next state/point from heap.
Definition: TGeoCache.cxx:370
void LocalToMaster(const Double_t *local, Double_t *master) const
Local point converted to master frame defined by current matrix.
Definition: TGeoCache.cxx:403
void LocalToMasterVect(const Double_t *local, Double_t *master) const
Local vector converted to master frame defined by current matrix.
Definition: TGeoCache.cxx:419
Int_t GetCurrentNodeId() const
Returns a fixed ID for current physical node.
Definition: TGeoCache.cxx:264
Int_t PushState(Bool_t ovlp, Int_t ntmany=0, Int_t startlevel=0, Double_t *point=0)
Push current state into heap.
Definition: TGeoCache.cxx:357
void LocalToMasterBomb(const Double_t *local, Double_t *master) const
Local point converted to master frame defined by current matrix and rescaled with bomb factor.
Definition: TGeoCache.cxx:435
Int_t GetStackLevel() const
Definition: TGeoCache.h:114
TGeoHMatrix * GetCurrentMatrix() const
Definition: TGeoCache.h:103
TGeoNode * GetMother(Int_t up=1) const
Definition: TGeoCache.h:105
Int_t GetLevel() const
Definition: TGeoCache.h:112
A node represent a volume positioned inside another.They store links to both volumes and to the TGeoM...
Definition: TGeoNode.h:41
TGeoVolume * GetVolume() const
Definition: TGeoNode.h:97
static Double_t Big()
Definition: TGeoShape.h:88
TGeoVolume, TGeoVolumeMulti, TGeoVolumeAssembly are the volume classes.
Definition: TGeoVolume.h:49
An array of TObjects.
Definition: TObjArray.h:37
TObject * At(Int_t idx) const
Definition: TObjArray.h:166
Mother of all ROOT objects.
Definition: TObject.h:37
Basic string class.
Definition: TString.h:136
Double_t y[n]
Definition: legend1.C:17
Double_t x[n]
Definition: legend1.C:17
void forward(const LAYERDATA &prevLayerData, LAYERDATA &currLayerData)
apply the weights (and functions) in forward direction of the DNN
Definition: NeuralNet.icc:546