UgliGeometry.cxx

Go to the documentation of this file.

// $Id: UgliGeometry.cxx,v 1.68 2007/02/19 05:57:31 rhatcher Exp $
//
// UgliGeometry
//
// UgliGeometry is single geometry
//
// Author:  R. Hatcher 2000.04.25
//

#include "UgliGeometry/UgliGeometry.h"

#include "UgliGeometry/UgliLoanPool.h"  // for algorithmic stuff
#include "UgliGeometry/UgliScintPlnNode.h"
#include "UgliGeometry/UgliSteelPlnNode.h"

#include "DatabaseInterface/DbiResultPtr.h"
// for Purge
#include "DatabaseInterface/DbiTableProxy.h"
#include "DatabaseInterface/DbiCache.h"

#include "UgliGeometry/UgliDbiTables.h"

#include "UgliGeometry/UgliDbiGeometry.h"
#include "UgliGeometry/UgliDbiScintPlnStruct.h"
#include "UgliGeometry/UgliDbiScintMdlStruct.h"
#include "UgliGeometry/UgliDbiStripStruct.h"
#include "UgliGeometry/UgliDbiSteelPln.h"
#include "UgliGeometry/UgliDbiScintPln.h"
#include "UgliGeometry/UgliDbiScintMdl.h"
#include "UgliGeometry/UgliDbiStrip.h"

#include "UgliGeometry/UgliStripShape.h"
#include "UgliGeometry/TNodeX.h"
#include "UgliGeometry/MinosOutline.h"  // also brings in TXTRU

#include "Conventions/Munits.h"
#include "Plex/PlexVetoShieldHack.h"
#include "Fabrication/FabPlnInstallLookup.h"

#include "MessageService/MsgService.h"
CVSID("$Id: UgliGeometry.cxx,v 1.68 2007/02/19 05:57:31 rhatcher Exp $");

#include "TMath.h"
#include "TCanvas.h"
#include "TMixture.h"
#include "TRotMatrix.h"
#include "TBRIK.h"
#include "TSPHE.h"
#if ROOT_VERSION_CODE >= ROOT_VERSION(5,15,3)
#include "TView3D.h"
#else
#include "TView.h"
#endif
#include "TObjArray.h"
#include "TList.h"

#include <cassert>
#include <float.h>  // FLT_EPSILON for floating point comparison

ClassImp(UgliGeometry)

typedef map<PlexPlaneId,UgliPlnNode*>::const_iterator nodeItr_t;
typedef map<PlexPlaneId,UgliPlnNode*>::const_reverse_iterator nodeRevItr_t;
typedef pair<PlexPlaneId,UgliPlnNode*> nodePair_t;

//_____________________________________________________________________________


size_t BinarySearchNearestLarger(const std::vector<Double_t>& array,
                                   Double_t value )
{
  // Binary search in a vector of values to locate value
  //
  // Vector is assumed to be sorted prior to this call
  // If match is found, function returns position of value
  // If no match found, function returns first element larger than value
  // Except if larger than last element, function returns last element + 1

  size_t n(array.size());

  // special cases
  if ( value > array[n-1] ) return n;  // beyond the end, nothing larger
  if ( value < array[0]   ) return 0;  // trivially easy

  size_t nabove(n+1);
  size_t nbelow(0);
  size_t middle;
  while ( nabove-nbelow > 1 ) {
    middle = (nabove+nbelow)/2;
    /*
    cout << "[" << nbelow << "," << middle << "," << nabove << "] "
         << " n=" << n << endl;
    if ( middle-1 > n-1 ) 
      cout << "BinarySearchNearestLarger bad middle" << endl;
    */
    Double_t vtest = array[middle-1];
    if ( value == vtest) return middle-1;
    if ( value  < vtest) nabove = middle;
    else                 nbelow = middle;
  }
  // fell through without a match
  return nabove-1;
         
}

//_____________________________________________________________________________
UgliGeometry::UgliGeometry()
   : fFrozen(true), fAlgorithmic(false), fRootGeom(0),
     fCachedSteelPlnNode(0), fCachedScintPlnNode(0)
{
   // Default constructor
   MSG("Ugli",Msg::kVerbose) << "UgliGeometry default ctor" << endl;
}

//_____________________________________________________________________________
UgliGeometry::UgliGeometry(const VldContext &vldc, Bool_t frozen)
   : fFrozen(frozen), fAlgorithmic(false), fRootGeom(0),
     fCachedSteelPlnNode(0), fCachedScintPlnNode(0)
{
   // Normal constructor

   fAlgorithmic = UgliDbiTables::IsAlgorithmic(vldc.GetDetector());

   // complete hack to keep a "global" context so that decisions about 
   // veto shield configuration can be made in a pseudo-vacuum.
   // set this *before* going to the loan pool
   if (vldc.GetDetector() == Detector::kFar) 
     PlexVetoShieldHack::SetDefaultContext(vldc);

   //MSG("Ugli",Msg::kInfo) << "UgliGeometry vldc ctor @ " << this << endl;

   BuildAll(vldc);
}

//_____________________________________________________________________________
UgliGeometry::~UgliGeometry()
{
   // delete all the owned sub-objects

   //MSG("Ugli",Msg::kInfo) << "UgliGeometry dtor @ " << this << endl;

   delete fRootGeom;    fRootGeom=0;

   if (CountRef()) {
      MSG("Ugli",Msg::kWarning)
         << "~UgliGeometry still had " << CountRef()
         << " outstanding references " << endl;
   }

}

//_____________________________________________________________________________
UgliGeometry::EMINFStatus UgliGeometry::GetMINFStatus() const
{ return UgliGeometry::kNotNeeded; }

//_____________________________________________________________________________
Bool_t UgliGeometry::IsCompatible(const VldContext &vldc)
{
   // check compatibility of this plex with a context

   return fVldRange.IsCompatible(vldc);

}

//_____________________________________________________________________________
Bool_t UgliGeometry::IsCompatible(const VldContext *vldc)
{
   // check compatibility of this plex with a context

   return fVldRange.IsCompatible(vldc);

}

//_____________________________________________________________________________
UgliScintPlnNode* UgliGeometry::GetScintPlnNode(PlexPlaneId planeid) const
{
   // get a node for a particular scint plane

   fRootGeom->cd();
   TNodeX* hallnode = dynamic_cast<TNodeX*>(fRootGeom->GetNode("hall"));
   if (!hallnode) {
      static int nmsg = 5;
      if (nmsg) {
         MSG("Ugli",Msg::kError) 
            << "GetScintPlnNode found no hall node" << endl;
         nmsg--;
         if (nmsg==0) MSG("Ugli",Msg::kError) 
            << "  ... last of these warnings" << endl;
      }
      return 0;
   }
   hallnode->cd();

   // ensure that plane id passed in didn't have the wrong setting for IsSteel
   PlexPlaneId scintplnid(planeid);
   if (scintplnid.IsSteel()) {
      static Int_t nmsg = 2;
      if (nmsg>0) {
         MSG("Ugli",Msg::kError) 
            << "::GetScintPlnNode passed steel plane id " 
            << planeid.AsString("c") << endl;
         nmsg--;
         if (nmsg==0) MSG("Ugli",Msg::kInfo) 
            << " ... last message " << endl;
      }
      scintplnid.SetIsSteel(kFALSE);
      //rwh:
      assert(0);
   }

   // convert FarDet veto shield id's into one-module-per-plane #'s
   if (scintplnid.GetDetector() == Detector::kFar && 
       scintplnid.IsVetoShield()) {
     VldContext vldc = 
       PlexVetoShieldHack::ConvertRangeToContext(GetVldRange());
     scintplnid = PlexVetoShieldHack::RenumberMuxToMdl(vldc,scintplnid);
   }

   if (scintplnid.GetPlaneCoverage() == PlaneCoverage::kNoActive) {
     static int msglimit = 20; // give up after 20 messages
     if (msglimit) {
       MSG("Ugli",Msg::kError)
         << "::GetScintPlnNode impossible for "
         << scintplnid.AsString("c")
         << ", THERE IS NO SCINTILLATOR!"
         << endl;
       if (--msglimit == 0)
         MSG("Ugli",Msg::kError)
           << " ... last warning of this type" << endl;
     }
     //rwh: assert(0);
     return 0;
   }

   // optimization under the assumption that we'll get multiple
   // sequential requests for same plane (on way to getting individual
   // strips presumably)
   if (fCachedScintPlnId == scintplnid) return fCachedScintPlnNode;

   UgliScintPlnNode* the_node =
#ifdef USENODETODEPTH
      dynamic_cast<UgliScintPlnNode*>(hallnode->GetNodeToDepth(scintplnid.AsString("p"),1));
#else
   //rwh:      dynamic_cast<UgliScintPlnNode*>(fPlaneTable[scintplnid]);
   0;
   // use lookup without possibility of insertion side effect
   typedef std::map<PlexPlaneId,UgliPlnNode*>::const_iterator planeTableItr_t;
   planeTableItr_t pt_itr = fPlaneTable.find(scintplnid);
   if (pt_itr != fPlaneTable.end()) 
     the_node = dynamic_cast<UgliScintPlnNode*>(pt_itr->second);
   if ( ! the_node ) {
     // perhaps the fPlaneTable needs to be refreshed
     RestorePlaneTable(false);
     pt_itr = fPlaneTable.find(scintplnid);
     if (pt_itr != fPlaneTable.end()) 
       the_node = dynamic_cast<UgliScintPlnNode*>(pt_itr->second);
   }
#endif
   if ( ! the_node ) {
      MSG("Ugli",Msg::kError)
         << "GetScintPlnNode could not find pre-constructed plane " 
         << scintplnid.AsString("c") 
         << " in " << fRootGeom->GetName() << endl;
      the_node = 0; // new UgliScintPlnNode(this,scintplnid);
      // sometimes this happens when veto shield electronics were read out
      // before the actual scintillator was installed.
      //rwh: assert(0);
   }

   // update cache of this request
   fCachedScintPlnId   = scintplnid;
   fCachedScintPlnNode = the_node;

   return the_node;
}

//_____________________________________________________________________________
UgliSteelPlnNode* UgliGeometry::GetSteelPlnNode(PlexPlaneId planeid) const
{
   // get a node for a particular scint plane

   fRootGeom->cd();
   TNodeX* hallnode = dynamic_cast<TNodeX*>(fRootGeom->GetNode("hall"));
   if (!hallnode) {
      static int nmsg = 5;
      if (nmsg) {
         MSG("Ugli",Msg::kError) 
            << "GetSteelPlnNode found no hall node" << endl;
         nmsg--;
         if (nmsg==0) MSG("Ugli",Msg::kError) 
            << "  ... last of these warnings" << endl;
      }
      return 0;
   }
   hallnode->cd();

   // ensure that plane id passed in didn't have the wrong setting for IsSteel
   PlexPlaneId steelplnid(planeid);
   if (!steelplnid.IsSteel()) {
      static Int_t nmsg = 2;
      if (nmsg>0) {
         MSG("Ugli",Msg::kWarning) 
            << "::GetSteelPlnNode passed scint plane id " 
            << planeid.AsString("c") << endl;
         nmsg--;
         if (nmsg==0) MSG("Ugli",Msg::kInfo) 
            << " ... last message " << endl;
      }
      steelplnid.SetIsSteel(kTRUE);
      //rwh:
      assert(0);
   }

   // optimization under the assumption that we'll get multiple
   // sequential requests for same plane 
   if (fCachedSteelPlnId == steelplnid) return fCachedSteelPlnNode;

   UgliSteelPlnNode* the_node = 
#ifdef USENODETODEPTH
      dynamic_cast<UgliSteelPlnNode*>(hallnode->GetNodeToDepth(steelplnid.AsString("p"),1));
#else
   //rwh:      dynamic_cast<UgliSteelPlnNode*>(fPlaneTable[steelplnid]);
   0;
   // use lookup without possibility of insertion side effect
   typedef std::map<PlexPlaneId,UgliPlnNode*>::const_iterator planeTableItr_t;
   planeTableItr_t pt_itr = fPlaneTable.find(steelplnid);
   if ( pt_itr != fPlaneTable.end() )
     the_node = dynamic_cast<UgliSteelPlnNode*>(pt_itr->second);
   if ( ! the_node ) {
     // perhaps the fPlaneTable needs to be refreshed
     RestorePlaneTable(false);
     pt_itr = fPlaneTable.find(steelplnid);
     if ( pt_itr != fPlaneTable.end() )
       the_node = dynamic_cast<UgliSteelPlnNode*>(pt_itr->second);
   }
#endif
   if ( ! the_node ) {
      MSG("Ugli",Msg::kError)
         << "GetSteelPlnNode could not find pre-constructed plane " 
         << steelplnid 
         << " in " << fRootGeom->GetName() << endl;
      the_node = 0; // new UgliSteelPlnNode(this,steelplnid);
   }

   // update cache of this request
   fCachedSteelPlnId   = steelplnid;
   fCachedSteelPlnNode = the_node;

   return the_node;
}

//_____________________________________________________________________________
UgliStripNode* UgliGeometry::GetStripNode(PlexStripEndId seid) const
{
   // get a node for a particular strip

   fRootGeom->cd();
   TNodeX* hallnode = dynamic_cast<TNodeX*>(fRootGeom->GetNode("hall"));
   if (!hallnode) {
      static int nmsg = 5;
      if (nmsg) {
         MSG("Ugli",Msg::kError) 
            << "GetStripNode found no hall node" << endl;
         nmsg--;
         if (nmsg==0) MSG("Ugli",Msg::kError) 
            << "  ... last of these warnings" << endl;
      }
      return 0;
   }
   hallnode->cd();

   PlexStripEndId geom_seid = seid;
   // convert FarDet veto shield id's into one-module-per-plane #'s
   if (geom_seid.GetDetector() == Detector::kFar && 
       geom_seid.IsVetoShield()) {
     VldContext vldc = 
       PlexVetoShieldHack::ConvertRangeToContext(GetVldRange());
     geom_seid = PlexVetoShieldHack::RenumberMuxToMdl(vldc,geom_seid);
   }

   UgliScintPlnNode* the_plane = GetScintPlnNode(geom_seid);
   if (!the_plane) return 0;

   return the_plane->GetStripNode(geom_seid);
}

//_____________________________________________________________________________
const vector<UgliScintPlnNode*>& UgliGeometry::GetScintPlnNodePtrVector() const
{
   // return collection of ptrs for all scint plane nodes in detector

   if (fScintPlnNodes.empty()) {
   
     nodeItr_t node_itr = fPlaneTable.begin();
     nodeItr_t node_end = fPlaneTable.end();
   
     while (node_itr != node_end) {
       nodePair_t map_pair = *node_itr;
       UgliScintPlnNode* scintPlnNode =
         dynamic_cast<UgliScintPlnNode*>(map_pair.second);
       if (scintPlnNode) 
         fScintPlnNodes.push_back(scintPlnNode);
       node_itr++;
     }
   }

   return fScintPlnNodes;
}

//_____________________________________________________________________________
const vector<UgliSteelPlnNode*>& UgliGeometry::GetSteelPlnNodePtrVector() const
{
   // Return collection of ptrs for all steel plane nodes in detector
   // Exclude FarDet Veto Shield pseudo-planes

   if (fNormalSteelNodes.empty()) {

     nodeItr_t node_itr = fPlaneTable.begin();
     nodeItr_t node_end = fPlaneTable.end();
   
     while (node_itr != node_end) {
       nodePair_t map_pair = *node_itr;
       UgliSteelPlnNode* steelPlnNode =
         dynamic_cast<UgliSteelPlnNode*>(map_pair.second);
       if (steelPlnNode && !steelPlnNode->GetPlexPlaneId().IsVetoShield()) 
         fNormalSteelNodes.push_back(steelPlnNode);
       node_itr++;
     }
   }

   return fNormalSteelNodes;
}

//_____________________________________________________________________________
const vector<UgliPlnNode*>& UgliGeometry::GetPlnNodePtrVector() const
{
   // return collection of ptrs for all plane nodes in detector

   if (fAllPlnNodes.empty()) {
   
     nodeItr_t node_itr = fPlaneTable.begin();
     nodeItr_t node_end = fPlaneTable.end();
   
     while (node_itr != node_end) {
       nodePair_t map_pair = *node_itr;
       UgliPlnNode* plnNode = map_pair.second;
       if (plnNode) fAllPlnNodes.push_back(plnNode);
       node_itr++;
     }
   }

   return fAllPlnNodes;
}

//_____________________________________________________________________________
void UgliGeometry::Draw(Option_t * /* option */)
{
   // draw this geometry

   MSG("Ugli",Msg::kInfo) << "UgliGeometry::Draw()" << endl;

   // placment, size (in pixels)
   TCanvas *uglicanvas = new TCanvas("ugli","ugli",200,10,700,700);
   // xymin, xymax, color, bordersize, bordermode
   TPad *uglipad = new TPad("ugli","ugli",0.02,0.02,0.98,0.98,0);
   uglipad->Draw();
   uglipad->cd();

   // create a view to assocate with the pad
#if ROOT_VERSION_CODE >= ROOT_VERSION(5,15,3)
   TView *ugliview = new TView3D(1,0,0);
#else
   TView *ugliview = new TView(1);
#endif
   //              front   top  side  weird
   Float_t phi   =  90; // 90   180     60
   Float_t theta = 180; // 90    90    150
   Float_t psi   =   0; // 90    90    170

   ugliview->SetLongitude(phi);
   ugliview->SetLatitude(theta);
   ugliview->SetPsi(psi);

   Float_t zmin, zmax;
   Float_t t[4];

   GetZExtent(zmin,zmax);
   GetTransverseExtent(PlaneView::kU,t[0],t[1]);
   GetTransverseExtent(PlaneView::kV,t[2],t[3]);

   for (Int_t i=0; i<4; i++) t[i] = TMath::Abs(t[i]);
   Int_t   imax = TMath::LocMax(4,t);

   // sqrt(2) to account for possible UV rotation space
   Float_t tsize = TMath::Sqrt(2.) * t[imax];

   Float_t x0 = 0;
   Float_t y0 = 0;
   Float_t z0 = 0.5*(zmin+zmax);

   Float_t dz  = 0.5*(zmax-zmin);
   ugliview->SetRange(x0-tsize,y0-tsize,z0-dz,x0+tsize,y0+tsize,z0+dz);

   // Display UgliGeometry
   fRootGeom->Draw("same");

   uglicanvas->Update();
}

//_____________________________________________________________________________
void UgliGeometry::Print(Option_t * /* option */) const
{
   // print something about this geometry (name + ref counts + vldrange)

   MSG("Ugli",Msg::kInfo)
     << "  " << TObject::GetName() 
     << " has " << CountRef() << " references " << endl
     << "    " << fVldRange.AsString("a") << endl;
   MSG("Ugli",Msg::kInfo)
     << "    fRootGeom \"" << fRootGeom->GetName() << "\"" << endl;
}

//_____________________________________________________________________________
void UgliGeometry::ls(Option_t *option) const
{
   // list components of this geometry

   fRootGeom->ls(option);
}

//_____________________________________________________________________________
void UgliGeometry::SetFrozen(Bool_t frozen) 
{
  // setting frozen/modifiable must modify fRootGeom's name as well
  // to keep it unique
  fFrozen = frozen;
  if (fRootGeom) {
     TString name = (frozen?"Frozen":"Modifiable");
     name += fVldRange.AsString("s1ac-");
     fRootGeom->SetName(name.Data());
  }
}

//_____________________________________________________________________________
void UgliGeometry::BuildAll(const VldContext &vldc)
{
   // Build things

   // Get the VldRange that fits this VldContext

   BuildVldRange(vldc);

   TString name = (IsFrozen()?"Frozen":"Modifiable");
   name += fVldRange.AsString("s1ac-");
   fRootGeom = new TGeometryX(name.Data(),"a MINOS geometry");
   fRootGeom->cd();

   if (vldc.GetDetector() == Detector::kUnknown) {
      MSG("Ugli",Msg::kWarning)
         << "no possibility of building a geometry for " << endl
         << "   VldContext: " << vldc << endl;
      return;
   }

   // Build Materials

   BuildMaterials(vldc);

   // Build RotMatrices

   BuildRotMatrices(vldc);

   // Build Shapes

   BuildShapes(vldc);

   // Build Nodes

   BuildNodes(vldc);

   // Clear DBI cache

   ClearDbiCache(vldc);
}
   
//_____________________________________________________________________________
void UgliGeometry::GetTransverseExtent(PlaneView::PlaneView_t view,
                                       Float_t& tmin, Float_t& tmax) const
{
  // Return extent based on detector type and view

  Double_t tmind, tmaxd;
  GetTransverseExtent(view,tmind,tmaxd);
  tmin = (Float_t)tmind;
  tmax = (Float_t)tmaxd;
}

//_____________________________________________________________________________
void UgliGeometry::GetTransverseExtent(PlaneView::PlaneView_t view,
                                       Double_t& tmin, Double_t& tmax) const
{
  // Return extent based on detector type and view
  // *** bad form *** currently simple hard coded values!!

   // the VldRange describing this geometry should only have on bit set
   Detector::Detector_t detector = 
      (Detector::Detector_t) fVldRange.GetDetectorMask();

   switch (detector) {
   case Detector::kNear:
      switch (view) {
      case PlaneView::kU:
         tmin = -210. * Munits::cm;
         tmax = +275. * Munits::cm;      
         break;
      case PlaneView::kV:
         tmin = -275. * Munits::cm;
         tmax = +210. * Munits::cm;      
         break;
      default:
      MSG("Ugli",Msg::kError)
         << "UgliGeometry::GetTransverseExtent undefined for "
         << Detector::AsString(detector) << " view " 
         << PlaneView::AsString(view) << endl;
      break;
      }
   case Detector::kFar:
      tmin = -400. * Munits::cm;
      tmax = +400. * Munits::cm;
      break;
   case Detector::kCalib:
      tmin = -50. * Munits::cm;
      tmax = +50. * Munits::cm;
      break;
   default:
      MSG("Ugli",Msg::kError)
         << "UgliGeometry::GetTransverseExtent undefined for "
         << Detector::AsString(detector) << endl;
      break;
   }

#ifdef OLDFUZZ
   Float_t fuzz_abs  = 10. * Munits::cm;
   Float_t fuzz_frac = 0.025;
#else
   Float_t fuzz_abs  = 0.5 * 4.1 * Munits::cm;
   Float_t fuzz_frac = 0.0;
#endif
   Float_t extra_per_side = 0.5*(tmax-tmin)*fuzz_frac;

   tmin = tmin - fuzz_abs - extra_per_side;
   tmax = tmax + fuzz_abs + extra_per_side;


}

//_____________________________________________________________________________
void UgliGeometry::GetZExtent(Float_t& zmin, Float_t& zmax, Int_t isuper) const
{
  // Return z extent
  // if isuper == -1 for whole detector
  // otherwise by supermodule (not yet supported)

  Double_t zmind, zmaxd;
  GetZExtent(zmind,zmaxd,isuper);
  zmin = (Float_t)zmind;
  zmax = (Float_t)zmaxd;
}

//_____________________________________________________________________________
void UgliGeometry::GetZExtent(Double_t& zmin, Double_t& zmax, Int_t isuper) const
{
  // Return z extent
  // if isuper == -1 for whole detector
  // otherwise by supermodule (not yet supported)

  // the VldRange describing this geometry should only have on bit set
  Detector::Detector_t det = 
    (Detector::Detector_t) fVldRange.GetDetectorMask();

  // protect against case where DBI built no planes
  RestorePlaneTable(true);
  if ( fPlaneTable.empty() ) {
    MSG("Ugli",Msg::kWarning)
      << "GetZExtent() No planes found." << endl
      << "   Perhaps this geometry was built with a bad VldContext" << endl
      << "   or the database lacked an appropriate table" << endl
      << fVldRange.AsString()
      << endl;
    
    Float_t spacing = 5.94*Munits::cm;
    
    switch (det) {
    case Detector::kNear:
      zmin =       -5.0*spacing;
      zmax = (float)282*spacing +  20.*Munits::cm + 5.0*spacing;
      break;
    case Detector::kCalDet:
      zmin =       -5.0*spacing;
      zmax =  (float)60*spacing +  20.*Munits::cm + 5.0*spacing;
      break;
    case Detector::kFar:
      zmin =       -5.0*spacing;
      zmax = (float)484*spacing + 125.*Munits::cm + 5.0*spacing;
      break;
    default:
      zmin = -5.0*spacing;
      zmax = 60*Munits::m;
      break;
    }
    // no real info ... return a guess
    return;
  }

  // Assumes that fPlaneTable is generally in z order
  // with the exception of CalDet cosmics and FarDet veto shield modules
  
  UgliPlnNode* upln_beg = fPlaneTable.begin()->second; // easy

  UgliPlnNode* upln_end = 0;
  // last "reasonable" plane needs to discount CalDet floor planes
  // and FarDet veto planes.  Work from the highest plane # down
  // until we get a reasonable view.
  nodeRevItr_t node_ritr = fPlaneTable.rbegin();
  nodeRevItr_t node_rend = fPlaneTable.rend();
  for ( ; node_ritr != node_rend ; ++node_ritr ) {
    upln_end          = node_ritr->second;
    PlexPlaneId plnid = upln_end->GetPlexPlaneId();
    PlaneView::PlaneView_t view = plnid.GetPlaneView();
    // continue looking if this plane has a kA or kB view (CalDet)
    // or stop if it finds a kU or kV view (esp. for Far w/ VetoShield)
    if (det == Detector::kCalDet){
      if (view != PlaneView::kA && view != PlaneView::kB) break;
    }
    else {
      if (view == PlaneView::kU || view == PlaneView::kV) break;
    }
  }

  if ( -1 != isuper ) {
    if ( Detector::kFar != det ) {
      MSG("Ugli",Msg::kError)
        << "UgliGeometry::GetZExtent does not support supermodules "
        << "other than -1 for " << Detector::AsString(det)
        << endl << "   return value for whole detector" << endl;
    }
    else {
      // look for intermediate uninstrumented plane
      // assumes only 2 super modules in far detector

      UgliPlnNode* upln_mid0 = upln_beg;  // just before uninstrumented
      UgliPlnNode* upln_mid1 = upln_beg;  // uninstrumented plane

      nodeItr_t node_itr = fPlaneTable.begin();
      nodeItr_t node_end = fPlaneTable.end();

      node_itr++; // move beyond first plane
      
      for ( ; node_itr != node_end ; node_itr++ ) {
        upln_mid0 = upln_mid1;
        upln_mid1 = node_itr->second;
        if (upln_mid1 == upln_end) {
          MSG("Ugli",Msg::kWarning)
            << "GetZExtent found no SM break for this geometry "
            << fVldRange << endl;
          upln_mid0 = upln_end;
          break; // reached the end, there isn't one
        }
        PlexPlaneId plnid = upln_mid1->GetPlexPlaneId();
        PlaneCoverage::PlaneCoverage_t cover = plnid.GetPlaneCoverage();
        if (cover == PlaneCoverage::kNoActive) break;
      }
      switch (isuper) {
      case 0:
        MSG("Ugli",Msg::kDebug)
          << " SM 0 upln_end set to upln_mid0" << endl;
        upln_end = upln_mid0;  // last before uninstrumented plane
        break;
      case 1:
        MSG("Ugli",Msg::kDebug)
          << " SM 1 upln_beg set to upln_mid1" << endl;
        upln_beg = upln_mid1;  // leading steel plane
        break;
      default:
        MSG("Ugli",Msg::kError)
          << "GetZExtent" << endl << " FarDet only has SM 0 and 1"
          << ", return value for whole detector." << endl;
      }

    } // FarDet
  } // specific SM

  zmin = upln_beg->GetZ0() - upln_beg->GetHalfThickness();
  MSG("Ugli",Msg::kDebug)
    << "GetZExtent first was " << upln_beg->GetPlexPlaneId() 
    << " Z0 " << upln_beg->GetZ0() << " - dz " << upln_beg->GetHalfThickness()
    << endl;

  zmax = upln_end->GetZ0() + upln_end->GetHalfThickness();
  MSG("Ugli",Msg::kDebug)
    << "GetZExtent last  was " << upln_end->GetPlexPlaneId() 
    << " Z0 " << upln_end->GetZ0() << " + dz " << upln_end->GetHalfThickness()
    << endl;

#ifdef OLDFUZZ
   Float_t fuzz_abs  = 10. * Munits::cm;
   Float_t fuzz_frac = 0.025;
   Float_t extra_per_side = 0.5*(zmax-zmin)*fuzz_frac;

   zmin = zmin - fuzz_abs - extra_per_side;
   zmax = zmax + fuzz_abs + extra_per_side;
#endif

}

//_____________________________________________________________________________
TVector3 UgliGeometry::GetHallExtentMin() const
{
  // return the min {x,y,z} of the detector hall

  TNodeX* hallnode  = dynamic_cast<TNodeX*>(fRootGeom->GetNode("hall"));
  TShape* hallshape = hallnode->GetShape();
  TBRIK*  hallbrik  = dynamic_cast<TBRIK*>(hallshape);
  if (!hallbrik) {
    MSG("Ugli",Msg::kInfo)
      << "UgliGeometry::GetHallExtentMin() hall is not a BRIK " << endl;
    return TVector3(-9999.,-9999.,-9999.);
  }
  TVector3 xyz0(hallnode->GetX(), hallnode->GetY(), hallnode->GetZ());
  TVector3 dxyz(hallbrik->GetDx(),hallbrik->GetDy(),hallbrik->GetDz());
  TVector3 result = xyz0 - dxyz;
  return result;

}

//_____________________________________________________________________________
TVector3 UgliGeometry::GetHallExtentMax() const
{
  // return the min {x,y,z} of the detector hall

  TNodeX* hallnode  = dynamic_cast<TNodeX*>(fRootGeom->GetNode("hall"));
  TShape* hallshape = hallnode->GetShape();
  TBRIK*  hallbrik  = dynamic_cast<TBRIK*>(hallshape);
  if (!hallbrik) {
    MSG("Ugli",Msg::kInfo)
      << "UgliGeometry::GetHallExtentMax() hall is not a BRIK " << endl;
    return TVector3(+9999.,+9999.,+9999.);
  }
  TVector3 xyz0(hallnode->GetX(), hallnode->GetY(), hallnode->GetZ());
  TVector3 dxyz(hallbrik->GetDx(),hallbrik->GetDy(),hallbrik->GetDz());
  TVector3 result = xyz0 + dxyz;
  return result;
}

//_____________________________________________________________________________
void UgliGeometry::BuildVldRange(const VldContext &vldc)
{
   // Build VldRange from VldContext

   MSG("Ugli",Msg::kDebug) << "UgliGeometry::BuildVldRange " << endl;

   Detector::Detector_t det = vldc.GetDetector();
   bool isunknown = (Detector::kUnknown == det);
   const char* src = "DBI";
   if (isunknown) src = "Fake (unknown detector)";

   // start the VldRange of covering all of time and then trim it down
   // each time we use a DBI table to compose some part
   VldTimeStamp starttime = VldTimeStamp((time_t)0,0);
   VldTimeStamp endtime   = VldTimeStamp(2038,1,18,0,0,0);
   fVldRange = VldRange(vldc.GetDetector(),vldc.GetSimFlag(),
                        starttime,endtime,src);

   // special return for unknown detector
   if (isunknown) return;

   if (fAlgorithmic) {
     MSG("Ugli",Msg::kInfo) 
       << "UgliGeometry::VldRange: Algorithmic! valid until "
       << endtime
       << endl;
     return;
   }

   // trim based on all the tables we'll use
   // this also primes the cache for all of them


   MSG("Ugli",Msg::kInfo) << "UgliGeometry::VldRange: UgliDbiSteelPln" 
                          << "                 \r" << flush;
   DbiResultPtr<UgliDbiSteelPln> steelTbl(vldc);
   TrimVldRange("UgliDbiSteelPln",steelTbl.GetValidityRec());

   MSG("Ugli",Msg::kInfo) << "UgliGeometry::VldRange: UgliDbiScintPlnStruct" 
                          << "                 \r" << flush;
   DbiResultPtr<UgliDbiScintPlnStruct> scintStructTbl(vldc);
   TrimVldRange("UgliDbiScintPlnStruct",scintStructTbl.GetValidityRec());

   MSG("Ugli",Msg::kInfo) << "UgliGeometry::VldRange: UgliDbiScintPln" 
                          << "                 \r" << flush;
   DbiResultPtr<UgliDbiScintPln> scintTbl(vldc);
   TrimVldRange("UgliDbiScintPln",scintTbl.GetValidityRec());

   MSG("Ugli",Msg::kInfo) << "UgliGeometry::VldRange: UgliDbiScintMdlStruct" 
                          << "                 \r" << flush;
   DbiResultPtr<UgliDbiScintMdlStruct> mdlStructTbl(vldc);
   TrimVldRange("UgliDbiScintMdlStruct",mdlStructTbl.GetValidityRec());

   MSG("Ugli",Msg::kInfo) << "UgliGeometry::VldRange: UgliDbiScintMdl" 
                          << "                 \r" << flush;
   DbiResultPtr<UgliDbiScintMdl> mdlTbl(vldc);
   TrimVldRange("UgliDbiScintMdl",mdlTbl.GetValidityRec());

   MSG("Ugli",Msg::kInfo) << "UgliGeometry::VldRange: UgliDbiStripStruct" 
                          << "                 \r" << flush;
   DbiResultPtr<UgliDbiStripStruct> stripStructTbl(vldc);
   TrimVldRange("UgliDbiStripStruct",stripStructTbl.GetValidityRec());

   MSG("Ugli",Msg::kInfo) << "UgliGeometry::VldRange: UgliDbiStrip" 
                          << "                 \r" << flush;
   DbiResultPtr<UgliDbiStrip> stripTbl(vldc);
   TrimVldRange("UgliDbiStrip",stripTbl.GetValidityRec());

   MSG("Ugli",Msg::kInfo) << "UgliGeometry::VldRange: done         " << endl;


}

//_____________________________________________________________________________
void UgliGeometry::ClearDbiCache(const VldContext &vldc)
{
   // Clear DBI cache of elements

   MSG("Ugli",Msg::kDebug) << "UgliGeometry::ClearDbiCache " << endl;

   // nothing to purge if we were algorithmic
   if (fAlgorithmic) return;

   // have we been configured not to do the purge?
   if ( ! UgliLoanPool::Instance()->PurgeDbiTableCache() ) return;

   // purge the cache on the tables we've used

   DbiCache* steelTblCache = 0;
   DbiCache* scintStructTblCache = 0;
   DbiCache* scintTblCache = 0;
   DbiCache* mdlStructTblCache = 0;
   DbiCache* mdlTblCache = 0;
   DbiCache* stripStructTblCache = 0;
   DbiCache* stripTblCache = 0;

   { 
      //
      // start of inner scope so that DbiResultPtr's will die, die, die
      // and thus Purge will see no remaining clients
      //
      

      MSG("Ugli",Msg::kDebug) << "UgliGeometry::GetCache: UgliDbiSteelPln" 
                              << "                 \r" << flush;
      DbiResultPtr<UgliDbiSteelPln> steelTbl(vldc);
      steelTblCache = steelTbl.TableProxy().GetCache();

      MSG("Ugli",Msg::kDebug) << "UgliGeometry::GetCache: UgliDbiScintPlnStruct" 
                              << "                 \r" << flush;
      DbiResultPtr<UgliDbiScintPlnStruct> scintStructTbl(vldc);
      scintStructTblCache = scintStructTbl.TableProxy().GetCache();

      MSG("Ugli",Msg::kDebug) << "UgliGeometry::GetCache: UgliDbiScintPln" 
                              << "                 \r" << flush;
      DbiResultPtr<UgliDbiScintPln> scintTbl(vldc);
      scintTblCache = scintTbl.TableProxy().GetCache();

      MSG("Ugli",Msg::kDebug) << "UgliGeometry::GetCache: UgliDbiScintMdlStruct" 
                              << "                 \r" << flush;
      DbiResultPtr<UgliDbiScintMdlStruct> mdlStructTbl(vldc);
      mdlStructTblCache = mdlStructTbl.TableProxy().GetCache();

      MSG("Ugli",Msg::kDebug) << "UgliGeometry::GetCache: UgliDbiScintMdl" 
                              << "                 \r" << flush;
      DbiResultPtr<UgliDbiScintMdl> mdlTbl(vldc);
      mdlTblCache = mdlTbl.TableProxy().GetCache();

      MSG("Ugli",Msg::kDebug) << "UgliGeometry::GetCache: UgliDbiStripStruct" 
                              << "                 \r" << flush;
      DbiResultPtr<UgliDbiStripStruct> stripStructTbl(vldc);
      stripStructTblCache = stripStructTbl.TableProxy().GetCache();


      MSG("Ugli",Msg::kDebug) << "UgliGeometry::GetCache: UgliDbiStrip" 
                              << "                 \r" << flush;
      DbiResultPtr<UgliDbiStrip> stripTbl(vldc);
      stripTblCache = stripTbl.TableProxy().GetCache();

      MSG("Ugli",Msg::kDebug) << "UgliGeometry::GetCache: done         " << endl;
   }

   // now there should be no active clients we can now purge 
   // to our heart's content

   MSG("Ugli",Msg::kDebug) << "UgliGeometry::PurgeCache: UgliDbiSteelPln" 
                           << "                 \r" << flush;
   if (steelTblCache) steelTblCache->Purge();

   MSG("Ugli",Msg::kDebug) << "UgliGeometry::PurgeCache: UgliDbiScintPlnStruct" 
                           << "                 \r" << flush;
   if (scintStructTblCache) scintStructTblCache->Purge();

   MSG("Ugli",Msg::kDebug) << "UgliGeometry::PurgeCache: UgliDbiScintPln" 
                           << "                 \r" << flush;
   if (scintTblCache) scintTblCache->Purge();

   MSG("Ugli",Msg::kDebug) << "UgliGeometry::PurgeCache: UgliDbiScintMdlStruct" 
                           << "                 \r" << flush;
   if (mdlStructTblCache) mdlStructTblCache->Purge();

   MSG("Ugli",Msg::kDebug) << "UgliGeometry::PurgeCache: UgliDbiScintMdl" 
                           << "                 \r" << flush;
   if (mdlTblCache) mdlTblCache->Purge();

   MSG("Ugli",Msg::kDebug) << "UgliGeometry::PurgeCache: UgliDbiStripStruct" 
                           << "                 \r" << flush;
   if (stripStructTblCache) stripStructTblCache->Purge();


   MSG("Ugli",Msg::kDebug) << "UgliGeometry::PurgeCache: UgliDbiStrip" 
                           << "                 \r" << flush;
   if (stripTblCache) stripTblCache->Purge();

   MSG("Ugli",Msg::kDebug) << "UgliGeometry::PurgeCache: done         " << endl;
   

}

//_____________________________________________________________________________
void UgliGeometry::RestorePlaneTable(bool onlyIfEmpty) const
{
  // Restore map of PlexPlaneId's to UgliPlnNode*'s
  // The contents of this might have been lost during persistency
  // (as of 2003-04-30 it couldn't correctly be written out)
  // If "onlyIfEmpty" do it only if the map is empty.

  if ( onlyIfEmpty && ! fPlaneTable.empty() ) return; // nothing to do

  MSG("Ugli",Msg::kDebug) << "UgliGeometry::RestorePlaneTable " << endl;

  fRootGeom->cd();
  TNodeX* hallnode = dynamic_cast<TNodeX*>(fRootGeom->GetNode("hall"));

  // loop over the nodes in the hall ... these should be planes
  TIter nodeInHallItr(hallnode->GetListOfNodes());
  TNode* nodeInHall = 0;
  while ( ( nodeInHall = dynamic_cast<TNode*>(nodeInHallItr()) ) ) {
    // these are markers and boxes containing scint+steel planes
    MSG("Ugli",Msg::kVerbose) 
      << " found " << nodeInHall->GetName() << " in hall " << endl;
    TIter nodeInBoxItr(nodeInHall->GetListOfNodes());
    TObject* nodeInBox = 0;
    while ( ( nodeInBox = nodeInBoxItr() ) ) {
      // these should be the actual planes
      MSG("Ugli",Msg::kVerbose) 
        << " found " << nodeInBox->GetName() 
        << " in " << nodeInHall->GetName()<< endl;
      UgliPlnNode* upn = dynamic_cast<UgliPlnNode*>(nodeInBox);
      if (upn) {
        fPlaneTable[upn->GetPlexPlaneId()] = upn;
        MSG("Ugli",Msg::kDebug) 
          << "UgliGeometry::RestorePlaneTable add " 
          << upn->GetPlexPlaneId() << endl;
      }
    }
  }
  

}

//_____________________________________________________________________________
void UgliGeometry::BuildMaterials(const VldContext& /* vldc */)
{
   // build this geometry's materialss

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

//   TMaterial *mat;
   TMixture  *mix;

   // there doesn't seem to be any way to set the density (1.032)
   mix = new TMixture("scint","polystyrene C6H5CH-CH2",-2);
   mix->DefineElement(0,1.00794,1.,8.);
   mix->DefineElement(1,12.011,6.,8.);

   // loop over SteelPn, fill out material for different melts ??
   mix = new TMixture("steel","generic steel",2);
   mix->DefineElement(0,55.84999,26,.98);
   mix->DefineElement(1,12.01,6,.02);


}

//_____________________________________________________________________________
void UgliGeometry::BuildRotMatrices(const VldContext& /* vldc */)
{
   // build some basic rotation matrices

   // absolute first should be Identity
   new TRotMatrix("Identity","Identity matrix",90,0,90,90,0,0);

   new TRotMatrix("XY","WorldAsXY", 90.,  0., 90., 90.,  0.,  0.);
   new TRotMatrix("UV","WorldAsUV", 90.,-45., 90., 45.,  0.,  0.);

}

//_____________________________________________________________________________
void UgliGeometry::BuildShapes(const VldContext& /* vldc */)
{
   // build some basic shapes (not planes or strips)

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

   // this shape is a placeholder used in constructing
   // planes or strips within a TNode derived object
   // without passing it a the final shape
   // make it really noticable in case there was a mistake
   // new TBRIK("noshape","noshape","void",0,0,0);
   Float_t nsx[] = {   3,   3, 1.5,-1.5,  -3,  -3,-1.5, -.5,   0,   0,
                     .49, .49,   0,   0,   1,   1, .51, .51,   1,   1,
                     .5,   -1,  -2,  -2,  -1,   1,   2,   2};
   Float_t nsy[] = {   0, 1.5,   3,   3, 1.5,-1.5,  -3,  -3,-3.5,  -5,
                      -5,  -6,  -6,  -7,  -7,  -6,  -6,  -5,  -5,  -3,
                      -2,  -2,  -1,   1,   2,   2,   1,   0};
   TXTRU *noshape = new TXTRU("noshape","noshape","void",28,2);
   Float_t dz = 5.94 * Munits::cm;
   noshape->DefineSection(0,-dz,1.,0.,0.);
   noshape->DefineSection(1,+dz,1.,0.,0.);
   for (unsigned int i=0; i < sizeof(nsx)/sizeof(Float_t); i++) 
      noshape->DefineVertex(i,nsx[i]*Munits::m,nsy[i]*Munits::m);
   noshape->SetLineColor(kRed); noshape->SetLineWidth(1);

}

//_____________________________________________________________________________
void UgliGeometry::BuildNodes(const VldContext& vldc)
{
   // build this geometry's hierarchy of nodes

   MSG("Ugli",Msg::kDebug) << "UgliGeometry::BuildNodes UgliDbiTables" << endl;
   const UgliDbiTables& ugliTables = 
     ((fAlgorithmic) ? UgliDbiTables(vldc,false) : UgliDbiTables(vldc));

   fRootGeom->cd();
   // Start building from the DBI info

   TShape *pshape = 0;
   TNodeX *pnode  = 0;

   bool        world_is_uv = true;
   const char* world_rotm  = "UV";

   bool force_xy = true;

   if (vldc.GetDetector() == Detector::kCalDet) {
      world_is_uv = false;
      world_rotm  = "XY";
   }
   else if (force_xy) {
      MSG("Ugli",Msg::kDebug)
         << vldc.AsString("c") << " should use Hall oriented in UV space"
         << " ... but we won't for now" << endl;
      world_is_uv = false;
      world_rotm  = "XY";
   }

   MSG("Ugli",Msg::kDebug) << "Build the hall" << endl;
   // First we need a hall
   const UgliDbiGeometry* geo = ugliTables.GetDbiGeometry();
   if (!geo) {
     MSG("Ugli",Msg::kFatal) 
       << "No UgliDbiGeometry for " << vldc << endl;
     return;
   }

   const Float_t* hmin = geo->GetHallXYZMin();
   const Float_t* hmax = geo->GetHallXYZMax();
// just a test folks
//      Float_t hmin[] = {-5,-5,0};
//      Float_t hmax[] = {15,15,60};

   Float_t absxmax  = TMath::Max(TMath::Abs(hmax[0]),TMath::Abs(hmin[0]));
   Float_t absymax  = TMath::Max(TMath::Abs(hmax[1]),TMath::Abs(hmin[1]));
   Float_t abszmax  = TMath::Max(TMath::Abs(hmax[2]),TMath::Abs(hmin[2]));
   Float_t absxymax = TMath::Max(absxmax,absymax);
   Float_t sqrt2 = TMath::Sqrt(2.0);
   if (world_is_uv) absxymax *= sqrt2;

   // define the fixed frame of the (local) universe
   pshape = new TBRIK("universe","all the ever is","void",
                      absxymax,absxymax,abszmax);
   pnode  = new TNodeX("universe","fixed center of all",
                       "universe",0,0,0,"Identity");
   pnode->SetVisibility(0); // nothing to see here folks
   pnode->SetVisibility(1);      // okay for now peek a little
   pnode->SetLineColor(kYellow); // but unobtrusively
   pnode->cd();

   // the world might rotate in the universe (uv or xy)
   pshape = new TBRIK("world","the shape of the world","void",
                      absxymax,absxymax,abszmax);
   pnode  = new TNodeX("world","it depends how we look at it",
                       "world",0,0,0,world_rotm);
   pnode->SetVisibility(1);     // see the world
   pnode->SetLineColor(kBlack); // it's gone black!
   pnode->cd();
   
   // shapes use half-sizes 
   Double_t xhsiz  = 0.5 * (hmax[0] - hmin[0]);
   Double_t yhsiz  = 0.5 * (hmax[1] - hmin[1]);
   Double_t zhsiz  = 0.5 * (hmax[2] - hmin[2]);
   
   Double_t x0hall = 0.5 * (hmax[0] + hmin[0]);
   Double_t y0hall = 0.5 * (hmax[1] + hmin[1]);
   Double_t z0hall = 0.5 * (hmax[2] + hmin[2]);
   
   pshape = new TBRIK("hall","The Hall","void",
                      xhsiz,yhsiz,zhsiz);
   TNodeX *hall_node = new TNodeX("hall","The Hall","hall",
                                  x0hall,y0hall,z0hall);
   hall_node->cd();
   hall_node->SetVisibility(1);   // see the hall
   hall_node->SetLineColor(kRed); // it's red!
   
   
   // put some markers in the hall identifying +x, +y, +z
   Float_t rmkr = 20.*Munits::cm;
   if (vldc.GetDetector() == Detector::kCalDet) rmkr = 1.*Munits::cm;
   pshape = new TSPHE("axismkr","axismkr","void",rmkr);
   pnode  = new TNodeX("+x","+x","axismkr",
                       xhsiz-x0hall-rmkr,-y0hall,-zhsiz+rmkr);
   pnode->SetLineColor(kRed);
   pnode->SetVisibility(1);
   pnode  = new TNodeX("+y","+y","axismkr",
                       -x0hall,yhsiz-y0hall-rmkr,-zhsiz+rmkr);
   pnode->SetLineColor(kGreen);
   pnode->SetVisibility(1);
   pnode  = new TNodeX("+z","+z","axismkr",
                       -x0hall,-y0hall,+zhsiz-rmkr);
   pnode->SetLineColor(kBlue);
   pnode->SetVisibility(1);
   MSG("Ugli",Msg::kDebug) << "The Hall has been installed" << endl;
   
   // pre-build the palette of strip shapes
   BuildStripShapes(vldc);

   //
   // determine whether (and what) to cut on the basis of FabPlnInstall
   //
   Msg::LogLevel_t cutMsgLevel = Msg::kSynopsis;
   VldTimeStamp geomStartTime = vldc.GetTimeStamp();
   bool cutOnPlnInstall = UgliDbiTables::IsCutOnPlnInstall(vldc.GetDetector());

   VldContext vldc_install = vldc;
   Registry& config = UgliLoanPool::Instance()->GetConfig();
   int cutAppliesToVetoShield = false;
   if (vldc.GetDetector() == Detector::kFar)
     config.Get("CutAppliesToVetoShield",cutAppliesToVetoShield);
   if ( cutOnPlnInstall && vldc.GetSimFlag() != SimFlag::kData ) {
     int applyToMC = 0;
     config.Get("CutAppliesToMC",applyToMC);
     switch ( applyToMC ) {
     case 1:  
       cutOnPlnInstall = true;  // okay, use VldContext of MC
       break;  
     case 2:  
       cutOnPlnInstall = true;  // okay, but use Data VldContext
       vldc_install = 
         VldContext(vldc.GetDetector(),SimFlag::kData,vldc.GetTimeStamp());
       MSG("Ugli",Msg::kInfo) 
         << "UgliGeometry::BuildNodes use kData instead of k" 
         << SimFlag::AsString(vldc.GetSimFlag())
         << " for FabPlnInstall." << endl;
       break;
     default: 
       cutOnPlnInstall = false; // nope, don't apply cut to MC
       break;  
     }
   }

   TString fabCutAction = "not to cut on ";
   if (cutOnPlnInstall) {
     fabCutAction = "to cut on ";
     if (vldc.GetDetector() == Detector::kFar) {
       if (cutAppliesToVetoShield) fabCutAction += "all ";
       else                        fabCutAction += "non-VetoShield ";
     }
   }
   MSG("Ugli",Msg::kInfo) 
     << "UgliGeometry configured " << fabCutAction 
     << "FabPlnInstall entries." << endl;

   FabPlnInstallLookup installInfo(vldc_install);
   if ( cutOnPlnInstall ) {
     const char* level = "Synopsis";
     config.Get("CutMsgLevel",level);
     cutMsgLevel = Msg::GetLevelCode(level);

     // if planes went up after this time then we need to trim
     // the VldRange end time (ignore veto shield)
     const FabPlnInstall* fab = installInfo.NextInstall(geomStartTime,true);
     if (fab) {
       const VldTimeStamp  time_end  = fVldRange.GetTimeEnd();
       const VldTimeStamp& time_next = fab->GetInstallDate();
       MSG("Ugli",cutMsgLevel) 
           << "UgliGeometry VldRange was "
           << time_end.AsString("sql") << " PlnInstall::NextInstall gives "
           << time_next.AsString("sql") << "." << endl;
       if ( time_next < time_end ) {
         MSG("Ugli",cutMsgLevel) 
           << "UgliGeometry VldRange TimeEnd trimmed from "
           << time_end.AsString("sql") << " to "
           << time_next.AsString("sql") << "." << endl;
         fVldRange.SetTimeEnd(time_next);
       }
     }
     else {
       MSG("Ugli",Msg::kInfo) 
         << "UgliGeometry:  No VldRange trimming as no PlnInstall::NextInstall." 
         << endl;
     }
   }

   // 
   // process steel + scint planes
   // 
   unsigned int nsteel = ugliTables.GetNumSteelRows();
   for (unsigned int irow=0; irow < nsteel; ++irow) {
     
     const UgliDbiSteelPln* steelRow = ugliTables.GetDbiSteelPln(irow);

     PlexPlaneId steelid = steelRow->GetPlaneId();

     //
     // check if row should be supressed due to FabPlnInstall entry
     //
     bool checkit = true;
     if (steelid.IsVetoShield() && !cutAppliesToVetoShield) checkit = false;
     if (cutOnPlnInstall && checkit) {
       // asked to test installation of planes based on FabPlnInstall table
       // so test ...
       const FabPlnInstall* fab =
         installInfo.fPlnInstallTbl.GetRowByIndex(steelid.GetPlane());
       if ( fab ) {
         if ( fab->GetInstallDate() > geomStartTime ) {
           MSG("Ugli",cutMsgLevel)
             << endl
             << "UgliDbiTables has entry for " << steelid
             << " but FabPlnInstall says " 
             << fab->GetInstallDate().AsString("sql")
             << endl;
           continue;  // skip installation of this steel plane
         }
       }
       else {
         MSG("Ugli",cutMsgLevel)
           << endl
           << "UgliDbiTables has entry for " << steelid
           << " but no entry in FabPlnInstall " 
           << endl;
         continue;  // skip installation of this steel plane
       }
         
     }
     
     //         int pln = steelid.GetPlane();
     int vis = 1;
     //         vis = -1;         
     //         if (pln== 1 || pln== 6) vis = 1;
     //         if (pln==13 || pln==20) vis = 1;
     //         if (pln>59) vis = 1;
     
     MSG("Ugli",Msg::kDebug) << " build " << steelid.AsString("c") 
                             << "\r" << flush;
          
     hall_node->cd();
     UgliSteelPlnNode* steel = 
       new UgliSteelPlnNode(steelid,this,ugliTables);
     fPlaneTable[steelid] = steel;
     
     //rwh: hack
     //         char boxname[16];
     //         sprintf(boxname,"%s",steelid.AsString("b"));  // dNNNBvc
     //         this->GetNode(boxname)->SetVisibility(vis);
     //         boxname[4] = 'P';
     //         this->GetNode(boxname)->SetVisibility(vis);
     steel->SetVisibility(vis);
     TNode* box_from_steel = steel->GetParent();
     box_from_steel->SetVisibility(vis);
     
     if (PlaneCoverage::kNoActive == steelid.GetPlaneCoverage()) continue;
     if (PlaneCoverage::kUnknown  == steelid.GetPlaneCoverage()) continue;
     
     PlexPlaneId scintid = steelid;
     scintid.SetIsSteel(false);
     
     MSG("Ugli",Msg::kSynopsis) << " build " << scintid.AsString("c") 
                            << "\r" << flush;

     box_from_steel->cd();
     UgliScintPlnNode* scint =
       new UgliScintPlnNode(scintid,this,ugliTables);
     fPlaneTable[scintid] = scint;
     
     //rwh: hack
     //         boxname[4] = 'A';
     //         this->GetNode(boxname)->SetVisibility(vis);
     scint->SetVisibility(vis);
     
   }
   hall_node->cd();
   
   MSG("Ugli",Msg::kSynopsis) << endl << " build  done" << endl;

   //
   // summarize what we just built
   //  (veto shield entries may have been out-of-order above)
   //
   PlexPlaneId loNormal, hiNormal, loShield, hiShield;
   const PlexPlaneId unsetPlnId;
   unsigned int nmdlShieldSection[5] = {0,0,0,0,0};

   nodeItr_t node_itr = fPlaneTable.begin();
   nodeItr_t node_end = fPlaneTable.end();
   
   while (node_itr != node_end) {
     nodePair_t map_pair = *node_itr;
     PlexPlaneId aPlnId = node_itr->second->GetPlexPlaneId();
     node_itr++;

     if (!aPlnId.IsVetoShield()) {
       if ( loNormal == unsetPlnId ) loNormal = aPlnId;
       hiNormal = aPlnId;
     }
     else if ( ! aPlnId.IsSteel() ) {
       if ( loShield == unsetPlnId ) loShield = aPlnId;
       hiShield = aPlnId;
       // characterize the shield
       int isection = aPlnId.GetVetoSection();
       nmdlShieldSection[isection]++;
     }    
   }

   MSG("Ugli",Msg::kInfo)
     << "Built Normal planes: " << loNormal << " to " << hiNormal << "." << endl;
   if ( loShield != unsetPlnId) {
     MSG("Ugli",Msg::kInfo)
       << "Built VetoShield: " << loShield 
       << " to " << hiShield << "; Section/Mdls: ";
     for (unsigned int isec=1; isec <= 4; ++isec) {
       if ( nmdlShieldSection[isec] > 0 )
         MSG("Ugli",Msg::kInfo) 
           << " " << isec << "/" << nmdlShieldSection[isec];
     }
     MSG("Ugli",Msg::kInfo) << "." << endl;
   }
   else if ( vldc.GetDetector() == Detector::kFar )
     MSG("Ugli",Msg::kInfo) << "Built No VetoShield sections." << endl;
}


//_____________________________________________________________________________
void UgliGeometry::BuildStripShapes(const VldContext& vldc)
{
   // build this geometry's strip shapes

   MSG("Ugli",Msg::kDebug) << "UgliGeometry::BuildStripShapes " << endl;

   DbiResultPtr<UgliDbiStripStruct> stripTbl(vldc);
   TrimVldRange("UgliDbiStripStruct",stripTbl.GetValidityRec());

      for (unsigned int irow=0; irow < stripTbl.GetNumRows(); ++irow) {
         const UgliDbiStripStruct* sRow = stripTbl.GetRow(irow);
         string sname = sRow->GetShapeName();

         // self-registering with TGeometry ... this isn't a memory leak
         new UgliStripShape(sname.c_str(),sRow->GetTotalLen(),
                            sRow->GetWlsLenEast(),sRow->GetWlsLenWest(),
                            sRow->GetLenEastPart(),sRow->GetLenWestPart(),
                            sRow->GetWlsLenBypass());
      }


}

//_____________________________________________________________________________
PlexPlaneId UgliGeometry::GetPlaneIdFromZ(Double_t z) const
{
  // Return the PlexPlaneId for the last (normal) plane 
  // with a back face *downstream* of z

  // For now do it the dumb way with a simple loop
  // eventually optimization can use a binary search

  // make sure that the map is filled (may have been lost in persistency)
  RestorePlaneTable(true);

  nodeRevItr_t node_itr = fPlaneTable.rbegin();
  nodeRevItr_t node_end = fPlaneTable.rend();
  UgliPlnNode *uplane = 0, *prev_uplane = 0;
  for ( ; node_itr != node_end ; ++node_itr ) {
    uplane = node_itr->second;
    PlexPlaneId plnid  = uplane->GetPlexPlaneId();
    PlaneView::PlaneView_t view = plnid.GetPlaneView();
    // continue looking if this plane has a kA or kB view (CalDet)
    // or if veto shield view (FarDet)
    // "unknown" is okay because that means uninstrumented plane    
    if (view == PlaneView::kA || view == PlaneView::kB) continue;
    if (view > PlaneView::kUnknown ) continue;
    Float_t zback = uplane->GetZ0() + uplane->GetHalfThickness();
    if ( ! prev_uplane ) prev_uplane = uplane;
    if ( z > zback ) return prev_uplane->GetPlexPlaneId();
    prev_uplane = uplane;
  }
  return uplane->GetPlexPlaneId();

}

//_____________________________________________________________________________
UgliSteelPlnNode* UgliGeometry::GetNearestSteelPlnNode(Double_t z) const
{
   // Return the UgliSteelPlnNode* that is nearest to the given z position.
  

   const std::vector<UgliSteelPlnNode*>& steelNodes = 
     GetSteelPlnNodePtrVector();
   size_t nplns = steelNodes.size();

   // deal with some special cases
   if ( nplns == 0) {
     // no steel, no luck!
     MSG("Ugli",Msg::kError)
       << "GetNearestSteelPlnNode was passed 0 UgliSteelPlnNode's"
       << endl;
     return 0;
   }
   else if ( nplns == 1 ) return steelNodes[0];  // only one plane, that's it!


   if ( fZSteelPlnMidPoint.empty() ) {
     // we'll just assume vector of steel pln's is ordered in z
     // and also plane #.  Each entry is the mid-point z between
     // two steel planes faces (zMid is above the plane # with the same index)
     UgliSteelPlnNode* steelNode = steelNodes[0];
     Double_t dz        = steelNode->GetHalfThickness();
     Double_t z0        = steelNode->GetZ0();
     Double_t zDownSide = z0 - dz;
     Double_t zUpSide   = z0 + dz;
     for ( size_t indx = 1; indx < nplns; ++indx ) {
       Double_t zUpSideLast = zUpSide;
       UgliSteelPlnNode* steelNode = steelNodes[indx];
       dz        = steelNode->GetHalfThickness();
       z0        = steelNode->GetZ0();
       zDownSide = z0 - dz;
       zUpSide   = z0 + dz;
       Double_t zMid = 0.5 * ( zUpSideLast + zDownSide );
       fZSteelPlnMidPoint.push_back(zMid);
       /*
       int prec = cout.precision();
       cout << setprecision(18);
       cout << "Midpoint between " << (indx-1) << " and " << indx
            << " " << steelNode->GetPlexPlaneId().AsString("C") 
            << " z_mid = " << zMid
            << resetiosflags(ios::floatfield)  // reset to "%g" format
            << setprecision(prec) // restore precision
            << endl;
       */
     }
   }  // fZSteelPlnMidPoint is filled

   size_t index = BinarySearchNearestLarger(fZSteelPlnMidPoint,z);
   return steelNodes[index];
   
}

//_____________________________________________________________________________
void UgliGeometry::TrimVldRange(const char* tblName, 
                                const DbiValidityRec* dbivrec)
{ 
   // Trim VldRange based on DbiValidityRec range info

   if (dbivrec) {
      fVldRange.TrimTo(dbivrec->GetVldRange());
   } else {
      MSG("Ugli",Msg::kWarning) 
         << "No DbiValidityRec for table " << tblName << endl;
   }
}

//_____________________________________________________________________________

---