TGeoNodeCache

class TGeoNodeCache

    protected:

                     TGeoNodeCache(const TGeoNodeCache&)
      TGeoNodeCache& operator=(const TGeoNodeCache&)

    public:

                           TGeoNodeCache()
                           TGeoNodeCache(Bool_t nodeid)
                           TGeoNodeCache(Int_t size, Bool_t nodeid = kFALSE)
                   virtual ~TGeoNodeCache()
                     Int_t AddNode(TGeoNode* node)
                      void BuildIdArray()
                     Int_t CacheId(Int_t nindex) const
                      void CdCache()
            virtual Bool_t CdDown(Int_t index, Bool_t make = kTRUE)
                      void CdNode(Int_t nodeid)
              virtual void CdTop()
              virtual void CdUp()
            static TClass* Class()
              virtual void CleanCache()
              virtual void ClearDaughter(Int_t index)
              virtual void ClearNode(Int_t nindex)
              virtual void Compact()
              virtual void DeleteCaches()
            virtual Bool_t DumpNodes()
                      void FillIdBranch(const Int_t* br, Int_t startlevel = 0)
             virtual void* GetBranch() const
              virtual void GetBranchNames(Int_t*) const
              virtual void GetBranchNumbers(Int_t*, Int_t*) const
              virtual void GetBranchOnlys(Int_t*) const
      virtual TGeoHMatrix* GetCurrentMatrix() const
                     Int_t GetCurrentNode() const
                     Int_t GetCurrentNodeId() const
             virtual Int_t GetFreeSpace() const
              const Int_t* GetIdBranch() const
                     Int_t GetLevel() const
             virtual void* GetMatrices() const
          TGeoMatrixCache* GetMatrixPool() const
         virtual TGeoNode* GetMother(Int_t up = 1) const
      virtual TGeoHMatrix* GetMotherMatrix(Int_t) const
             virtual Int_t GetNfree() const
         virtual TGeoNode* GetNode() const
             virtual Int_t GetNodeId() const
             virtual Int_t GetNused() const
       virtual const char* GetPath()
                     Int_t GetSize() const
                     Int_t GetStackLevel() const
                     Int_t GetTopNode() const
             virtual Int_t GetUsageCount() const
                    Bool_t HasIdArray() const
              virtual void IncreasePool(Int_t size)
              virtual void IncrementUsageCount()
                     Int_t Index(Int_t nindex) const
           virtual TClass* IsA() const
            virtual Bool_t IsDummy() const
              virtual void LocalToMaster(const Double_t* local, Double_t* master) const
              virtual void LocalToMasterBomb(const Double_t* local, Double_t* master) const
              virtual void LocalToMasterVect(const Double_t* local, Double_t* master) const
              virtual void MasterToLocal(const Double_t* master, Double_t* local) const
              virtual void MasterToLocalBomb(const Double_t* master, Double_t* local) const
              virtual void MasterToLocalVect(const Double_t* master, Double_t* local) const
              virtual void PopDummy(Int_t ipop = 9999)
            virtual Bool_t PopState(Int_t& nmany, Double_t* point = 0)
            virtual Bool_t PopState(Int_t& nmany, Int_t level, Double_t* point = 0)
              virtual void PrintNode() const
             virtual Int_t PushState(Bool_t ovlp, Int_t ntmany = 0, Int_t startlevel = 0, Double_t* point = 0)
              virtual void Refresh()
                      void SetDefaultLevel(Int_t level)
                    Bool_t SetPersistency()
              virtual void ShowMembers(TMemberInspector& insp, char* parent)
                      void Status() const
              virtual void Streamer(TBuffer& b)
                      void StreamerNVirtual(TBuffer& b)

Data Members

    private:

                Int_t fSize          current size of the cache
                Int_t fNused         number of used nodes
                Int_t fDefaultLevel  level down to which nodes will be persistent
                Int_t fTopNode       top level physical node
                Int_t fCount         total usage count
                Int_t fCountLimit    count limit for which nodes become persistent
                Int_t fCurrentNode   current physical node
                Int_t fCurrentCache  current cache number
                Int_t fCurrentIndex  index of current node in current cache
               Int_t* fBranch        nodes from current branch
               Int_t* fMatrices      matrix indices from current branch
                Int_t fStackLevel    level in the stack of states
         TGeoHMatrix* fGlobalMatrix  current global matrix
      TGeoNodeArray** fCache         [128] cache of node arrays

    protected:

              Double_t fGeoCacheUsageRatio    percentage of total usage count that triggers persistency
                 Int_t fGeoCacheMaxDaughters  max ndaugters for TGeoNodeArray
                 Int_t fGeoCacheMaxSize       maximum initial cache size
                 Int_t fGeoCacheDefaultLevel  default level down to store nodes
                 Int_t fGeoCacheMaxLevels     maximum supported number of levels
                 Int_t fGeoCacheObjArrayInd   maximum number of daughters stored as node arrays
                 Int_t fGeoCacheStackSize     maximum size of the stack
                 Int_t fLevel                 level in the current branch
                 Int_t fCurrentID             unique ID of current node
               TString fPath                  path for current branch
            TObjArray* fStack                 stack of cache states
                Int_t* fNodeIdArray           ! array of node id's
                 Int_t fIndex                 index in array of ID's
      TGeoMatrixCache* fMatrixPool            pool of compressed global matrices
                 Int_t fIdBranch[30]          current branch of indices

Class Description

 Physical tree description.

 dummy constructor

 dummy constructor

 constructor

copy constructor

assignment operator

 destructor

 Builds node id array.

 Returns a fixed ID for current physical node

 Compact arrays

 Delete all node caches.

 Add a logical node in the cache corresponding to ndaughters.

 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)

 Make daughter 'index' of current node the current one.
 first make sure that current node is also current in its cache

 Change current path to mother.

 Free nodes which are not persistent from cache except the current branch.
 first compute count limit for persistency

 Dump all non-persistent branches.

 Clear only the node nindex.

 Get mother of current logical node, <up> levels up.

 Get unique node id.

 Returns the current path.

 Print some info about current node.

 Push current state into heap.

 Refresh current state.

 Pop next state/point from heap.

 Pop next state/point from heap and restore matrices starting from LEVEL.

 Set matrix cache persistent.

 Print status of cache.