57 fNextDaughterIndex(0),
62 fCurrentOverlapping(kFALSE),
66 fIsStepEntering(kFALSE),
67 fIsStepExiting(kFALSE),
69 fIsOnBoundary(kFALSE),
70 fIsSameLocation(kFALSE),
88 for (
Int_t i=0; i<3; i++) {
91 fCldirChecked[i] = 0.;
107 fNextDaughterIndex(-2),
112 fCurrentOverlapping(
kFALSE),
120 fIsSameLocation(
kTRUE),
140 for (
Int_t i=0; i<3; i++) {
163 fLastSafety(gm.fLastSafety),
167 fNextDaughterIndex(gm.fNextDaughterIndex),
168 fOverlapSize(gm.fOverlapSize),
169 fOverlapMark(gm.fOverlapMark),
170 fOverlapClusters(gm.fOverlapClusters),
171 fSearchOverlaps(gm.fSearchOverlaps),
172 fCurrentOverlapping(gm.fCurrentOverlapping),
173 fStartSafe(gm.fStartSafe),
174 fIsEntering(gm.fIsEntering),
175 fIsExiting(gm.fIsExiting),
176 fIsStepEntering(gm.fIsStepEntering),
177 fIsStepExiting(gm.fIsStepExiting),
178 fIsOutside(gm.fIsOutside),
179 fIsOnBoundary(gm.fIsOnBoundary),
180 fIsSameLocation(gm.fIsSameLocation),
181 fIsNullStep(gm.fIsNullStep),
182 fGeometry(gm.fGeometry),
184 fCurrentVolume(gm.fCurrentVolume),
185 fCurrentNode(gm.fCurrentNode),
186 fTopNode(gm.fTopNode),
187 fLastNode(gm.fLastNode),
188 fNextNode(gm.fNextNode),
189 fForcedNode(gm.fForcedNode),
190 fBackupState(gm.fBackupState),
191 fCurrentMatrix(gm.fCurrentMatrix),
192 fGlobalMatrix(gm.fGlobalMatrix),
196 for (
Int_t i=0; i<3; i++) {
248 for (
Int_t i=0; i<3; i++) {
280 if (nlevel<=0) nlevel = 100;
283 if (first && verbose>0)
Info(
"BuildCache",
"--- Maximum geometry depth set to 100");
285 if (first && verbose>0)
Info(
"BuildCache",
"--- Maximum geometry depth is %i", nlevel);
303 if (!path[0])
return kTRUE;
308 if (ind1 == length-1) ind1 = -1;
315 ind2 = spath.
Index(
"/", ind1+1);
316 if (ind2<0 || ind2==length-1) {
317 if (ind2<0) ind2 =
length;
320 name = spath(ind1+1, ind2-ind1-1);
331 Error(
"cd",
"Path %s not valid", path);
345 if (!path[0])
return kTRUE;
351 if (ind1 == length-1) ind1 = -1;
358 ind2 = spath.
Index(
"/", ind1+1);
359 if (ind2<0 || ind2==length-1) {
360 if (ind2<0) ind2 =
length;
363 name = spath(ind1+1, ind2-ind1-1);
497 if (
fCurrentNode && fNextDaughterIndex<fCurrentNode->GetNdaughters()) {
500 while (nextindex>=0) {
540 Fatal(
"CrossDivisionCell",
"Volume has no pattern finder");
546 Double_t point[3], newpoint[3], dir[3];
604 fPoint[1] += extra*fDirection[1];
605 fPoint[2] += extra*fDirection[2];
608 fPoint[0] -= extra*fDirection[0];
609 fPoint[1] -= extra*fDirection[1];
610 fPoint[2] -= extra*fDirection[2];
611 if (!current)
return 0;
614 while (nextindex>=0) {
629 printf(
"CrossBoundaryAndLocate: Exited geometry\n");
638 printf(
"CrossBoundaryAndLocate: Exited geometry\n");
686 computeGlobal =
kTRUE;
713 printf(
"TGeoManager::FindNextBoundary: point=(%19.16f, %19.16f, %19.16f)\n",
715 printf(
" dir= (%19.16f, %19.16f, %19.16f)\n",
731 printf(
"=== To path: %s\n", path);
732 printf(
"=== local to %s: (%19.16f, %19.16f, %19.16f, %19.16f, %19.16f, %19.16f)\n",
733 tvol->
GetName(), point[0],point[1],point[2],dir[0],dir[1],dir[2]);
736 if (idebug>4)
printf(
"=== volume %s contains point\n", tvol->
GetName());
741 printf(
"=== volume %s does not contain point\n", tvol->
GetName());
746 newpt[0] = point[0] +
fStep*dir[0];
747 newpt[1] = point[1] +
fStep*dir[1];
748 newpt[2] = point[2] +
fStep*dir[2];
749 printf(
"=== Propagated point: (%19.16f, %19.16f, %19.16f)", newpt[0],newpt[1],newpt[2]);
756 printf(
"=== local to %s: (%19.16f, %19.16f, %19.16f, %19.16f, %19.16f, %19.16f)\n",
757 tvol->
GetName(), point[0],point[1],point[2],dir[0],dir[1],dir[2]);
761 printf(
"=== volume %s does not contain point\n", tvol->
GetName());
794 printf(
" -> from local=(%19.16f, %19.16f, %19.16f)\n",
795 point[0],point[1],point[2]);
796 printf(
" ldir =(%19.16f, %19.16f, %19.16f)\n",
797 dir[0],dir[1],dir[2]);
814 Int_t idaughter = -1;
848 for (
Int_t i=0; i<novlps; i++) {
849 current = mother->
GetNode(ovlps[i]);
942 Fatal(
"FindNextBoundary",
"Cannot find mother node");
955 if (nextovlp) nmany -= imother-up;
960 if (ovlp || nextovlp) {
963 Fatal(
"FindNextBoundary",
"Cannot find mother matrix");
985 currentnode = mothernode;
1005 while (nextindex>=0) {
1044 if ((index-1) >= ifirst) ifirst = index-1;
1046 if ((index+1) <= ilast) ilast = index+1;
1050 current = vol->
GetNode(ifirst);
1064 nodefound = current;
1068 if (ilast==ifirst)
return nodefound;
1070 current = vol->
GetNode(ilast);
1084 nodefound = current;
1093 if (idebug>4)
printf(
" Checking distance to %d daughters...\n",nd);
1094 if (nd<5 || !voxels) {
1095 for (i=0; i<nd; i++) {
1106 printf(
" -> from local=(%19.16f, %19.16f, %19.16f)\n",
1107 lpoint[0],lpoint[1],lpoint[2]);
1108 printf(
" ldir =(%19.16f, %19.16f, %19.16f)\n",
1109 ldir[0],ldir[1],ldir[2]);
1110 printf(
" -> to: %s shape %s snext=%g\n", current->
GetName(),
1124 while (indnext>=0) {
1128 nodefound = current;
1138 Int_t sumchecked = 0;
1142 while ((sumchecked<nd) && (vlist=voxels->
GetNextVoxel(point, dir, ncheck, info))) {
1143 for (i=0; i<ncheck; i++) {
1144 current = vol->
GetNode(vlist[i]);
1155 printf(
" -> from local=(%19.16f, %19.16f, %19.16f)\n",
1156 lpoint[0],lpoint[1],lpoint[2]);
1157 printf(
" ldir =(%19.16f, %19.16f, %19.16f)\n",
1158 ldir[0],ldir[1],ldir[2]);
1159 printf(
" -> to: %s shape %s snext=%g\n", current->
GetName(),
1172 idaughter = vlist[i];
1173 while (indnext>=0) {
1177 nodefound = current;
1196 static Int_t icount = 0;
1215 fPoint[1] += stepmax*fDirection[1];
1216 fPoint[2] += stepmax*fDirection[2];
1225 fPoint[1] += stepmax*fDirection[1];
1226 fPoint[2] += stepmax*fDirection[2];
1233 fPoint[1] += extra*fDirection[1];
1234 fPoint[2] += extra*fDirection[2];
1237 printf(
"TGeoManager::FindNextBAndStep: point=(%19.16f, %19.16f, %19.16f)\n",
1239 printf(
" dir= (%19.16f, %19.16f, %19.16f)\n",
1240 fDirection[0], fDirection[1], fDirection[2]);
1250 fPoint[0] -= extra*fDirection[0];
1251 fPoint[1] -= extra*fDirection[1];
1252 fPoint[2] -= extra*fDirection[2];
1254 fStep = snext+extra;
1259 while (nextindex>=0) {
1266 fPoint[0] += snext*fDirection[0];
1267 fPoint[1] += snext*fDirection[1];
1268 fPoint[2] += snext*fDirection[2];
1288 Int_t icrossed = -2;
1294 printf(
" -> from local=(%19.16f, %19.16f, %19.16f)\n",
1295 point[0],point[1],point[2]);
1296 printf(
" ldir =(%19.16f, %19.16f, %19.16f)\n",
1297 dir[0],dir[1],dir[2]);
1317 if (!
fLevel && !is_assembly) {
1335 Int_t idaughter = -1;
1339 icrossed = idaughter;
1374 for (
Int_t i=0; i<novlps; i++) {
1375 current = mother->
GetNode(ovlps[i]);
1391 icrossed = ovlps[i];
1407 icrossed = idaughter;
1425 icrossed = ovlps[i];
1457 if (nextovlp) nmany -= imother-up;
1462 if (ovlp || nextovlp) {
1474 while (up--)
CdUp();
1484 currentnode = mothernode;
1508 while (nextindex>=0) {
1520 if (icrossed == -2) {
1526 if (icrossed == -1) {
1530 if (!
fLevel && !is_assembly) {
1542 while (nextindex>=0) {
1565 if (found != last) {
1590 if (found != last) {
1728 if (ilast==ifirst)
return fSafety;
1745 for (
id=0;
id<nd;
id++) {
1766 for (
id=0;
id<nd;
id++) {
1770 if (dxyz0 >
fSafety)
continue;
1772 if (dxyz1 >
fSafety)
continue;
1774 if (dxyz2 >
fSafety)
continue;
1775 if (dxyz0>0) dxyz+=dxyz0*dxyz0;
1776 if (dxyz1>0) dxyz+=dxyz1*dxyz1;
1777 if (dxyz2>0) dxyz+=dxyz2*dxyz2;
1786 if (safe<fSafety) fSafety = safe;
1813 if (safe<fSafety && safe>=0)
fSafety=safe;
1814 if (!novlp || !contains)
continue;
1816 for (io=0; io<novlp; io++) {
1817 nodeovlp = vol->
GetNode(ovlp[io]);
1827 if (safe<fSafety && safe>=0)
fSafety=safe;
1845 if (crtovlp) nmany--;
1846 if (crtovlp || nextovlp) {
1876 while (crtindex>=0) {
1901 if (!inside_current) {
1903 inside_current = vol->
Contains(point);
1909 if (!inside_current) {
1924 if (!inside_current && downwards) {
1927 else inside_current = vol->
Contains(point);
1928 if (!inside_current) {
1937 printf(
"Search node local=(%19.16f, %19.16f, %19.16f) -> %s\n",
1951 while (crtindex>=0 && downwards) {
1977 if (node && node!=skipnode) {
1991 Int_t *check_list = 0;
2014 for (
id=0;
id<ncheck;
id++) {
2015 node = vol->
GetNode(check_list[
id]);
2016 if (node==skipnode)
continue;
2060 for (
id=0;
id<nd;
id++) {
2062 if (node==skipnode)
continue;
2103 Int_t found_virtual = 0;
2107 for (i=0; i<nc; i++) {
2121 if (found_virtual>deepest_virtual) {
2124 if (found_virtual==deepest_virtual) {
2128 if ((
fLevel==deepest) && (clnode==priority)) replace=
kTRUE;
2150 deepest_virtual = found_virtual;
2159 deepest_virtual = found_virtual;
2180 if (!ovlps)
return 0;
2186 result[ntotal++]=check_list[start];
2190 while ((ovlps[jst]<=check_list[start]) && (jst<novlps)) jst++;
2191 if (jst==novlps)
return 0;
2192 for (i=start; i<ncheck; i++) {
2193 for (j=jst; j<novlps; j++) {
2194 if (check_list[i]==ovlps[j]) {
2200 result[ntotal++]=check_list[i];
2224 if (is_geom) epsil=(
cross)?1
E-6:-1
E-6;
2255 Int_t new_media = 0;
2257 Int_t virtual_level = 1;
2260 while ((mother=
GetMother(virtual_level))) {
2262 if (!new_media) new_media=(mother->
GetMedium()==medium)?0:virtual_level;
2265 if (!new_media) new_media=(mother->
GetMedium()==medium)?0:virtual_level;
2268 return (new_media==0)?virtual_level:(new_media-1);
2291 if (!mother)
return kTRUE;
2297 if (ovlp || nextovlp) {
2303 while (up--)
CdUp();
2320 if (!overlapping)
return fLevel;
2323 while (overlapping && level) {
2336 Info(
"InspectState",
"Current path is: %s",
GetPath());
2339 Bool_t is_offset, is_overlapping;
2340 for (level=0; level<
fLevel+1; level++) {
2342 if (!node)
continue;
2345 Info(
"InspectState",
"level %i: %s div=%i many=%i",level,node->
GetName(),is_offset,is_overlapping);
2372 if (change) fLastSafety = 0;
2395 if (!change)
return kFALSE;
2406 if (!change)
return kFALSE;
2416 if (!change)
return kFALSE;
2419 while (crtindex>=0) {
2429 if (!nd)
return kTRUE;
2436 if (!change)
return kFALSE;
2445 Int_t *check_list = 0;
2455 for (
Int_t id=0;
id<ncheck;
id++) {
2518 if (safe < proposed)
return kFALSE;
2639 SetCurrentNavigator(GetEntriesFast()-1);
Int_t fNmany
current geometry level;
virtual TGeoPatternFinder * GetFinder() const
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...
double dist(Rotation3D const &r1, Rotation3D const &r2)
Bool_t GotoSafeLevel()
Go upwards the tree until a non-overlaping node.
TGeoNodeCache * fCache
current geometry
void Add(THist< DIMENSION, PRECISIONA > &to, THist< DIMENSION, PRECISIONB > &from)
#define snext(osub1, osub2)
Int_t GetNext() const
Get index of next division.
const char * GetPath() const
Get path to the current node in the form /node0/node1/...
virtual void Voxelize(Option_t *option="")
Voxelize attached volume according to option If the volume is an assembly, make sure the bbox is comp...
virtual Int_t GetCurrentNodeIndex() const
TGeoVolume * GetVolume() const
TGeoHMatrix * GetCurrentMatrix() const
virtual void ComputeNormal(const Double_t *point, const Double_t *dir, Double_t *norm)=0
Double_t Safety(Double_t point[3], Double_t safmax=1.E30)
Compute safety for the parallel world.
TVector3 cross(const TVector3 &v1, const TVector3 &v2)
TGeoNode * InitTrack(const Double_t *point, const Double_t *dir)
Initialize current point and current direction vector (normalized) in MARS.
TGeoPatternFinder * GetFinder() const
Bool_t CheckPath(const char *path) const
Check if a geometry path is valid without changing the state of the navigator.
Double_t Safety(const Double_t *point, Bool_t in=kTRUE) const
computes the closest distance from given point to this shape
virtual TGeoNode * FindNode(Double_t *, const Double_t *=0)
TGeoNavigator()
path to current node
TGeoManager * fGeometry
flag that last geometric step was null
virtual Int_t * GetCheckList(const Double_t *point, Int_t &nelem, TGeoStateInfo &td)
get the list of daughter indices for which point is inside their bbox
TGeoStateInfo * GetInfo()
Get next state info pointer.
Int_t fOverlapMark
current size of fOverlapClusters
Int_t GetSafeLevel() const
Go upwards the tree until a non-overlaping node.
void InspectShape() const
Double_t fSafety
step to be done from current point and direction
TGeoNode * fCurrentNode
current volume
TGeoHMatrix * GetMotherMatrix(Int_t up=1) const
virtual void Info(const char *method, const char *msgfmt,...) const
Issue info message.
void GetBranchOnlys(Int_t *isonly) const
Fill node copy numbers of current branch into an array.
static Int_t GetVerboseLevel()
Set verbosity level (static function).
virtual Int_t GetNextNodeIndex() const
Bool_t IsSameLocation() const
Bool_t IsActivityEnabled() const
Bool_t fIsOnBoundary
flag that current point is outside geometry
void MasterToLocal(const Double_t *master, Double_t *local) const
void Multiply(const TGeoMatrix *right)
multiply to the right with an other transformation if right is identity matrix, just return ...
TGeoPhysicalNode * FindNextBoundary(Double_t point[3], Double_t dir[3], Double_t &step, Double_t stepmax=1.E30)
Same functionality as TGeoNavigator::FindNextDaughterBoundary for the parallel world.
TGeoNode * FindInCluster(Int_t *cluster, Int_t nc)
Find a node inside a cluster of overlapping nodes.
Short_t Min(Short_t a, Short_t b)
TGeoNode * GetNode() const
TGeoHMatrix * fDivMatrix
current pointer to cached global matrix
TGeoPhysicalNode * FindNode(Double_t point[3])
Finds physical node containing the point.
Double_t fCldir[3]
cosine of incident angle on current checked surface
virtual void LocalToMasterVect(const Double_t *local, Double_t *master) const
convert a vector by multiplying its column vector (x, y, z, 1) to matrix inverse
Double_t fDirection[3]
current point
TGeoNode * fLastNode
top physical node
void GetBranchOnlys(Int_t *isonly) const
Fill copy numbers of current branch nodes.
virtual void SortCrossedVoxels(const Double_t *point, const Double_t *dir, TGeoStateInfo &td)
get the list in the next voxel crossed by a ray
Bool_t BeginsWith(const char *s, ECaseCompare cmp=kExact) const
Bool_t NeedRebuild() const
Int_t GetNdaughters() const
Int_t fNextDaughterIndex
number of overlapping nodes on current branch
virtual Int_t * GetNextVoxel(const Double_t *point, const Double_t *dir, Int_t &ncheck, TGeoStateInfo &td)
get the list of new candidates for the next voxel crossed by current ray printf("### GetNextVoxel\n")...
TGeoHMatrix * fCurrentMatrix
backup state
Double_t fNormal[3]
last computed safety radius
static Double_t Tolerance()
void DoRestoreState()
Restore a backed-up state without affecting the cache stack.
const char * Data() const
virtual void Fatal(const char *method, const char *msgfmt,...) const
Issue fatal error message.
void CdNode(Int_t nodeid)
Change current path to point to the node having this id.
virtual Bool_t Contains(const Double_t *point) const =0
TGeoNavigator & operator=(const TGeoNavigator &)
assignment operator
TGeoParallelWorld * GetParallelWorld() 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 IsOverlapping() const
void PopDummy(Int_t ipop=9999)
TGeoNode * GetTopNode() const
Bool_t HasIdArray() const
Bool_t fIsNullStep
flag that a new point is in the same node as previous
ClassImp(TGeoNavigator) TGeoNavigator
virtual Bool_t IsOnBoundary(const Double_t *) const
virtual void MasterToLocal(const Double_t *master, Double_t *local) const
convert a point by multiplying its column vector (x, y, z, 1) to matrix
virtual TGeoMatrix * GetMatrix() const =0
TObject & operator=(const TObject &rhs)
TObject assignment operator.
TGeoNode * GetDaughter(Int_t ind) const
TGeoNode * GetCurrentNode() const
void CopyFrom(const TGeoMatrix *other)
Fast copy method.
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
TGeoVolume * GetTopVolume() const
void ResetState()
Reset current state flags.
void ReleaseInfo()
Release last used state info pointer.
TGeoNode * SearchNode(Bool_t downwards=kFALSE, const TGeoNode *skipnode=0)
Returns the deepest node containing fPoint, which must be set a priori.
void CdTop()
Make top level node the current node.
virtual void MasterToLocalVect(const Double_t *master, Double_t *local) const
convert a point by multiplying its column vector (x, y, z, 1) to matrix
TObject * UncheckedAt(Int_t i) const
TGeoNode * FindNextBoundaryAndStep(Double_t stepmax=TGeoShape::Big(), Bool_t compsafe=kFALSE)
Compute distance to next boundary within STEPMAX.
Bool_t Contains(const Double_t *point) const
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.
void SetCurrentPoint(const Double_t *point)
Int_t GetIndex(const TGeoNode *node) const
get index number for a given daughter
Double_t Safety(Bool_t inside=kFALSE)
Compute safe distance from the current point.
Double_t length(const TVector2 &v)
TGeoHMatrix * fGlobalMatrix
current stored global matrix
Int_t GetVirtualLevel()
Find level of virtuality of current overlapping node (number of levels up having the same tracking me...
Double_t fCldirChecked[3]
unit vector to current closest shape
virtual Bool_t IsAssembly() const
Returns true if the volume is an assembly or a scaled assembly.
void MasterToTop(const Double_t *master, Double_t *top) const
Convert coordinates from master volume frame to top.
virtual const char * ClassName() const
Returns name of class to which the object belongs.
virtual Double_t Safety(const Double_t *point, Bool_t in=kTRUE) const =0
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 ...
virtual void LocalToMaster(const Double_t *local, Double_t *master) const
convert a point by multiplying its column vector (x, y, z, 1) to matrix inverse
Bool_t fIsOutside
flaag that next geometric step will exit current volume
void CdDown(Int_t index)
Make a daughter of current node current.
virtual void RegisterYourself()
Register the matrix in the current manager, which will become the owner.
void SafetyOverlaps()
Compute safe distance from the current point within an overlapping node.
Bool_t fSearchOverlaps
internal array for overlaps
Double_t fLastSafety
safety radius from current point
virtual const char * GetName() const
Returns name of object.
Bool_t IsSafeVoxel(const Double_t *point, Int_t inode, Double_t minsafe) const
Computes squared distance from POINT to the voxel(s) containing node INODE.
void GetBranchNames(Int_t *names) const
Fill volume names of current branch into an array.
Bool_t fIsStepEntering
flag that current track is about to leave current node
TGeoNode * GetNode(const char *name) const
get the pointer to a daughter node
virtual ~TGeoNavigator()
Destructor.
static Double_t gTolerance
virtual Double_t DistFromOutside(const Double_t *point, const Double_t *dir, Int_t iact=1, Double_t step=TGeoShape::Big(), Double_t *safe=0) const =0
TGeoNode * GetNode(Int_t level=-1) const
Return node in branch at LEVEL. If not specified, return last leaf.
Int_t fLevel
thread id for this navigator
virtual Double_t DistFromInside(const Double_t *point, const Double_t *dir, Int_t iact=1, Double_t step=TGeoShape::Big(), Double_t *safe=0) const =0
Int_t PushPath(Int_t startlevel=0)
Double_t fPoint[3]
unit vector to current checked shape
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...
TGeoNode * fNextNode
last searched node
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.
TString fPath
current local matrix of the selected division cell
TGeoShape * GetShape() const
void SetCurrentDirection(const Double_t *dir)
void CdUp()
Go one level up in geometry.
Int_t PushPoint(Int_t startlevel=0)
Bool_t fIsEntering
flag a safe start for point classification
TGeoVoxelFinder * GetVoxels() const
Getter for optimization structure.
Int_t GetMaxLevel() const
TGeoNode * GetMother(Int_t up=1) const
TGeoNode * FindNextBoundary(Double_t stepmax=TGeoShape::Big(), const char *path="", Bool_t frombdr=kFALSE)
Find distance to next boundary and store it in fStep.
const char * GetPath()
Returns the current geometry path.
TGeoVolume * fCurrentVolume
cache of states
Bool_t fIsSameLocation
flag that current point is on some boundary
ClassImp(TMCParticle) void TMCParticle printf(": p=(%7.3f,%7.3f,%9.3f) ;", fPx, fPy, fPz)
void GetBranchNames(Int_t *names) const
Fill names with current branch volume names (4 char - used by GEANT3 interface).
static RooMathCoreReg dummy
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...
virtual Int_t GetIndex() const
Int_t fThreadId
last point for which safety was computed
void ResetAll()
Reset the navigator.
TGeoHMatrix * GetHMatrix()
Return stored current matrix (global matrix of the next touched node).
Mother of all ROOT objects.
Bool_t CdDown(Int_t index)
Make daughter INDEX of current node the active state. Compute global matrix.
Double_t fLastPoint[3]
current direction
Bool_t fIsStepExiting
flag that next geometric step will enter new volume
void CdNext()
Do a cd to the node found next by FindNextBoundary.
Bool_t IsParallelWorldNav() const
void TopToMaster(const Double_t *top, Double_t *master) const
Convert coordinates from top volume frame to master.
R__EXTERN TGeoIdentity * gGeoIdentity
void GetBranchNumbers(Int_t *copyNumbers, Int_t *volumeNumbers) const
Fill node copy numbers of current branch into an array.
static Int_t ThreadId()
Translates the current thread id to an ordinal number.
void InspectState() const
Inspects path and all flags for the current state.
void GetBranchNumbers(Int_t *copyNumbers, Int_t *volumeNumbers) const
Fill copy numbers of current branch nodes.
virtual void MasterToLocal(const Double_t *master, Double_t *local) const
Convert the point coordinates from mother reference to local reference system.
void CdNode(Int_t nodeid)
Change current path to point to the node having this id.
Double_t * GetBoxes() const
TGeoNode * FindNode(Bool_t safe_start=kTRUE)
Returns deepest node containing current point.
TGeoMedium * GetMedium() const
const char * kGeoOutsidePath
virtual TGeoNode * CdNext()
Make next node (if any) current.
void CdUp()
Make mother of current node the active state.
Bool_t IsActiveDaughters() const
Int_t fOverlapSize
next daughter index after FindNextBoundary
void FindOverlaps() const
loop all nodes marked as overlaps and find overlaping brothers
Double_t Sqrt(Double_t x)
Int_t * GetOverlaps(Int_t &novlp) const
Bool_t fIsExiting
flag if current step just got into a new node
TGeoNode * fForcedNode
next node that will be crossed
Ssiz_t Index(const char *pat, Ssiz_t i=0, ECaseCompare cmp=kExact) const
void DoBackupState()
Backup the current state without affecting the cache stack.
Double_t * FindNormalFast()
Computes fast normal to next crossed boundary, assuming that the current point is close enough to the...
Int_t GetCurrentNodeId() const
void SetState(Int_t level, Int_t startlevel, Int_t nmany, Bool_t ovlp, Double_t *point=0)
Fill current modeller state.
Bool_t fStartSafe
flags the type of the current node
virtual const Double_t * GetTranslation() const
static char * skip(char **buf, const char *delimiters)
Bool_t RestoreState(Int_t &nmany, TGeoCacheState *state, Double_t *point=0)
Pop next state/point from a backed-up state.
TGeoNode * CrossDivisionCell()
Cross a division cell.
Int_t * fOverlapClusters
current recursive position in fOverlapClusters
Int_t GetNdaughters() const
TGeoNode * fTopNode
current node
TGeoCacheState * fBackupState
current point is supposed to be inside this node
Bool_t fCurrentOverlapping
flag set when an overlapping cluster is searched
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)...
virtual void MasterToLocalVect(const Double_t *master, Double_t *local) const
Convert a vector from mother reference to local reference system.