UgliLoanPool.cxx

Go to the documentation of this file.

// $Id: UgliLoanPool.cxx,v 1.50 2009/05/18 14:59:06 kasahara Exp $
//
// UgliLoanPool
//
// UgliLoanPool is Singleton for managing the "active" Ugliii
//
// Author:  R. Hatcher 2000.05.15
//

#include "UgliGeometry/UgliLoanPool.h"

#include <vector>

#include "TSystem.h"
#include "TROOT.h"
#include "TClass.h"
#include "TFile.h"

class UgliGeometryReroot;

#include "UgliGeometry/UgliGeometry.h"
#include "UgliGeometry/UgliGeomHandle.h"
#include "UgliGeometry/UgliDbiTables.h"
#include "Util/UtilString.h"
#include "Validity/VldContext.h"
#include "Validity/VldRange.h"
#include "Util/UtilString.h"
#include "LeakChecker/LeaMemMonitor.h"

#include "MessageService/MsgService.h"
CVSID("$Id: UgliLoanPool.cxx,v 1.50 2009/05/18 14:59:06 kasahara Exp $");

#include <cassert>

ClassImp(UgliLoanPool)

//_____________________________________________________________________________
// Initialize static members

UgliLoanPool *UgliLoanPool::fgInstance = 0;

const Int_t dfltMaxUnused = 1;

//____________________________________________________________________________

void UgliLoanPool::SetAlwaysUseDbi(Bool_t flag)
{
  UgliLoanPool::Instance()->Set(Form("AlwaysUseDbi=%d",(int)flag));
}

//____________________________________________________________________________

Bool_t UgliLoanPool::GetAlwaysUseDbi()
{
  const Registry& r = UgliLoanPool::Instance()->GetConfig();
  int tmpi = 1;
  r.Get("AlwaysUseDbi",tmpi);
  return tmpi;
}

//____________________________________________________________________________

void UgliLoanPool::SetUseGeo(Bool_t flag)
{
  // Can be used to reconfigure UgliLoanPool for geometry model choice
  UgliLoanPool::Instance()->Set(Form("UseGeo=%d",(int)flag));
  fUseGeo = flag;
}

//____________________________________________________________________________

void UgliLoanPool::SetUseNewCavern(Bool_t flag)
{
  // Can be used to reconfigure UgliLoanPool for use of new cavern layout
  // Default: false
  UgliLoanPool::Instance()->Set(Form("UseNewCavern=%d",(int)flag));

}

//____________________________________________________________________________

void UgliLoanPool::SetShieldOff(Bool_t flag)
{
  // Can be used to reconfigure UgliLoanPool to turn shield off
  UgliLoanPool::Instance()->Set(Form("ShieldOff=%d",(int)flag));

}

//____________________________________________________________________________

void UgliLoanPool::SetSwimMethodLowField(Geo::ESwimMethod swimmethod)
{
  // Used to reconfigure UgliLoanPool swim method in low field regions 
  UgliLoanPool::Instance()->Set(Form("SwimMethodLowField=%d",(int)swimmethod));
}

//____________________________________________________________________________

bool UgliLoanPool::GetUseNewCavern() const 
{
  // Used to retrieve UseNewCavern flag
  const Registry& r = UgliLoanPool::Instance()->GetConfig();
  int usenewcavern = 0;
  if ( r.Get("UseNewCavern",usenewcavern) ) return usenewcavern;
  return false;
}

//____________________________________________________________________________

bool UgliLoanPool::GetShieldOff() const 
{
  // Used to retrieve ShieldOff flag
  const Registry& r = UgliLoanPool::Instance()->GetConfig();
  int shieldoff = 0;
  if ( r.Get("ShieldOff",shieldoff) ) return shieldoff;
  return false;
}

//____________________________________________________________________________

Geo::ESwimMethod UgliLoanPool::GetSwimMethodLowField() const
{
  // Used to retrieve swim method configuration in low field region
  const Registry& r = UgliLoanPool::Instance()->GetConfig();
  int swimmethod = -1;
  if ( r.Get("SwimMethodLowField",swimmethod) ) 
    return (Geo::ESwimMethod)swimmethod;
  else return Geo::kUnknownSwimMethod;

}

//____________________________________________________________________________

void UgliLoanPool::SetSwimMethodHighField(Geo::ESwimMethod swimmethod)
{
  // Used to reconfigure UgliLoanPool swim method in high field regions 
  UgliLoanPool::Instance()
                     ->Set(Form("SwimMethodHighField=%d",(int)swimmethod));
}

//____________________________________________________________________________

Geo::ESwimMethod UgliLoanPool::GetSwimMethodHighField() const
{
  // Used to retrieve swim method configuration in high field region
  const Registry& r = UgliLoanPool::Instance()->GetConfig();
  int swimmethod = -1;
  if ( r.Get("SwimMethodHighField",swimmethod) )
    return (Geo::ESwimMethod)swimmethod;
  else return Geo::kUnknownSwimMethod;

}

//____________________________________________________________________________

void UgliLoanPool::SetMedium(Geo::EDetComponent detcomp, const char* medName)
{
  // Used to configure medium in specified detector component
  Registry& r = UgliLoanPool::Instance()->GetConfig();
  Registry mediumMap;
  if ( !r.Get("MediumMap",mediumMap) ) {
    MSG("Ugli",Msg::kError) << "SetMedium " << medName << " for det component "
                            << Geo::AsString(detcomp) << " failed due to "
                            << "missing MediumMap Registry." << endl;
    return;
  }
  mediumMap.UnLockKeys();
  mediumMap.UnLockValues();
  mediumMap.Set(Geo::AsString(detcomp),medName);
  mediumMap.LockValues();
  mediumMap.LockKeys();

  r.UnLockValues();
  r.Set("MediumMap",mediumMap);
  r.LockValues();
  
}

//____________________________________________________________________________
const char* UgliLoanPool::GetMedium(Geo::EDetComponent detcomp) const
{
  // Used to retrieve medium for specified detector component if configured
  // by user.  Returns empty string if not found.
  const Registry& r = UgliLoanPool::Instance()->GetConfig();
  Registry mediumMap;
  if ( !r.Get("MediumMap",mediumMap) ) {
    MSG("Ugli",Msg::kError) << "GetMedium for det component "
                            << Geo::AsString(detcomp) << " failed due to "
                            << "missing MediumMap registry." << endl;
    return "";
  }
  const char* tmps;
  if ( mediumMap.Get(Geo::AsString(detcomp),tmps) ) 
                             return std::string(tmps).c_str();

  return ""; // null if no entry in map

}

//____________________________________________________________________________
void UgliLoanPool::SetProcess(UtilMCFlag::EProcess process, Int_t value,
                              const char* medName) {
  // Used to configure physics process flag value for a specific medium

  Registry& r = UgliLoanPool::Instance()->GetConfig();
  Registry medConfig;
  bool isNew = false;
  // fill it with existing registry if present
  if ( !r.Get(medName,medConfig) ) isNew = true; 

  medConfig.UnLockKeys();
  medConfig.UnLockValues();
  medConfig.Set(UtilMCFlag::AsString(process),value);
  medConfig.LockValues();
  medConfig.LockKeys();

  if ( isNew ) r.UnLockKeys();
  r.UnLockValues();
  r.Set(medName,medConfig);
  r.LockValues();
  if ( isNew ) r.LockKeys();
  
}

//____________________________________________________________________________
void UgliLoanPool::SetCut(UtilMCFlag::ECut cut, Double_t value,
                          const char* medName) {
  // Used to configure cut flag value for a specific medium

  Registry& r = UgliLoanPool::Instance()->GetConfig();
  Registry medConfig;
  bool isNew = false;
  // fill it with existing registry if present
  if ( !r.Get(medName,medConfig) ) isNew = true; 

  medConfig.UnLockKeys();
  medConfig.UnLockValues();
  medConfig.Set(UtilMCFlag::AsString(cut),value);
  medConfig.LockValues();
  medConfig.LockKeys();

  if ( isNew ) r.UnLockKeys();
  r.UnLockValues();
  r.Set(medName,medConfig);
  r.LockValues();
  if ( isNew ) r.LockKeys();
  
}

//____________________________________________________________________________
void UgliLoanPool::SetTracking(UtilMCFlag::ETracking trk, Double_t value,
                               const char* medName) {
  // Used to configure tracking flag value for a specific medium

  Registry& r = UgliLoanPool::Instance()->GetConfig();
  Registry medConfig;
  bool isNew = false;
  // fill it with existing registry if present
  if ( !r.Get(medName,medConfig) ) isNew = true; 

  medConfig.UnLockKeys();
  medConfig.UnLockValues();
  medConfig.Set(UtilMCFlag::AsString(trk),value);
  medConfig.LockValues();
  medConfig.LockKeys();

  if ( isNew ) r.UnLockKeys();
  r.UnLockValues();
  r.Set(medName,medConfig);
  r.LockValues();
  if ( isNew ) r.LockKeys();
  
}

//____________________________________________________________________________
Registry UgliLoanPool::GetMediumRegistry(const char* medName) const {
  // Used to retrieve configuration registry for a given medium.  If
  // it doesn't exist, an empty registry is returned.

  const Registry& r = UgliLoanPool::Instance()->GetConfig();
  Registry medConfig;  // empty by default
  r.Get(medName,medConfig); // fills registry if key exists 
  return medConfig; 

}

//_____________________________________________________________________________
UgliLoanPool *UgliLoanPool::Instance()
{
// protect Singleton to ensure there is only one
   if (fgInstance == 0) {
      MSG("Ugli",Msg::kSynopsis) << "UgliLoanPool instance creation" << endl;

      static UgliLoanPool::Cleaner c; // end-of-run clean up
      c.ClassIsUsed();

      fgInstance = new UgliLoanPool;

      // intialize intial (default) configuration
      Registry& r = fgInstance->GetConfig();
      r.SetName("UgliLoanPool Configuration");
      r.Merge(fgInstance->DefaultConfig());
      r.LockKeys();
      fgInstance->SetConfigFromEnvironment();
      fgInstance->Update();
      // if Config has 'Cache' try reading that
      // do this here rather than in Config() so that it only happens
      // on the first creation (i.e. later Config's don't redo this)
      if ( r.KeyExists("Cache") ) {
        const char* cache_location = "";
        if ( r.Get("Cache",cache_location) && strlen(cache_location) )
          UgliLoanPool::ReadFromFile(cache_location);
      }
   }
   return fgInstance;
}

//_____________________________________________________________________________
void UgliLoanPool::Config()
{
  //  Reconfigure after internal registry update.

  MSG("Ugli",Msg::kDebug) << "UgliLoanPool::Config " << endl;

  Registry& r = GetConfig();
  // r.Print();

  int tmpi;
  if (r.Get("MaxUnref",tmpi)) fMaxUnref = tmpi;
  if (r.Get("UseGeo",tmpi)) fUseGeo = tmpi;
  
  const char* dets[] = { "Near","Far","CalDet"};
  char itemnameAlg[1024];
  char itemnameCut[1024];

  for (unsigned int i=0; i<sizeof(dets)/sizeof(char*); ++i) {

    sprintf(itemnameAlg,"Algorithmic%s",dets[i]);
    MSG("Ugli",Msg::kDebug)
      << "lookup in Config's registry for " << itemnameAlg << endl;
    if (r.Get(itemnameAlg,tmpi)) {
      Detector::Detector_t det = 
        Detector::CharToEnum(dets[i][0]);
      // actual set flag only if it's different from current value
      bool new_setting = tmpi;
      bool current_setting = UgliDbiTables::IsAlgorithmic(det);
      if (new_setting != current_setting) {
        MSG("Ugli",Msg::kInfo)
          << "Set Algorithmic geometry for " << Detector::AsString(det)
          << " to " << (tmpi?"true":"false") << endl;
        UgliDbiTables::SetAlgorithmic(det,tmpi);
      }
    }

    sprintf(itemnameCut,"CutOnPlnInstall%s",dets[i]);
    MSG("Ugli",Msg::kDebug)
      << "lookup in Config's registry for " << itemnameCut << endl;
    if (r.Get(itemnameCut,tmpi)) {
      Detector::Detector_t det = 
        Detector::CharToEnum(dets[i][0]);
      // actual set flag only if it's different from current value
      bool new_setting = tmpi;
      bool current_setting = UgliDbiTables::IsCutOnPlnInstall(det);
      if (new_setting != current_setting) {
        MSG("Ugli",Msg::kDebug)
          << "Set CutOnPlnInstall geometry for " << Detector::AsString(det)
          << " to " << (tmpi?"true":"false") << endl;
        UgliDbiTables::SetCutOnPlnInstall(det,tmpi);
      }
    }

  }

}

//_____________________________________________________________________________
const Registry& UgliLoanPool::DefaultConfig() const
{
  //======================================================================
  // The default configuration for this framework component
  //======================================================================
  int itrue  = 1; // Work around for Registry's lack of bool
  int ifalse = 0; // Work around for Registry's lack of bool
  static Registry r;
  
  std::string name = this->GetName();
  name += ".config.default";
  r.SetName(name.c_str());
  
  r.UnLockValues();
  r.Set("AlwaysUseDbi",          1);
  r.Set("MaxUnref",              dfltMaxUnused);
  r.Set("UseGeo",                itrue);
  r.Set("UseNewCavern",          ifalse);
  r.Set("ShieldOff",             ifalse);
  r.Set("SwimMethodHighField",   Geo::kRungeKutta);
  r.Set("SwimMethodLowField",    Geo::kNoFieldSwim);
  r.Set("Cache",                 "");        // use no cache by default
  r.Set("CacheWrite",            itrue);     // if cache used, write at job end
  r.Set("AlgorithmicNear",       ifalse);
  r.Set("AlgorithmicFar",        ifalse);
  r.Set("AlgorithmicCalDet",     ifalse);
  r.Set("CutOnPlnInstallNear",   ifalse);    // worry about keeping up
  r.Set("CutOnPlnInstallFar",    itrue);     // construction complete!
//r.Set("CutOnPlnInstallFar",    ifalse);    // table isn't complete! (veto)
  r.Set("CutOnPlnInstallCalDet", ifalse);    // no entries
  // how to apply cut to MC
  //   0=no cut, 1=use MC table, 2=force use of Data table
  r.Set("CutAppliesToMC",        0);         // don't apply cut to MC
  r.Set("CutAppliesToVetoShield",ifalse);    // don't apply cut to VetoShield
  r.Set("CutMsgLevel",           "Synopsis"); // MsgLevel to report cuts at
  r.Set("PurgeDbiTableCache",    itrue);     // purge Dbi cache when geom built
  r.Set("MediumMap", Registry()); // empty registry 

  r.LockValues();
  r.LockKeys();
  
  return r;

}

//_____________________________________________________________________________
void UgliLoanPool::SetConfigFromEnvironment()
{
  // Setup configuration from ENV_UGLI environment variable
  // which conists of a semi-colon separated list of DBI
  // configuration requests.

  const char* strENV_UGLI = gSystem->Getenv("ENV_UGLI");
  if ( strENV_UGLI == 0 || strlen(strENV_UGLI) == 0 ) return;

  MSG("Ugli",Msg::kInfo)
    << "Configuring UgliGeometry from the environment variable ENV_UGLI:" << endl
    << "   " << strENV_UGLI << endl;

  std::vector<std::string> configRequests;
  UtilString::StringTok(configRequests, strENV_UGLI, ";");

  for (unsigned entry = 0; entry < configRequests.size(); ++entry)
    this->Set(configRequests[entry].c_str());

}

//_____________________________________________________________________________
bool UgliLoanPool::DoesValidGeomExist(const VldContext& vldc, 
                                      Ugli::EModifyMode mmode,
                                      Geo::EAppType apptype)
{
   // testing if ctor of UgliGeomHandle will construct a new geometry

   Bool_t use_frozen = true;
   switch (mmode) {
   case (Ugli::kModifiable): use_frozen = false; break;
   case (Ugli::kFrozen):     use_frozen = true;  break;
   case (Ugli::kUseGlobal): 
      use_frozen = true;
      if (Ugli::kModifiable == 
          Ugli::GetDefaultModifyMode()) use_frozen = false;
      break;
   }

   if ( !UseGeo() ) {
     UgliGeometry *geom = GetExistingUgliGeometry(vldc,use_frozen);
     if ( geom ) return true;
   }
   else {
     GeoGeometry* geom = GetExistingGeoGeometry(vldc,use_frozen,apptype);
     if ( geom ) return true;
   }
   
   return false;
}

//_____________________________________________________________________________
void UgliLoanPool::ClearPool(Bool_t frozen, Bool_t modifiable)
{

   //LeaMemMonitor::PrintMemStat("Before UgliLoanPool::ClearPool");
   if ( frozen ) {     
     fFrozenUgliGeomList.Delete();
     fFrozenGeoGeomList.Delete();
   }
   if ( modifiable ) {
     fModifiableUgliGeomList.Delete();
     fModifiableGeoGeomList.Delete();
   }
   //LeaMemMonitor::PrintMemStat("After UgliLoanPool::ClearPool");
}

//_____________________________________________________________________________
bool UgliLoanPool::PurgeDbiTableCache() const
{
   // Does the config suggest that DbiTable caches should be purged
   // after the UgliGeometry has been constructed?

   Registry& r = fgInstance->GetConfig();
   int dopurge = true;  // default
   r.Get("PurgeDbiTableCache",dopurge);
   return dopurge;

}

//_____________________________________________________________________________
UgliLoanPool::UgliLoanPool()
  : fMaxUnref(dfltMaxUnused),fUseGeo(true)
{
   // Default ctor -- called by self only

   if (fgInstance && fgInstance != this) {
     MSG("Ugli",Msg::kWarning)
       << "UgliLoanPool ctor() called but global already exists"
       << " -- memory leak (existing one will be lost)"
       << endl;
   }
   fgInstance = this;

   MSG("Ugli",Msg::kSynopsis) << "UgliLoanPool ctor" << endl;

   fFrozenUgliGeomList.SetOwner(true);
   fModifiableUgliGeomList.SetOwner(true);
   fFrozenGeoGeomList.SetOwner(true);
   fModifiableGeoGeomList.SetOwner(true);
   
}

//_____________________________________________________________________________
UgliLoanPool::UgliLoanPool(const UgliLoanPool &plp)
  : TObject(plp), CfgConfigurable(plp)
{
   // copy constuctor should never get called
   MSG("Ugli",Msg::kFatal) << 
               "UgliLoanPool copy constructor called" << endl;
   assert(0);
}

//_____________________________________________________________________________
UgliLoanPool::~UgliLoanPool()
{
  // Destroy UgliLoanPool
  // Write out to Cache first (if requested)

  MSG("Ugli",Msg::kSynopsis) << "UgliLoanPool shutdown" << endl;

  Registry& r = GetConfig();
  if ( r.KeyExists("Cache") ) {
    const char* cache_location = "";
    if ( r.Get("Cache",cache_location) && strlen(cache_location) ) {
      int dowrite = true;
      if ( ! r.Get("CacheWrite",dowrite) ) {
        MSG("Ugli",Msg::kInfo)
          << "UgliLoanPool not configured for 'CacheWrite', assume "
          << dowrite << "." << endl;
      }
      if (dowrite) {
        MSG("Ugli",Msg::kInfo) 
          << "UgliLoanPool writing file " 
          << cache_location << " ..." << flush;
        UgliLoanPool::SaveToFile(cache_location);
        MSG("Ugli",Msg::kInfo) << " done" << endl;
      }
    }
  }

  // delete all the owned sub-objects
  ClearPool(true,true);

}

//_____________________________________________________________________________
UgliGeometry* UgliLoanPool::GetUgliGeometry(const VldContext& vldc, 
                                            Bool_t frozen)
{
   // Find (or create) the right UgliGeometry to give to a handle

   UgliGeometry *geom = GetExistingUgliGeometry(vldc,frozen);
   if (geom) return geom;

   // nothing appropriate, choose one of the managed lists
   // geometry should be placed in
   TObjArray*   geomList = &fFrozenUgliGeomList;
   if (!frozen) geomList = &fModifiableUgliGeomList;

   // first count the # of (other) unreferenced geoms
   UgliGeometry *other_geom = 0;
   Int_t todelete = -fMaxUnref;
   TObjArrayIter iter_cnt(geomList);
   while ( ( other_geom = (UgliGeometry *)iter_cnt.Next() ) ) {
      if ( other_geom->CountRef() <= 0 ) todelete++;
   }
   // if more unreferenced geometries than desired clean them out
   // iterate from the front (default) so oldest get cleaned out first
   if (todelete > 0) {
      TObjArrayIter iter_rm(geomList);
      while ( ( other_geom = (UgliGeometry *)iter_rm.Next() ) && 
              todelete > 0 ) {
         if ( other_geom->CountRef() <= 0 ) {
            geomList->Remove(other_geom);
            delete other_geom;
            todelete--;
         }
      }
      // remove the spaces we freed up
      geomList->Compress();
      MSG("Ugli",Msg::kVerbose) 
         << "GetUgliGeometry removed old unref'd geoms" << endl;
   }

   // no valid UgliGeometry available need to build one
   geom = BuildUgliGeometry(vldc,frozen);
   if ( !geom) {
      MSG("Ugli",Msg::kFatal)
         << "UgliLoanPool failed to build for: " << endl;
      vldc.Print();
      assert(geom);
   }

   // append this new geometry into the list
   MSG("Ugli",Msg::kVerbose) 
      << "GetUgliGeometry returned created new "
      << ((frozen)? "frozen" : "modifiable")
      << " UgliGeometry " << endl;
   geomList->AddLast(geom);

   return geom;

}

//_____________________________________________________________________________
GeoGeometry* UgliLoanPool::GetGeoGeometry(const VldContext& vldc, 
                                          Bool_t frozen, Geo::EAppType apptype)
{
   // Find (or create) the right GeoGeometry to give to a handle
   GeoGeometry *geom = GetExistingGeoGeometry(vldc,frozen,apptype);
   if (geom) return geom;

   // nothing appropriate, choose one of the managed lists
   // geometry should be placed in
   TObjArray*   geomList = &fFrozenGeoGeomList;
   if (!frozen) geomList = &fModifiableGeoGeomList;

   // first count the # of (other) unreferenced geoms
   GeoGeometry *other_geom = 0;
   Int_t todelete = -fMaxUnref;
   TObjArrayIter iter_cnt(geomList);
   while ( ( other_geom = (GeoGeometry *)iter_cnt.Next() ) ) {
      if ( other_geom->CountRef() <= 0 ) todelete++;
   }
   // if more unreferenced geometries than desired clean them out
   // iterate from the front (default) so oldest get cleaned out first
   if (todelete > 0) {
      TObjArrayIter iter_rm(geomList);
      while ( ( other_geom = (GeoGeometry *)iter_rm.Next() ) && 
              todelete > 0 ) {
         if ( other_geom->CountRef() <= 0 ) {
            geomList->Remove(other_geom);
            delete other_geom;
            todelete--;
         }
      }
      // remove the spaces we freed up
      geomList->Compress();
      MSG("Ugli",Msg::kVerbose) 
         << "GetGeoGeometry removed old unref'd geoms" << endl;
   }

   // no valid GeoGeometry available need to build one
   geom = BuildGeoGeometry(vldc,frozen,apptype);
   if ( !geom) {
      MSG("Ugli",Msg::kFatal)
        << "UgliLoanPool failed to build GeoGeometry for:\n" << vldc
        << " apptype " << Geo::AsString(apptype) << "." << endl;
      assert(geom);
   }

   // append this new geometry into the list
   MSG("Ugli",Msg::kVerbose) 
      << "GetGeoGeometry returned created new "
      << ((frozen)? "frozen" : "modifiable")
      << " GeoGeometry for:\n" << vldc << " apptype "  
      << Geo::AsString(apptype) << "." << endl;
   geomList->AddLast(geom);

   return geom;

}

//_____________________________________________________________________________
UgliGeometry* UgliLoanPool::GetExistingUgliGeometry(const VldContext& vldc, 
                                            Bool_t frozen)
{
   // Find the right UgliGeometry if it exists

   UgliGeometry *geom = 0;

   // geometry should come from or be placed in one of
   // the two lists
   TObjArray*   geomList = &fFrozenUgliGeomList;
   if (!frozen) geomList = &fModifiableUgliGeomList;

   // look in the current shared or writable list
   // iterate from the back as that is what was added most recently
   // and thus most likely what we want
   TObjArrayIter iter(geomList,kIterBackward);
   // search the current list
   MSG("Ugli",Msg::kVerbose) << "look for match to VldContext " 
                             << vldc << endl;
   while ( ( geom = dynamic_cast<UgliGeometry *>(iter.Next()) ) ) {
      // check if it is compatible
      if ( geom->IsCompatible(vldc) ) {
         // create another handle to this UgliGeometry
         MSG("Ugli",Msg::kVerbose) << 
            "GetUgliGeometry returned found handle " << endl;
         return geom;
      }
   }
   return 0; // found nothing appropriate
}

//_____________________________________________________________________________
GeoGeometry* UgliLoanPool::GetExistingGeoGeometry(const VldContext& vldc,
                                   Bool_t frozen, Geo::EAppType apptype)
{
   // Find the right GeoGeometry if it exists

   GeoGeometry *geom = 0;
   
   // geometry should come from or be placed in one of
   // the two lists
   TObjArray*   geomList = &fFrozenGeoGeomList;
   if (!frozen) geomList = &fModifiableGeoGeomList;

   // look in the current shared or writable list
   // iterate from the back as that is what was added most recently
   // and thus most likely what we want
   TObjArrayIter iter(geomList,kIterBackward);
   // search the current list
   MSG("Ugli",Msg::kVerbose) << "look for Geo match to VldContext " 
                             << vldc << " and apptype " << apptype << endl;
   while ( ( geom = dynamic_cast<GeoGeometry *>(iter.Next()) ) ) {
      // check if it is compatible
      if ( geom->IsCompatible(vldc,apptype) ) {
         // create another handle to this GeoGeometry
         MSG("Ugli",Msg::kVerbose) << 
            "GetGeoGeometry returned found handle " << endl;
         return geom;
      }
   }
   return 0; // found nothing appropriate
}
   
//_____________________________________________________________________________

UgliGeometry* UgliLoanPool::BuildUgliGeometry(const VldContext& vldc,
                                              Bool_t frozen)
{
   // Fake up a UgliGeometry from where ever

   UgliGeometry *ugliGeometry = 0;

   MSG("Ugli",Msg::kVerbose)
     << "BuildUgliGeometry SimFlag=" << SimFlag::AsString(vldc.GetSimFlag())
     << " AlwaysUseDbi=" << (GetAlwaysUseDbi()?"true":"false") << endl << endl;

   if (vldc.GetSimFlag() == SimFlag::kReroot && !GetAlwaysUseDbi()) {
      // remove circular dependency by using RTTI-like info
      // for UgliGeometryReroot default ctor picks up vldc from RerootExodus
      //was: ugliGeometry = new UgliGeometryReroot(vldc);

      static bool first = true;
      if (first) {
         first = false;
         gROOT->LoadClass("UgliGeometryReroot","libUgliGeometry.so");
      }
      void *ptr = gROOT->GetClass("UgliGeometryReroot",kTRUE)->New();
      if (!ptr) {
         MSG("Ugli",Msg::kFatal)
            <<  "BuildUgliGeometry failed to instantiate UgliGeometryReroot "
            << vldc << endl;
         assert(0);
      }

      MSG("Ugli",Msg::kDebug)
         << "BuildUgliGeometry vldc "
         << vldc << " (REROOT)" << endl;

      // can't dynamic_cast void* pointers
      //    ugliGeometry = dynamic_cast<UgliGeometryReroot*>(ptr);
      //    ugliGeometry = dynamic_cast<UgliGeometry *>(ptr);
      // UgliGeometryReroot isn't know to be a base type for UgliGeometry
      //    ugliGeometry = (UgliGeometryReroot *)(ptr);
      ugliGeometry = (UgliGeometry *)(ptr);
      if (ugliGeometry->GetMINFStatus() == UgliGeometry::kNotThere) {
         // perhaps this data is from a written out "streams file"
         // rather than an old REROOT file
         MSG("Ugli",Msg::kWarning)
            << "UgliGeometryReroot constructed " << endl
            << "   but there is no gMINFast, revert to using DBI version"
            << endl;
         delete ugliGeometry;
         ugliGeometry = 0;
      }
   }

   if (!ugliGeometry) {
      MSG("Ugli",Msg::kDebug)
         << "BuildUgliGeometry vldc "
         << vldc << " (std)" << endl;
      ugliGeometry = new UgliGeometry(vldc,frozen);
   }

   // we do this after-the-fact because we can't pass this into
   // the ctor of UgliGeometryReroot in the above scheme
   ugliGeometry->SetFrozen(frozen);

   return ugliGeometry;
}

//_____________________________________________________________________________

GeoGeometry* UgliLoanPool::BuildGeoGeometry(const VldContext& vldc, 
                                            Bool_t frozen,
                                            Geo::EAppType apptype)
{
   // Build a GeoGeometry for specified vld and application type

   GeoGeometry *geoGeometry = 0;
   if ( !frozen ) {
     MSG("Ugli",Msg::kFatal) << "Geo modifiable geometries not supported yet." 
                             << endl;
     abort();
   }
   
   MSG("Ugli",Msg::kVerbose) 
     << "BuildGeoGeometry for: " << vldc
     << " for apptype " << Geo::AsString(apptype) << "." << endl;

   if (!geoGeometry) {
      MSG("Ugli",Msg::kDebug) 
         << "BuildGeoGeometry vldc "
         << vldc << " app type " << Geo::AsString(apptype) << "." << endl;
      geoGeometry = new GeoGeometry(vldc,apptype);
   }

   return geoGeometry;
}

//_____________________________________________________________________________
void UgliLoanPool::Print(Option_t *option) const
{
// Print info about the current loan pool

   MSG("Ugli",Msg::kVerbose) << "Print" << endl;

   GetConfig().Print();

   if ( !UseGeo() || !fFrozenUgliGeomList.IsEmpty() 
                  || !fModifiableUgliGeomList.IsEmpty() ) {
     UgliGeometry *geom = 0;
     MSG("Ugli",Msg::kInfo) << " --- Frozen UgliLoanPool ---" << endl;
     TIter frozen(&fFrozenUgliGeomList);
     while ( ( geom = (UgliGeometry *)frozen.Next() ) ) geom->Print(option);
   
     MSG("Ugli",Msg::kInfo) << " --- Modifiable UgliLoanPool ---" << endl;
     TIter modifiable(&fModifiableUgliGeomList);
     while ( ( geom = (UgliGeometry *)modifiable.Next() ) )geom->Print(option);
   }
   
   if ( UseGeo() || !fFrozenGeoGeomList.IsEmpty()
                 || !fModifiableGeoGeomList.IsEmpty() ) {
     GeoGeometry* geom = 0;
  
     MSG("Ugli",Msg::kInfo) << " --- Geo Frozen UgliLoanPool ---" << endl;
     TIter frozen(&fFrozenGeoGeomList);
     while ( ( geom = (GeoGeometry *)frozen.Next() ) ) geom->Print(option);

     MSG("Ugli",Msg::kInfo) << " --- Geo Modifiable UgliLoanPool ---" << endl;
     TIter modifiable(&fModifiableGeoGeomList);
     while ( ( geom = (GeoGeometry *)modifiable.Next() ) ) geom->Print(option);
   }
   
   MSG("Ugli",Msg::kInfo) << " --- End of UgliLoanPool ---" << endl;
}

//_____________________________________________________________________________
void UgliLoanPool::SaveToFile(const char* filename, bool recreate)
{
  // save a UgliLoanPool to a file

  UgliLoanPool* plp = UgliLoanPool::Instance(); // make sure there is one

  const char* fmode = "RECREATE";
  if (!recreate) fmode = "UPDATE";
  TFile f(filename,fmode);
  plp->Write();
  f.Write();
  f.Close();
}

//_____________________________________________________________________________
void UgliLoanPool::ReadFromFile(const char* filename)
{
  // read a UgliLoanPool from a file
  // ensure that there isn't a memory leak if a UgliLoanPool already exists
  // by merging the two

  if ( gSystem->AccessPathName(filename,kFileExists) ) {
    // note funky return value:  FALSE is you _can_ access file
    MSG("Ugli",Msg::kInfo)
      << "UgliLoanPool::ReadFromFile() no such file: " << filename << endl;
    return;
  }

  // bitch in general because it really isn't a good idea!
  MSG("Ugli",Msg::kInfo)
    << "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" << endl 
    << "UgliLoanPool::ReadFromFile() used to build some geometries. " << endl
    << "This is really not a safe thing to do in that it bypasses the" << endl
    << "database and thus is not subject to rolling updates.  Any geometry" << endl
    << "will thus reflect the status at the time the file was written" << endl
    << "and may be outdated.  Use at your own risk." << endl
    << "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" << endl;

  UgliLoanPool* ulpPrev = fgInstance;  // save any existing global
  fgInstance = 0;  // so we don't complain about a memory leak

  TFile f(filename);
  UgliLoanPool* ulp = dynamic_cast<UgliLoanPool*>(f.Get("UgliLoanPool"));

  if (!ulp) {
    // file didn't have any UgliLoanPool!
    MSG("Ugli",Msg::kWarning)
      << "UgliLoanPool::ReadFromFile() found no pool in file:"
      << filename
      << endl;
    // revert to old
    fgInstance = ulpPrev;
  }
  else if (ulpPrev) {
    // file had a UgliLoanPool, but we already had one as well
    // merge the two
    MSG("Ugli",Msg::kInfo)
      << "UgliLoanPool::ReadFromFile() will now merge newly read data "
      << "into prior loan pool" << endl;
    // make old loan pool the global one to preserve order
    fgInstance = ulpPrev;
    // loop over elements of newly read pool and move them to global copy
    TObjArray *from, *to;
    for (int pubpriv = 0; pubpriv <= 1; ++pubpriv) {
      if (pubpriv) {
        from = &ulp->fFrozenUgliGeomList;
        to   = &fgInstance->fFrozenUgliGeomList;
      }
      else {
        from = &ulp->fModifiableUgliGeomList;
        to   = &fgInstance->fModifiableUgliGeomList;
      }
      for (int indx = 0; indx <= from->GetLast(); ++indx) {
        UgliGeometry* ugligeom = 
          dynamic_cast<UgliGeometry*>(from->RemoveAt(indx));
        if (ugligeom) {
          // make sure merged geometry has fPlaneTable filled
          ugligeom->RestorePlaneTable(false);
          to->Add(ugligeom);
        }
      } // loop over elements
    } // shared/private 

    // Repeat for Geo arrays
    for (int pubpriv = 0; pubpriv <= 1; ++pubpriv) {
      if (pubpriv) {
        from = &ulp->fFrozenGeoGeomList;
        to   = &fgInstance->fFrozenGeoGeomList;
      }
      else {
        from = &ulp->fModifiableGeoGeomList;
        to   = &fgInstance->fModifiableGeoGeomList;
      }
      for (int indx = 0; indx <= from->GetLast(); ++indx) {
        GeoGeometry* geogeom= dynamic_cast<GeoGeometry*>(from->RemoveAt(indx));
        if (geogeom) to->Add(geogeom);
      } // loop over elements
    } // shared/private 
    // delete newly read, but now empty, pool
    // inhibit writing it out though
    ulp->GetConfig().RemoveKey("Cache");
    delete ulp;
  }


}

//_____________________________________________________________________________

---