Back to home page

EIC code displayed by LXR
 
 

    

Warning, file /include/root/TGeoNavigator.h was not indexed or was modified since last indexation (in which case cross-reference links may be missing, inaccurate or erroneous).

0001 // @(#)root/geom:$Id$
0002 // Author: Mihaela Gheata   30/05/07
0003 
0004 /*************************************************************************
0005  * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
0006  * All rights reserved.                                                  *
0007  *                                                                       *
0008  * For the licensing terms see $ROOTSYS/LICENSE.                         *
0009  * For the list of contributors see $ROOTSYS/README/CREDITS.             *
0010  *************************************************************************/
0011 
0012 #ifndef ROOT_TGeoNavigator
0013 #define ROOT_TGeoNavigator
0014 
0015 #include "TObject.h"
0016 
0017 #include "TGeoCache.h"
0018 
0019 ////////////////////////////////////////////////////////////////////////////
0020 //                                                                        //
0021 // TGeoNavigator - Class containing the implementation of all navigation  //
0022 //   methods.
0023 //                                                                        //
0024 ////////////////////////////////////////////////////////////////////////////
0025 
0026 class TGeoManager;
0027 class TGeoNode;
0028 class TGeoVolume;
0029 class TGeoMatrix;
0030 class TGeoHMatrix;
0031 
0032 class TGeoNavigator : public TObject {
0033 
0034 protected:
0035    TGeoNavigator(const TGeoNavigator &) = delete;
0036    TGeoNavigator &operator=(const TGeoNavigator &) = delete;
0037    TGeoNode *FindInCluster(Int_t *cluster, Int_t nc);
0038    Int_t GetTouchedCluster(Int_t start, Double_t *point, Int_t *check_list, Int_t ncheck, Int_t *result);
0039    TGeoNode *CrossDivisionCell();
0040    void SafetyOverlaps();
0041 
0042 private:
0043    Double_t fStep;               //! step to be done from current point and direction
0044    Double_t fSafety;             //! safety radius from current point
0045    Double_t fLastSafety;         //! last computed safety radius
0046    Double_t fNormal[3];          //! cosine of incident angle on current checked surface
0047    Double_t fCldir[3];           //! unit vector to current closest shape
0048    Double_t fCldirChecked[3];    //! unit vector to current checked shape
0049    Double_t fPoint[3];           //! current point
0050    Double_t fDirection[3];       //! current direction
0051    Double_t fLastPoint[3];       //! last point for which safety was computed
0052    Int_t fThreadId;              //! thread id for this navigator
0053    Int_t fLevel;                 //! current geometry level;
0054    Int_t fNmany;                 //! number of overlapping nodes on current branch
0055    Int_t fNextDaughterIndex;     //! next daughter index after FindNextBoundary
0056    Int_t fOverlapSize;           //! current size of fOverlapClusters
0057    Int_t fOverlapMark;           //! current recursive position in fOverlapClusters
0058    Int_t *fOverlapClusters;      //! internal array for overlaps
0059    Bool_t fSearchOverlaps;       //! flag set when an overlapping cluster is searched
0060    Bool_t fCurrentOverlapping;   //! flags the type of the current node
0061    Bool_t fStartSafe;            //! flag a safe start for point classification
0062    Bool_t fIsEntering;           //! flag if current step just got into a new node
0063    Bool_t fIsExiting;            //! flag that current track is about to leave current node
0064    Bool_t fIsStepEntering;       //! flag that next geometric step will enter new volume
0065    Bool_t fIsStepExiting;        //! flag that next geometric step will exit current volume
0066    Bool_t fIsOutside;            //! flag that current point is outside geometry
0067    Bool_t fIsOnBoundary;         //! flag that current point is on some boundary
0068    Bool_t fIsSameLocation;       //! flag that a new point is in the same node as previous
0069    Bool_t fIsNullStep;           //! flag that last geometric step was null
0070    TGeoManager *fGeometry;       //! current geometry
0071    TGeoNodeCache *fCache;        //! cache of states
0072    TGeoVolume *fCurrentVolume;   //! current volume
0073    TGeoNode *fCurrentNode;       //! current node
0074    TGeoNode *fTopNode;           //! top physical node
0075    TGeoNode *fLastNode;          //! last searched node
0076    TGeoNode *fNextNode;          //! next node that will be crossed
0077    TGeoNode *fForcedNode;        //! current point is supposed to be inside this node
0078    TGeoCacheState *fBackupState; //! backup state
0079    TGeoHMatrix *fCurrentMatrix;  //! current stored global matrix
0080    TGeoHMatrix *fGlobalMatrix;   //! current pointer to cached global matrix
0081    TGeoHMatrix *fDivMatrix;      //! current local matrix of the selected division cell
0082    TString fPath;                //! path to current node
0083 
0084 public:
0085    TGeoNavigator();
0086    TGeoNavigator(TGeoManager *geom);
0087    ~TGeoNavigator() override;
0088 
0089    void BuildCache(Bool_t dummy = kFALSE, Bool_t nodeid = kFALSE);
0090    Bool_t cd(const char *path = "");
0091    Bool_t CheckPath(const char *path) const;
0092    void CdNode(Int_t nodeid);
0093    void CdDown(Int_t index);
0094    void CdDown(TGeoNode *node);
0095    void CdUp();
0096    void CdTop();
0097    void CdNext();
0098    void GetBranchNames(Int_t *names) const;
0099    void GetBranchNumbers(Int_t *copyNumbers, Int_t *volumeNumbers) const;
0100    void GetBranchOnlys(Int_t *isonly) const;
0101    Int_t GetNmany() const { return fNmany; }
0102    //--- geometry queries
0103    TGeoNode *CrossBoundaryAndLocate(Bool_t downwards, TGeoNode *skipnode);
0104    TGeoNode *FindNextBoundary(Double_t stepmax = TGeoShape::Big(), const char *path = "", Bool_t frombdr = kFALSE);
0105    TGeoNode *FindNextDaughterBoundary(Double_t *point, Double_t *dir, Int_t &idaughter, Bool_t compmatrix = kFALSE);
0106    TGeoNode *FindNextBoundaryAndStep(Double_t stepmax = TGeoShape::Big(), Bool_t compsafe = kFALSE);
0107    TGeoNode *FindNode(Bool_t safe_start = kTRUE);
0108    TGeoNode *FindNode(Double_t x, Double_t y, Double_t z);
0109    Double_t *FindNormal(Bool_t forward = kTRUE);
0110    Double_t *FindNormalFast();
0111    TGeoNode *InitTrack(const Double_t *point, const Double_t *dir);
0112    TGeoNode *InitTrack(Double_t x, Double_t y, Double_t z, Double_t nx, Double_t ny, Double_t nz);
0113    void ResetState();
0114    void ResetAll();
0115    Double_t Safety(Bool_t inside = kFALSE);
0116    TGeoNode *SearchNode(Bool_t downwards = kFALSE, const TGeoNode *skipnode = nullptr);
0117    TGeoNode *Step(Bool_t is_geom = kTRUE, Bool_t cross = kTRUE);
0118    const Double_t *GetLastPoint() const { return fLastPoint; }
0119    Int_t GetVirtualLevel();
0120    Bool_t GotoSafeLevel();
0121    Int_t GetSafeLevel() const;
0122    Double_t GetSafeDistance() const { return fSafety; }
0123    Double_t GetLastSafety() const { return fLastSafety; }
0124    Double_t GetStep() const { return fStep; }
0125    Int_t GetThreadId() const { return fThreadId; }
0126    void InspectState() const;
0127    Bool_t IsSafeStep(Double_t proposed, Double_t &newsafety) const;
0128    Bool_t IsSameLocation(Double_t x, Double_t y, Double_t z, Bool_t change = kFALSE);
0129    Bool_t IsSameLocation() const { return fIsSameLocation; }
0130    Bool_t IsSamePoint(Double_t x, Double_t y, Double_t z) const;
0131    Bool_t IsStartSafe() const { return fStartSafe; }
0132    void SetStartSafe(Bool_t flag = kTRUE) { fStartSafe = flag; }
0133    void SetStep(Double_t step) { fStep = step; }
0134    Bool_t IsCheckingOverlaps() const { return fSearchOverlaps; }
0135    Bool_t IsCurrentOverlapping() const { return fCurrentOverlapping; }
0136    Bool_t IsEntering() const { return fIsEntering; }
0137    Bool_t IsExiting() const { return fIsExiting; }
0138    Bool_t IsStepEntering() const { return fIsStepEntering; }
0139    Bool_t IsStepExiting() const { return fIsStepExiting; }
0140    Bool_t IsOutside() const { return fIsOutside; }
0141    Bool_t IsOnBoundary() const { return fIsOnBoundary; }
0142    Bool_t IsNullStep() const { return fIsNullStep; }
0143    void SetCheckingOverlaps(Bool_t flag = kTRUE) { fSearchOverlaps = flag; }
0144    void SetOutside(Bool_t flag = kTRUE) { fIsOutside = flag; }
0145    //--- modeler state getters/setters
0146    void DoBackupState();
0147    void DoRestoreState();
0148    Int_t GetNodeId() const { return fCache->GetNodeId(); }
0149    Int_t GetNextDaughterIndex() const { return fNextDaughterIndex; }
0150    TGeoNode *GetNextNode() const { return fNextNode; }
0151    TGeoNode *GetMother(Int_t up = 1) const { return fCache->GetMother(up); }
0152    TGeoHMatrix *GetMotherMatrix(Int_t up = 1) const { return fCache->GetMotherMatrix(up); }
0153    TGeoHMatrix *GetHMatrix();
0154    TGeoHMatrix *GetCurrentMatrix() const { return fCache->GetCurrentMatrix(); }
0155    TGeoNode *GetCurrentNode() const { return fCurrentNode; }
0156    Int_t GetCurrentNodeId() const { return fCache->GetCurrentNodeId(); }
0157    const Double_t *GetCurrentPoint() const { return fPoint; }
0158    const Double_t *GetCurrentDirection() const { return fDirection; }
0159    TGeoVolume *GetCurrentVolume() const { return fCurrentNode->GetVolume(); }
0160    const Double_t *GetCldirChecked() const { return fCldirChecked; }
0161    const Double_t *GetCldir() const { return fCldir; }
0162    TGeoHMatrix *GetDivMatrix() const { return fDivMatrix; }
0163    //   Double_t               GetNormalChecked() const {return fNormalChecked;}
0164    const Double_t *GetNormal() const { return fNormal; }
0165    Int_t GetLevel() const { return fLevel; }
0166    const char *GetPath() const;
0167    Int_t GetStackLevel() const { return fCache->GetStackLevel(); }
0168    void SetCurrentPoint(const Double_t *point) { memcpy(fPoint, point, 3 * sizeof(Double_t)); }
0169    void SetCurrentPoint(Double_t x, Double_t y, Double_t z)
0170    {
0171       fPoint[0] = x;
0172       fPoint[1] = y;
0173       fPoint[2] = z;
0174    }
0175    void SetLastPoint(Double_t x, Double_t y, Double_t z)
0176    {
0177       fLastPoint[0] = x;
0178       fLastPoint[1] = y;
0179       fLastPoint[2] = z;
0180    }
0181    void SetCurrentDirection(const Double_t *dir) { memcpy(fDirection, dir, 3 * sizeof(Double_t)); }
0182    void SetCurrentDirection(Double_t nx, Double_t ny, Double_t nz)
0183    {
0184       fDirection[0] = nx;
0185       fDirection[1] = ny;
0186       fDirection[2] = nz;
0187    }
0188    //   void                   SetNormalChecked(Double_t norm) {fNormalChecked=norm;}
0189    void SetCldirChecked(Double_t *dir) { memcpy(fCldirChecked, dir, 3 * sizeof(Double_t)); }
0190    void SetLastSafetyForPoint(Double_t safe, const Double_t *point)
0191    {
0192       fLastSafety = safe;
0193       memcpy(fLastPoint, point, 3 * sizeof(Double_t));
0194    }
0195    void SetLastSafetyForPoint(Double_t safe, Double_t x, Double_t y, Double_t z)
0196    {
0197       fLastSafety = safe;
0198       fLastPoint[0] = x;
0199       fLastPoint[1] = y, fLastPoint[2] = z;
0200    }
0201 
0202    //--- point/vector reference frame conversion
0203    void LocalToMaster(const Double_t *local, Double_t *master) const { fCache->LocalToMaster(local, master); }
0204    void LocalToMasterVect(const Double_t *local, Double_t *master) const { fCache->LocalToMasterVect(local, master); }
0205    void LocalToMasterBomb(const Double_t *local, Double_t *master) const { fCache->LocalToMasterBomb(local, master); }
0206    void MasterToLocal(const Double_t *master, Double_t *local) const { fCache->MasterToLocal(master, local); }
0207    void MasterToLocalVect(const Double_t *master, Double_t *local) const { fCache->MasterToLocalVect(master, local); }
0208    void MasterToLocalBomb(const Double_t *master, Double_t *local) const { fCache->MasterToLocalBomb(master, local); }
0209    void MasterToTop(const Double_t *master, Double_t *top) const;
0210    void TopToMaster(const Double_t *top, Double_t *master) const;
0211    TGeoNodeCache *GetCache() const { return fCache; }
0212    //   void                   SetCache(const TGeoNodeCache *cache) {fCache = (TGeoNodeCache*)cache;}
0213    //--- stack manipulation
0214    Int_t PushPath(Int_t startlevel = 0) { return fCache->PushState(fCurrentOverlapping, startlevel, fNmany); }
0215    Bool_t PopPath()
0216    {
0217       fCurrentOverlapping = fCache->PopState(fNmany);
0218       fCurrentNode = fCache->GetNode();
0219       fLevel = fCache->GetLevel();
0220       fGlobalMatrix = fCache->GetCurrentMatrix();
0221       return fCurrentOverlapping;
0222    }
0223    Bool_t PopPath(Int_t index)
0224    {
0225       fCurrentOverlapping = fCache->PopState(fNmany, index);
0226       fCurrentNode = fCache->GetNode();
0227       fLevel = fCache->GetLevel();
0228       fGlobalMatrix = fCache->GetCurrentMatrix();
0229       return fCurrentOverlapping;
0230    }
0231    Int_t PushPoint(Int_t startlevel = 0) { return fCache->PushState(fCurrentOverlapping, startlevel, fNmany, fPoint); }
0232    Bool_t PopPoint()
0233    {
0234       fCurrentOverlapping = fCache->PopState(fNmany, fPoint);
0235       fCurrentNode = fCache->GetNode();
0236       fLevel = fCache->GetLevel();
0237       fGlobalMatrix = fCache->GetCurrentMatrix();
0238       return fCurrentOverlapping;
0239    }
0240    Bool_t PopPoint(Int_t index)
0241    {
0242       fCurrentOverlapping = fCache->PopState(fNmany, index, fPoint);
0243       fCurrentNode = fCache->GetNode();
0244       fLevel = fCache->GetLevel();
0245       fGlobalMatrix = fCache->GetCurrentMatrix();
0246       return fCurrentOverlapping;
0247    }
0248    void PopDummy(Int_t ipop = 9999) { fCache->PopDummy(ipop); }
0249 
0250    ClassDefOverride(TGeoNavigator, 0) // geometry navigator class
0251 };
0252 
0253 #include "TObjArray.h"
0254 
0255 ////////////////////////////////////////////////////////////////////////////
0256 //                                                                        //
0257 // TGeoNavigatorArray - Class representing an array of navigators working //
0258 //   in a single thread.                                                  //
0259 //                                                                        //
0260 ////////////////////////////////////////////////////////////////////////////
0261 
0262 class TGeoNavigatorArray : public TObjArray {
0263 private:
0264    TGeoNavigator *fCurrentNavigator; // Current navigator
0265    TGeoManager *fGeoManager;         // Manager to which it applies
0266 
0267    TGeoNavigatorArray(const TGeoNavigatorArray &) = delete;
0268    TGeoNavigatorArray &operator=(const TGeoNavigatorArray &) = delete;
0269 
0270 public:
0271    TGeoNavigatorArray() : TObjArray(), fCurrentNavigator(nullptr), fGeoManager(nullptr) {}
0272    TGeoNavigatorArray(TGeoManager *mgr) : TObjArray(), fCurrentNavigator(nullptr), fGeoManager(mgr) { SetOwner(); }
0273    ~TGeoNavigatorArray() override {}
0274 
0275    TGeoNavigator *AddNavigator();
0276    inline TGeoNavigator *GetCurrentNavigator() const { return fCurrentNavigator; }
0277    TGeoNavigator *SetCurrentNavigator(Int_t inav) { return (fCurrentNavigator = (TGeoNavigator *)At(inav)); }
0278 
0279    ClassDefOverride(TGeoNavigatorArray, 0) // An array of navigators
0280 };
0281 #endif
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.3.7 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!