// @(#)root/geom:$Id$
// Author: Andrei Gheata   18/03/02

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/

////////////////////////////////////////////////////////////////////////////////
// Physical tree description.
//
//
//
//
//Begin_Html
/*
<img src=".gif">
*/
//End_Html

#include "TGeoManager.h"
#include "TGeoMatrix.h"
#include "TGeoVolume.h"
#include "TGeoCache.h"

//const Int_t kN3 = 3*sizeof(Double_t);


ClassImp(TGeoNodeCache)

/*************************************************************************
 * TGeoNodeCache - special pool of reusable nodes
 *
 *
 *************************************************************************/

//_____________________________________________________________________________
TGeoNodeCache::TGeoNodeCache()
{
// Dummy constructor
   fGeoCacheMaxLevels    = 100;
   fGeoCacheStackSize    = 10;
   fGeoInfoStackSize     = 100;
   fLevel       = 0;
   fStackLevel  = 0;
   fInfoLevel   = 0;
   fCurrentID   = 0;
   fIndex       = 0;
   fPath        = "";
   fTop         = 0;
   fNode        = 0;
   fMatrix      = 0;
   fStack       = 0;
   fMatrixBranch = 0;
   fMPB         = 0;
   fNodeBranch  = 0;
   fInfoBranch  = 0;
   fPWInfo      = 0;
   fNodeIdArray = 0;
   for (Int_t i=0; i<100; i++) fIdBranch[i] = 0;
}

//_____________________________________________________________________________
TGeoNodeCache::TGeoNodeCache(TGeoNode *top, Bool_t nodeid, Int_t capacity)
{
// Default constructor
   fGeoCacheMaxLevels    = capacity;
   fGeoCacheStackSize    = 10;
   fGeoInfoStackSize     = 100;
   fLevel       = 0;
   fStackLevel  = 0;
   fInfoLevel   = 0;
   fCurrentID   = 0;
   fIndex       = 0;
   fPath        = "";
   fTop         = top;
   fNode        = top;
   fStack = new TObjArray(fGeoCacheStackSize);
   for (Int_t ist=0; ist<fGeoCacheStackSize; ist++)
      fStack->Add(new TGeoCacheState(fGeoCacheMaxLevels)); // !obsolete 100
   fMatrixBranch = new TGeoHMatrix *[fGeoCacheMaxLevels];
   fMPB = new TGeoHMatrix *[fGeoCacheMaxLevels];
   fNodeBranch  = new TGeoNode*[fGeoCacheMaxLevels];
   fInfoBranch  = new TGeoStateInfo*[fGeoInfoStackSize];
   for (Int_t i=0; i<fGeoCacheMaxLevels; i++) {
      fMPB[i] = new TGeoHMatrix(TString::Format("global_%d",i));
      fMatrixBranch[i] = 0;
      fNodeBranch[i] = 0;
   }
   for (Int_t i=0; i<fGeoInfoStackSize; i++) {
      fInfoBranch[i] = 0;
   }   
   fPWInfo      = 0;
   fMatrix = fMatrixBranch[0] = fMPB[0];
   fNodeBranch[0] = top;
   fNodeIdArray = 0;
   for (Int_t i=0; i<100; i++) fIdBranch[i] = 0;
   if (nodeid) BuildIdArray();
   CdTop();
}

//_____________________________________________________________________________
TGeoNodeCache::~TGeoNodeCache()
{
// Destructor
   if (fStack) {
      fStack->Delete();
      delete fStack;
   }
   if (fMatrixBranch) delete [] fMatrixBranch;
   if (fMPB) {
      for (Int_t i=0; i<fGeoCacheMaxLevels; i++) delete fMPB[i];
      delete [] fMPB;
   }
   delete [] fNodeBranch;
   if (fInfoBranch) {
      for (Int_t i=0; i<fGeoInfoStackSize; i++) delete fInfoBranch[i];
   }
   delete [] fInfoBranch;
   if (fNodeIdArray)  delete [] fNodeIdArray;
   delete fPWInfo;
}

//_____________________________________________________________________________
void TGeoNodeCache::BuildIdArray()
{
// Builds node id array.
   Int_t nnodes = gGeoManager->GetNNodes();
   //if (nnodes>3E7) return;
   if (fNodeIdArray) delete [] fNodeIdArray;
   Info("BuildIDArray","--- node ID tracking enabled, size=%lu Bytes\n", ULong_t((2*nnodes+1)*sizeof(Int_t)));
   fNodeIdArray = new Int_t[2*nnodes+1];
   fNodeIdArray[0] = 0;
   Int_t ifree  = 1;
   Int_t nodeid = 0;
   gGeoManager->GetTopNode()->FillIdArray(ifree, nodeid, fNodeIdArray);
   fIdBranch[0] = 0;
}

//_____________________________________________________________________________
void TGeoNodeCache::BuildInfoBranch()
{
// Bulds info branch. Navigation is possible only after this step.
   if (!fInfoBranch) fInfoBranch  = new TGeoStateInfo*[fGeoInfoStackSize];
   else if (fInfoBranch[0]) return;
   for (Int_t i=0; i<fGeoInfoStackSize; i++) {
      fInfoBranch[i] = new TGeoStateInfo();
   }
}

//_____________________________________________________________________________
TGeoStateInfo *TGeoNodeCache::GetMakePWInfo(Int_t nd)
{
// Get the PW info, if none create one
   if (fPWInfo) return fPWInfo;
   fPWInfo = new TGeoStateInfo(nd);
   return fPWInfo;
}   

//_____________________________________________________________________________
void TGeoNodeCache::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)
   if (!fNodeIdArray) {
      Error("CdNode", "Navigation based on phisical node unuique id disabled.\n   To enable, use: gGeoManager->GetCache()->BuildIdArray()");
      return;
   }
   Int_t *arr = fNodeIdArray;
   if (nodeid == arr[fIndex]) return;
   while (fLevel>0) {
      gGeoManager->CdUp();
      if (nodeid == arr[fIndex]) return;
   }
   gGeoManager->CdTop();
   Int_t currentID = 0;
   Int_t nd = GetNode()->GetNdaughters();
   Int_t nabove, nbelow, middle;
   while (nodeid!=currentID && nd) {
      nabove = nd+1;
      nbelow = 0;
      while (nabove-nbelow > 1) {
         middle = (nabove+nbelow)>>1;
         currentID = arr[arr[fIndex+middle]];
         if (nodeid == currentID) {
            gGeoManager->CdDown(middle-1);
            return;
         }
         if (nodeid < currentID) nabove = middle;
         else                    nbelow = middle;
      }
      gGeoManager->CdDown(nbelow-1);
      currentID = arr[fIndex];
      nd = GetNode()->GetNdaughters();
   }
}

//_____________________________________________________________________________
Bool_t TGeoNodeCache::CdDown(Int_t index)
{
// Make daughter INDEX of current node the active state. Compute global matrix.
   TGeoNode *newnode = fNode->GetDaughter(index);
   if (!newnode) return kFALSE;
   fLevel++;
   if (fNodeIdArray) {
      fIndex = fNodeIdArray[fIndex+index+1];
      fIdBranch[fLevel] = fIndex;
   }
   fNode = newnode;
   fNodeBranch[fLevel] = fNode;
   TGeoMatrix  *local = newnode->GetMatrix();
   TGeoHMatrix *newmat = fMPB[fLevel];
   if (!local->IsIdentity()) {
      newmat->CopyFrom(fMatrix);
      newmat->Multiply(local);
      fMatrix = newmat;
   }
   fMatrixBranch[fLevel] = fMatrix;
   return kTRUE;
}

//_____________________________________________________________________________
Bool_t TGeoNodeCache::CdDown(TGeoNode *newnode)
{
// Make daughter INDEX of current node the active state. Compute global matrix.
   if (!newnode) return kFALSE;
   fLevel++;
   if (fNodeIdArray) {
      Int_t index = fNode->GetVolume()->GetIndex(newnode);
      fIndex = fNodeIdArray[fIndex+index+1];
      fIdBranch[fLevel] = fIndex;
   }
   fNode = newnode;
   fNodeBranch[fLevel] = fNode;
   TGeoMatrix  *local = newnode->GetMatrix();
   TGeoHMatrix *newmat = fMPB[fLevel];
   if (!local->IsIdentity()) {
      newmat->CopyFrom(fMatrix);
      newmat->Multiply(local);
      fMatrix = newmat;
   }
   fMatrixBranch[fLevel] = fMatrix;
   return kTRUE;
}

//_____________________________________________________________________________
void TGeoNodeCache::CdUp()
{
// Make mother of current node the active state.
   if (!fLevel) return;
   fLevel--;
   if (fNodeIdArray) fIndex = fIdBranch[fLevel];
   fNode = fNodeBranch[fLevel];
   fMatrix = fMatrixBranch[fLevel];
}

//_____________________________________________________________________________
Int_t TGeoNodeCache::GetCurrentNodeId() const
{
// Returns a fixed ID for current physical node
   if (fNodeIdArray) return fNodeIdArray[fIndex];
   return GetNodeId();
}

//_____________________________________________________________________________
Int_t TGeoNodeCache::GetNodeId() const
{
// Get unique node id.
   Long_t id=0;
   for (Int_t level=0;level<fLevel+1; level++)
      id += (Long_t)fNodeBranch[level];
   return (Int_t)id;
}

//_____________________________________________________________________________
void TGeoNodeCache::GetBranchNames(Int_t *names) const
{
// Fill names with current branch volume names (4 char - used by GEANT3 interface).
   const char *name;
   for (Int_t i=0; i<fLevel+1; i++) {
      name = fNodeBranch[i]->GetVolume()->GetName();
      memcpy(&names[i], name, sizeof(Int_t));
   }
}

//_____________________________________________________________________________
void TGeoNodeCache::GetBranchNumbers(Int_t *copyNumbers, Int_t *volumeNumbers) const
{
// Fill copy numbers of current branch nodes.
   for (Int_t i=0; i<fLevel+1; i++) {
      copyNumbers[i]   = fNodeBranch[i]->GetNumber();
      volumeNumbers[i] = fNodeBranch[i]->GetVolume()->GetNumber();
   }
}

//_____________________________________________________________________________
void TGeoNodeCache::GetBranchOnlys(Int_t *isonly) const
{
// Fill copy numbers of current branch nodes.
   Bool_t ismany = kFALSE;
   for (Int_t i=0; i<fLevel+1; i++) {
      if (!fNodeBranch[i]->IsOffset()) ismany=fNodeBranch[i]->IsOverlapping();
      isonly[i] = (ismany)?0:1;
   }
}

//_____________________________________________________________________________
TGeoStateInfo *TGeoNodeCache::GetInfo()
{
// Get next state info pointer.
   if (fInfoLevel==fGeoInfoStackSize-1) {
      TGeoStateInfo **infoBranch = new TGeoStateInfo*[2*fGeoInfoStackSize];
      memcpy(infoBranch, fInfoBranch, fGeoInfoStackSize*sizeof(TGeoStateInfo*));
      for (Int_t i=fGeoInfoStackSize; i<2*fGeoInfoStackSize; i++)
         infoBranch[i] = new TGeoStateInfo();
      delete [] fInfoBranch;
      fInfoBranch = infoBranch;
      fGeoInfoStackSize *= 2;
   }
   return fInfoBranch[fInfoLevel++];
}

//_____________________________________________________________________________
void TGeoNodeCache::ReleaseInfo()
{
// Release last used state info pointer.
   fInfoLevel--;
}

//_____________________________________________________________________________
const char *TGeoNodeCache::GetPath()
{
// Returns the current geometry path.
   fPath = "";
   for (Int_t level=0;level<fLevel+1; level++) {
      fPath += "/";
      fPath += fNodeBranch[level]->GetName();
   }
   return fPath.Data();
}

//_____________________________________________________________________________
Int_t TGeoNodeCache::PushState(Bool_t ovlp, Int_t startlevel, Int_t nmany, Double_t *point)
{
// Push current state into heap.
   if (fStackLevel>=fGeoCacheStackSize) {
      for (Int_t ist=0; ist<fGeoCacheStackSize; ist++)
         fStack->Add(new TGeoCacheState(fGeoCacheMaxLevels));
   }
   ((TGeoCacheState*)fStack->At(fStackLevel))->SetState(fLevel,startlevel,nmany,ovlp,point);
   return ++fStackLevel;
}

//_____________________________________________________________________________
Bool_t TGeoNodeCache::PopState(Int_t &nmany, Double_t *point)
{
// Pop next state/point from heap.
   if (!fStackLevel) return 0;
   Bool_t ovlp = ((TGeoCacheState*)fStack->At(--fStackLevel))->GetState(fLevel,nmany,point);
   Refresh();
//   return (fStackLevel+1);
   return ovlp;
}

//_____________________________________________________________________________
Bool_t TGeoNodeCache::PopState(Int_t &nmany, Int_t level, Double_t *point)
{
// Pop next state/point from heap and restore matrices starting from LEVEL.
   if (level<=0) return 0;
   Bool_t ovlp = ((TGeoCacheState*)fStack->At(level-1))->GetState(fLevel,nmany,point);
   Refresh();
   return ovlp;
}

//_____________________________________________________________________________
Bool_t TGeoNodeCache::RestoreState(Int_t &nmany, TGeoCacheState *state, Double_t *point)
{
// Pop next state/point from a backed-up state.
   Bool_t ovlp = state->GetState(fLevel,nmany,point);
   Refresh();
   return ovlp;
}

//_____________________________________________________________________________
void TGeoNodeCache::LocalToMaster(const Double_t *local, Double_t *master) const
{
// Local point converted to master frame defined by current matrix.
   fMatrix->LocalToMaster(local, master);
}

//_____________________________________________________________________________
void TGeoNodeCache::MasterToLocal(const Double_t *master, Double_t *local) const
{
// Point in master frame defined by current matrix converted to local one.
   fMatrix->MasterToLocal(master, local);
}

//_____________________________________________________________________________
void TGeoNodeCache::LocalToMasterVect(const Double_t *local, Double_t *master) const
{
// Local vector converted to master frame defined by current matrix.
   fMatrix->LocalToMasterVect(local, master);
}

//_____________________________________________________________________________
void TGeoNodeCache::MasterToLocalVect(const Double_t *master, Double_t *local) const
{
// Vector in master frame defined by current matrix converted to local one.
   fMatrix->MasterToLocalVect(master,local);
}

//_____________________________________________________________________________
void TGeoNodeCache::LocalToMasterBomb(const Double_t *local, Double_t *master) const
{
// Local point converted to master frame defined by current matrix and rescaled with bomb factor.
   fMatrix->LocalToMasterBomb(local, master);
}

//_____________________________________________________________________________
void TGeoNodeCache::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.
   fMatrix->MasterToLocalBomb(master, local);
}

ClassImp(TGeoCacheState)

/*************************************************************************
* TGeoCacheState - class storing the state of the cache at a given moment
*
*
*************************************************************************/

//_____________________________________________________________________________
TGeoCacheState::TGeoCacheState()
{
// Default ctor.
   fCapacity = 0;
   fLevel = 0;
   fNmany = 0;
   fStart = 0;
   memset(fIdBranch, 0, 30*sizeof(Int_t));
   memset(fPoint, 0, 3*sizeof(Int_t));
   fOverlapping = kFALSE;
   fNodeBranch = 0;
   fMatrixBranch = 0;
   fMatPtr = 0;
}

//_____________________________________________________________________________
TGeoCacheState::TGeoCacheState(Int_t capacity)
{
// Ctor.
   fCapacity = capacity;
   fLevel = 0;
   fNmany = 0;
   fStart = 0;
   memset(fIdBranch, 0, 30*sizeof(Int_t));
   memset(fPoint, 0, 3*sizeof(Int_t));
   fOverlapping = kFALSE;
   fNodeBranch = new TGeoNode *[capacity];
   fMatrixBranch = new TGeoHMatrix *[capacity];
   fMatPtr = new TGeoHMatrix *[capacity];
   for (Int_t i=0; i<capacity; i++) {
      fMatrixBranch[i] = new TGeoHMatrix("global");
      fNodeBranch[i] = 0;
   }
}

//_____________________________________________________________________________
TGeoCacheState::TGeoCacheState(const TGeoCacheState& gcs) :
  TObject(gcs),
  fCapacity(gcs.fCapacity),
  fLevel(gcs.fLevel),
  fNmany(gcs.fNmany),
  fStart(gcs.fStart),
  fOverlapping(gcs.fOverlapping)
{
   //copy constructor
   Int_t i;
   for (i=0; i<3; i++) fPoint[i]=gcs.fPoint[i];
   for(i=0; i<30; i++) fIdBranch[i]=gcs.fIdBranch[i];
   fNodeBranch = new TGeoNode *[fCapacity];
   fMatrixBranch = new TGeoHMatrix *[fCapacity];
   fMatPtr = new TGeoHMatrix *[fCapacity];
   for (i=0; i<fCapacity; i++) {
      fNodeBranch[i] = gcs.fNodeBranch[i];
      fMatrixBranch[i] = new TGeoHMatrix(*gcs.fMatrixBranch[i]);
      fMatPtr[i] = gcs.fMatPtr[i];
   }
}

//_____________________________________________________________________________
TGeoCacheState& TGeoCacheState::operator=(const TGeoCacheState& gcs)
{
   //assignment operator
   Int_t i;
   if(this!=&gcs) {
      TObject::operator=(gcs);
      fCapacity=gcs.fCapacity;
      fLevel=gcs.fLevel;
      fNmany=gcs.fNmany;
      fStart=gcs.fStart;
      for(i=0; i<30; i++) fIdBranch[i]=gcs.fIdBranch[i];
      for(i=0; i<3; i++) fPoint[i]=gcs.fPoint[i];
      fOverlapping=gcs.fOverlapping;
      fNodeBranch = new TGeoNode *[fCapacity];
      fMatrixBranch = new TGeoHMatrix *[fCapacity];
      fMatPtr = new TGeoHMatrix *[fCapacity];
      for (i=0; i<fCapacity; i++) {
         fNodeBranch[i] = gcs.fNodeBranch[i];
         fMatrixBranch[i] = new TGeoHMatrix(*gcs.fMatrixBranch[i]);
         fMatPtr[i] = gcs.fMatPtr[i];
      }
   }
   return *this;
}

//_____________________________________________________________________________
TGeoCacheState::~TGeoCacheState()
{
// Dtor.
   if (fNodeBranch) {
      for (Int_t i=0; i<fCapacity; i++) {
         delete fMatrixBranch[i];
      }
      delete [] fNodeBranch;
      delete [] fMatrixBranch;
      delete [] fMatPtr;
   }
}

//_____________________________________________________________________________
void TGeoCacheState::SetState(Int_t level, Int_t startlevel, Int_t nmany, Bool_t ovlp, Double_t *point)
{
// Fill current modeller state.
   fLevel = level;
   fStart = startlevel;
   fNmany = nmany;
   TGeoNodeCache *cache = gGeoManager->GetCache();
   if (cache->HasIdArray()) memcpy(fIdBranch, cache->GetIdBranch()+fStart, (level+1-fStart)*sizeof(Int_t));
   TGeoNode **node_branch = (TGeoNode **) cache->GetBranch();
   TGeoHMatrix **mat_branch  = (TGeoHMatrix **) cache->GetMatrices();
   Int_t nelem = level+1-fStart;
   memcpy(fNodeBranch, node_branch+fStart, nelem*sizeof(TGeoNode *));
   memcpy(fMatPtr, mat_branch+fStart, nelem*sizeof(TGeoHMatrix *));
   TGeoHMatrix *last = 0;
   TGeoHMatrix *current;
   for (Int_t i=0; i<nelem; i++) {
      current = mat_branch[i+fStart];
      if (current == last) continue;
      *fMatrixBranch[i] = current;
      last = current;
   }
   fOverlapping = ovlp;
   if (point) memcpy(fPoint, point, 3*sizeof(Double_t));
}

//_____________________________________________________________________________
Bool_t TGeoCacheState::GetState(Int_t &level, Int_t &nmany, Double_t *point) const
{
// Restore a modeler state.
   level = fLevel;
   nmany = fNmany;
   TGeoNodeCache *cache = gGeoManager->GetCache();
   if (cache->HasIdArray()) cache->FillIdBranch(fIdBranch, fStart);
   TGeoNode **node_branch = (TGeoNode **) cache->GetBranch();
   TGeoHMatrix **mat_branch  = (TGeoHMatrix **) cache->GetMatrices();
   Int_t nelem = level+1-fStart;
   memcpy(node_branch+fStart, fNodeBranch, nelem*sizeof(TGeoNode *));
   memcpy(mat_branch+fStart, fMatPtr, (level+1-fStart)*sizeof(TGeoHMatrix *));
   TGeoHMatrix *last = 0;
   TGeoHMatrix *current;
   for (Int_t i=0; i<nelem; i++) {
      current = mat_branch[i+fStart];
      if (current == last) continue;
      *current = fMatrixBranch[i];
      last = current;
   }
   if (point) memcpy(point, fPoint, 3*sizeof(Double_t));
   return fOverlapping;
}
 TGeoCache.cxx:1
 TGeoCache.cxx:2
 TGeoCache.cxx:3
 TGeoCache.cxx:4
 TGeoCache.cxx:5
 TGeoCache.cxx:6
 TGeoCache.cxx:7
 TGeoCache.cxx:8
 TGeoCache.cxx:9
 TGeoCache.cxx:10
 TGeoCache.cxx:11
 TGeoCache.cxx:12
 TGeoCache.cxx:13
 TGeoCache.cxx:14
 TGeoCache.cxx:15
 TGeoCache.cxx:16
 TGeoCache.cxx:17
 TGeoCache.cxx:18
 TGeoCache.cxx:19
 TGeoCache.cxx:20
 TGeoCache.cxx:21
 TGeoCache.cxx:22
 TGeoCache.cxx:23
 TGeoCache.cxx:24
 TGeoCache.cxx:25
 TGeoCache.cxx:26
 TGeoCache.cxx:27
 TGeoCache.cxx:28
 TGeoCache.cxx:29
 TGeoCache.cxx:30
 TGeoCache.cxx:31
 TGeoCache.cxx:32
 TGeoCache.cxx:33
 TGeoCache.cxx:34
 TGeoCache.cxx:35
 TGeoCache.cxx:36
 TGeoCache.cxx:37
 TGeoCache.cxx:38
 TGeoCache.cxx:39
 TGeoCache.cxx:40
 TGeoCache.cxx:41
 TGeoCache.cxx:42
 TGeoCache.cxx:43
 TGeoCache.cxx:44
 TGeoCache.cxx:45
 TGeoCache.cxx:46
 TGeoCache.cxx:47
 TGeoCache.cxx:48
 TGeoCache.cxx:49
 TGeoCache.cxx:50
 TGeoCache.cxx:51
 TGeoCache.cxx:52
 TGeoCache.cxx:53
 TGeoCache.cxx:54
 TGeoCache.cxx:55
 TGeoCache.cxx:56
 TGeoCache.cxx:57
 TGeoCache.cxx:58
 TGeoCache.cxx:59
 TGeoCache.cxx:60
 TGeoCache.cxx:61
 TGeoCache.cxx:62
 TGeoCache.cxx:63
 TGeoCache.cxx:64
 TGeoCache.cxx:65
 TGeoCache.cxx:66
 TGeoCache.cxx:67
 TGeoCache.cxx:68
 TGeoCache.cxx:69
 TGeoCache.cxx:70
 TGeoCache.cxx:71
 TGeoCache.cxx:72
 TGeoCache.cxx:73
 TGeoCache.cxx:74
 TGeoCache.cxx:75
 TGeoCache.cxx:76
 TGeoCache.cxx:77
 TGeoCache.cxx:78
 TGeoCache.cxx:79
 TGeoCache.cxx:80
 TGeoCache.cxx:81
 TGeoCache.cxx:82
 TGeoCache.cxx:83
 TGeoCache.cxx:84
 TGeoCache.cxx:85
 TGeoCache.cxx:86
 TGeoCache.cxx:87
 TGeoCache.cxx:88
 TGeoCache.cxx:89
 TGeoCache.cxx:90
 TGeoCache.cxx:91
 TGeoCache.cxx:92
 TGeoCache.cxx:93
 TGeoCache.cxx:94
 TGeoCache.cxx:95
 TGeoCache.cxx:96
 TGeoCache.cxx:97
 TGeoCache.cxx:98
 TGeoCache.cxx:99
 TGeoCache.cxx:100
 TGeoCache.cxx:101
 TGeoCache.cxx:102
 TGeoCache.cxx:103
 TGeoCache.cxx:104
 TGeoCache.cxx:105
 TGeoCache.cxx:106
 TGeoCache.cxx:107
 TGeoCache.cxx:108
 TGeoCache.cxx:109
 TGeoCache.cxx:110
 TGeoCache.cxx:111
 TGeoCache.cxx:112
 TGeoCache.cxx:113
 TGeoCache.cxx:114
 TGeoCache.cxx:115
 TGeoCache.cxx:116
 TGeoCache.cxx:117
 TGeoCache.cxx:118
 TGeoCache.cxx:119
 TGeoCache.cxx:120
 TGeoCache.cxx:121
 TGeoCache.cxx:122
 TGeoCache.cxx:123
 TGeoCache.cxx:124
 TGeoCache.cxx:125
 TGeoCache.cxx:126
 TGeoCache.cxx:127
 TGeoCache.cxx:128
 TGeoCache.cxx:129
 TGeoCache.cxx:130
 TGeoCache.cxx:131
 TGeoCache.cxx:132
 TGeoCache.cxx:133
 TGeoCache.cxx:134
 TGeoCache.cxx:135
 TGeoCache.cxx:136
 TGeoCache.cxx:137
 TGeoCache.cxx:138
 TGeoCache.cxx:139
 TGeoCache.cxx:140
 TGeoCache.cxx:141
 TGeoCache.cxx:142
 TGeoCache.cxx:143
 TGeoCache.cxx:144
 TGeoCache.cxx:145
 TGeoCache.cxx:146
 TGeoCache.cxx:147
 TGeoCache.cxx:148
 TGeoCache.cxx:149
 TGeoCache.cxx:150
 TGeoCache.cxx:151
 TGeoCache.cxx:152
 TGeoCache.cxx:153
 TGeoCache.cxx:154
 TGeoCache.cxx:155
 TGeoCache.cxx:156
 TGeoCache.cxx:157
 TGeoCache.cxx:158
 TGeoCache.cxx:159
 TGeoCache.cxx:160
 TGeoCache.cxx:161
 TGeoCache.cxx:162
 TGeoCache.cxx:163
 TGeoCache.cxx:164
 TGeoCache.cxx:165
 TGeoCache.cxx:166
 TGeoCache.cxx:167
 TGeoCache.cxx:168
 TGeoCache.cxx:169
 TGeoCache.cxx:170
 TGeoCache.cxx:171
 TGeoCache.cxx:172
 TGeoCache.cxx:173
 TGeoCache.cxx:174
 TGeoCache.cxx:175
 TGeoCache.cxx:176
 TGeoCache.cxx:177
 TGeoCache.cxx:178
 TGeoCache.cxx:179
 TGeoCache.cxx:180
 TGeoCache.cxx:181
 TGeoCache.cxx:182
 TGeoCache.cxx:183
 TGeoCache.cxx:184
 TGeoCache.cxx:185
 TGeoCache.cxx:186
 TGeoCache.cxx:187
 TGeoCache.cxx:188
 TGeoCache.cxx:189
 TGeoCache.cxx:190
 TGeoCache.cxx:191
 TGeoCache.cxx:192
 TGeoCache.cxx:193
 TGeoCache.cxx:194
 TGeoCache.cxx:195
 TGeoCache.cxx:196
 TGeoCache.cxx:197
 TGeoCache.cxx:198
 TGeoCache.cxx:199
 TGeoCache.cxx:200
 TGeoCache.cxx:201
 TGeoCache.cxx:202
 TGeoCache.cxx:203
 TGeoCache.cxx:204
 TGeoCache.cxx:205
 TGeoCache.cxx:206
 TGeoCache.cxx:207
 TGeoCache.cxx:208
 TGeoCache.cxx:209
 TGeoCache.cxx:210
 TGeoCache.cxx:211
 TGeoCache.cxx:212
 TGeoCache.cxx:213
 TGeoCache.cxx:214
 TGeoCache.cxx:215
 TGeoCache.cxx:216
 TGeoCache.cxx:217
 TGeoCache.cxx:218
 TGeoCache.cxx:219
 TGeoCache.cxx:220
 TGeoCache.cxx:221
 TGeoCache.cxx:222
 TGeoCache.cxx:223
 TGeoCache.cxx:224
 TGeoCache.cxx:225
 TGeoCache.cxx:226
 TGeoCache.cxx:227
 TGeoCache.cxx:228
 TGeoCache.cxx:229
 TGeoCache.cxx:230
 TGeoCache.cxx:231
 TGeoCache.cxx:232
 TGeoCache.cxx:233
 TGeoCache.cxx:234
 TGeoCache.cxx:235
 TGeoCache.cxx:236
 TGeoCache.cxx:237
 TGeoCache.cxx:238
 TGeoCache.cxx:239
 TGeoCache.cxx:240
 TGeoCache.cxx:241
 TGeoCache.cxx:242
 TGeoCache.cxx:243
 TGeoCache.cxx:244
 TGeoCache.cxx:245
 TGeoCache.cxx:246
 TGeoCache.cxx:247
 TGeoCache.cxx:248
 TGeoCache.cxx:249
 TGeoCache.cxx:250
 TGeoCache.cxx:251
 TGeoCache.cxx:252
 TGeoCache.cxx:253
 TGeoCache.cxx:254
 TGeoCache.cxx:255
 TGeoCache.cxx:256
 TGeoCache.cxx:257
 TGeoCache.cxx:258
 TGeoCache.cxx:259
 TGeoCache.cxx:260
 TGeoCache.cxx:261
 TGeoCache.cxx:262
 TGeoCache.cxx:263
 TGeoCache.cxx:264
 TGeoCache.cxx:265
 TGeoCache.cxx:266
 TGeoCache.cxx:267
 TGeoCache.cxx:268
 TGeoCache.cxx:269
 TGeoCache.cxx:270
 TGeoCache.cxx:271
 TGeoCache.cxx:272
 TGeoCache.cxx:273
 TGeoCache.cxx:274
 TGeoCache.cxx:275
 TGeoCache.cxx:276
 TGeoCache.cxx:277
 TGeoCache.cxx:278
 TGeoCache.cxx:279
 TGeoCache.cxx:280
 TGeoCache.cxx:281
 TGeoCache.cxx:282
 TGeoCache.cxx:283
 TGeoCache.cxx:284
 TGeoCache.cxx:285
 TGeoCache.cxx:286
 TGeoCache.cxx:287
 TGeoCache.cxx:288
 TGeoCache.cxx:289
 TGeoCache.cxx:290
 TGeoCache.cxx:291
 TGeoCache.cxx:292
 TGeoCache.cxx:293
 TGeoCache.cxx:294
 TGeoCache.cxx:295
 TGeoCache.cxx:296
 TGeoCache.cxx:297
 TGeoCache.cxx:298
 TGeoCache.cxx:299
 TGeoCache.cxx:300
 TGeoCache.cxx:301
 TGeoCache.cxx:302
 TGeoCache.cxx:303
 TGeoCache.cxx:304
 TGeoCache.cxx:305
 TGeoCache.cxx:306
 TGeoCache.cxx:307
 TGeoCache.cxx:308
 TGeoCache.cxx:309
 TGeoCache.cxx:310
 TGeoCache.cxx:311
 TGeoCache.cxx:312
 TGeoCache.cxx:313
 TGeoCache.cxx:314
 TGeoCache.cxx:315
 TGeoCache.cxx:316
 TGeoCache.cxx:317
 TGeoCache.cxx:318
 TGeoCache.cxx:319
 TGeoCache.cxx:320
 TGeoCache.cxx:321
 TGeoCache.cxx:322
 TGeoCache.cxx:323
 TGeoCache.cxx:324
 TGeoCache.cxx:325
 TGeoCache.cxx:326
 TGeoCache.cxx:327
 TGeoCache.cxx:328
 TGeoCache.cxx:329
 TGeoCache.cxx:330
 TGeoCache.cxx:331
 TGeoCache.cxx:332
 TGeoCache.cxx:333
 TGeoCache.cxx:334
 TGeoCache.cxx:335
 TGeoCache.cxx:336
 TGeoCache.cxx:337
 TGeoCache.cxx:338
 TGeoCache.cxx:339
 TGeoCache.cxx:340
 TGeoCache.cxx:341
 TGeoCache.cxx:342
 TGeoCache.cxx:343
 TGeoCache.cxx:344
 TGeoCache.cxx:345
 TGeoCache.cxx:346
 TGeoCache.cxx:347
 TGeoCache.cxx:348
 TGeoCache.cxx:349
 TGeoCache.cxx:350
 TGeoCache.cxx:351
 TGeoCache.cxx:352
 TGeoCache.cxx:353
 TGeoCache.cxx:354
 TGeoCache.cxx:355
 TGeoCache.cxx:356
 TGeoCache.cxx:357
 TGeoCache.cxx:358
 TGeoCache.cxx:359
 TGeoCache.cxx:360
 TGeoCache.cxx:361
 TGeoCache.cxx:362
 TGeoCache.cxx:363
 TGeoCache.cxx:364
 TGeoCache.cxx:365
 TGeoCache.cxx:366
 TGeoCache.cxx:367
 TGeoCache.cxx:368
 TGeoCache.cxx:369
 TGeoCache.cxx:370
 TGeoCache.cxx:371
 TGeoCache.cxx:372
 TGeoCache.cxx:373
 TGeoCache.cxx:374
 TGeoCache.cxx:375
 TGeoCache.cxx:376
 TGeoCache.cxx:377
 TGeoCache.cxx:378
 TGeoCache.cxx:379
 TGeoCache.cxx:380
 TGeoCache.cxx:381
 TGeoCache.cxx:382
 TGeoCache.cxx:383
 TGeoCache.cxx:384
 TGeoCache.cxx:385
 TGeoCache.cxx:386
 TGeoCache.cxx:387
 TGeoCache.cxx:388
 TGeoCache.cxx:389
 TGeoCache.cxx:390
 TGeoCache.cxx:391
 TGeoCache.cxx:392
 TGeoCache.cxx:393
 TGeoCache.cxx:394
 TGeoCache.cxx:395
 TGeoCache.cxx:396
 TGeoCache.cxx:397
 TGeoCache.cxx:398
 TGeoCache.cxx:399
 TGeoCache.cxx:400
 TGeoCache.cxx:401
 TGeoCache.cxx:402
 TGeoCache.cxx:403
 TGeoCache.cxx:404
 TGeoCache.cxx:405
 TGeoCache.cxx:406
 TGeoCache.cxx:407
 TGeoCache.cxx:408
 TGeoCache.cxx:409
 TGeoCache.cxx:410
 TGeoCache.cxx:411
 TGeoCache.cxx:412
 TGeoCache.cxx:413
 TGeoCache.cxx:414
 TGeoCache.cxx:415
 TGeoCache.cxx:416
 TGeoCache.cxx:417
 TGeoCache.cxx:418
 TGeoCache.cxx:419
 TGeoCache.cxx:420
 TGeoCache.cxx:421
 TGeoCache.cxx:422
 TGeoCache.cxx:423
 TGeoCache.cxx:424
 TGeoCache.cxx:425
 TGeoCache.cxx:426
 TGeoCache.cxx:427
 TGeoCache.cxx:428
 TGeoCache.cxx:429
 TGeoCache.cxx:430
 TGeoCache.cxx:431
 TGeoCache.cxx:432
 TGeoCache.cxx:433
 TGeoCache.cxx:434
 TGeoCache.cxx:435
 TGeoCache.cxx:436
 TGeoCache.cxx:437
 TGeoCache.cxx:438
 TGeoCache.cxx:439
 TGeoCache.cxx:440
 TGeoCache.cxx:441
 TGeoCache.cxx:442
 TGeoCache.cxx:443
 TGeoCache.cxx:444
 TGeoCache.cxx:445
 TGeoCache.cxx:446
 TGeoCache.cxx:447
 TGeoCache.cxx:448
 TGeoCache.cxx:449
 TGeoCache.cxx:450
 TGeoCache.cxx:451
 TGeoCache.cxx:452
 TGeoCache.cxx:453
 TGeoCache.cxx:454
 TGeoCache.cxx:455
 TGeoCache.cxx:456
 TGeoCache.cxx:457
 TGeoCache.cxx:458
 TGeoCache.cxx:459
 TGeoCache.cxx:460
 TGeoCache.cxx:461
 TGeoCache.cxx:462
 TGeoCache.cxx:463
 TGeoCache.cxx:464
 TGeoCache.cxx:465
 TGeoCache.cxx:466
 TGeoCache.cxx:467
 TGeoCache.cxx:468
 TGeoCache.cxx:469
 TGeoCache.cxx:470
 TGeoCache.cxx:471
 TGeoCache.cxx:472
 TGeoCache.cxx:473
 TGeoCache.cxx:474
 TGeoCache.cxx:475
 TGeoCache.cxx:476
 TGeoCache.cxx:477
 TGeoCache.cxx:478
 TGeoCache.cxx:479
 TGeoCache.cxx:480
 TGeoCache.cxx:481
 TGeoCache.cxx:482
 TGeoCache.cxx:483
 TGeoCache.cxx:484
 TGeoCache.cxx:485
 TGeoCache.cxx:486
 TGeoCache.cxx:487
 TGeoCache.cxx:488
 TGeoCache.cxx:489
 TGeoCache.cxx:490
 TGeoCache.cxx:491
 TGeoCache.cxx:492
 TGeoCache.cxx:493
 TGeoCache.cxx:494
 TGeoCache.cxx:495
 TGeoCache.cxx:496
 TGeoCache.cxx:497
 TGeoCache.cxx:498
 TGeoCache.cxx:499
 TGeoCache.cxx:500
 TGeoCache.cxx:501
 TGeoCache.cxx:502
 TGeoCache.cxx:503
 TGeoCache.cxx:504
 TGeoCache.cxx:505
 TGeoCache.cxx:506
 TGeoCache.cxx:507
 TGeoCache.cxx:508
 TGeoCache.cxx:509
 TGeoCache.cxx:510
 TGeoCache.cxx:511
 TGeoCache.cxx:512
 TGeoCache.cxx:513
 TGeoCache.cxx:514
 TGeoCache.cxx:515
 TGeoCache.cxx:516
 TGeoCache.cxx:517
 TGeoCache.cxx:518
 TGeoCache.cxx:519
 TGeoCache.cxx:520
 TGeoCache.cxx:521
 TGeoCache.cxx:522
 TGeoCache.cxx:523
 TGeoCache.cxx:524
 TGeoCache.cxx:525
 TGeoCache.cxx:526
 TGeoCache.cxx:527
 TGeoCache.cxx:528
 TGeoCache.cxx:529
 TGeoCache.cxx:530
 TGeoCache.cxx:531
 TGeoCache.cxx:532
 TGeoCache.cxx:533
 TGeoCache.cxx:534
 TGeoCache.cxx:535
 TGeoCache.cxx:536
 TGeoCache.cxx:537
 TGeoCache.cxx:538
 TGeoCache.cxx:539
 TGeoCache.cxx:540
 TGeoCache.cxx:541
 TGeoCache.cxx:542
 TGeoCache.cxx:543
 TGeoCache.cxx:544
 TGeoCache.cxx:545
 TGeoCache.cxx:546
 TGeoCache.cxx:547
 TGeoCache.cxx:548
 TGeoCache.cxx:549
 TGeoCache.cxx:550
 TGeoCache.cxx:551
 TGeoCache.cxx:552
 TGeoCache.cxx:553
 TGeoCache.cxx:554
 TGeoCache.cxx:555
 TGeoCache.cxx:556
 TGeoCache.cxx:557
 TGeoCache.cxx:558
 TGeoCache.cxx:559
 TGeoCache.cxx:560
 TGeoCache.cxx:561
 TGeoCache.cxx:562
 TGeoCache.cxx:563
 TGeoCache.cxx:564
 TGeoCache.cxx:565
 TGeoCache.cxx:566
 TGeoCache.cxx:567
 TGeoCache.cxx:568
 TGeoCache.cxx:569
 TGeoCache.cxx:570
 TGeoCache.cxx:571
 TGeoCache.cxx:572
 TGeoCache.cxx:573
 TGeoCache.cxx:574
 TGeoCache.cxx:575
 TGeoCache.cxx:576
 TGeoCache.cxx:577
 TGeoCache.cxx:578
 TGeoCache.cxx:579
 TGeoCache.cxx:580
 TGeoCache.cxx:581
 TGeoCache.cxx:582
 TGeoCache.cxx:583
 TGeoCache.cxx:584