UgliGeometryReroot.cxx

Go to the documentation of this file.

// $Id: UgliGeometryReroot.cxx,v 1.36 2006/12/03 01:52:59 gmieg Exp $
//
// UgliGeometryReroot
//
// UgliGeometryReroot is an actual connection map
//   that derives its information from the connected REROOT file
//
// Author:  R. Hatcher 2000.05.03
//

#include "RerootExodus/UgliGeometryReroot.h"

#include "UgliGeometry/TGeometryX.h"
#include "UgliGeometry/UgliStripNode.h"
#include "Conventions/Munits.h"

#include "MINF_Classes/MINFast.h"
#include "REROOT_Classes/REROOT_Event.h"
#include "REROOT_Classes/REROOT_Geom.h"
#include "REROOT_Classes/REROOT_GAFKey.h"

#include "TMath.h"
#include "TCanvas.h"
#include "TRotMatrix.h"
#include "TBRIK.h"
#include "TSPHE.h"

#include "MessageService/MsgService.h"
CVSID("$Id: UgliGeometryReroot.cxx,v 1.36 2006/12/03 01:52:59 gmieg Exp $");

#include <iomanip>

#include "UgliGeometry/MinosOutline.h"

#include "DatabaseInterface/Dbi.h"
#include "DatabaseInterface/DbiCascader.h"
#include "DatabaseInterface/DbiTableProxy.h"
#include "DatabaseInterface/DbiTableProxyRegistry.h"
#include "DatabaseInterface/DbiOutRowStream.h"
#include "DatabaseInterface/DbiWriter.h"
#include "DatabaseInterface/DbiCache.h"
#include "DatabaseInterface/DbiResultPtr.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 <set>

#include "RerootExodus/RerootExodus.h"

#include <set>
#include <vector>

ClassImp(UgliGeometryReroot)

//_____________________________________________________________________________
UgliGeometryReroot::UgliGeometryReroot()
   : UgliGeometry()
{

   // Default constructor
   MSG("Ugli",Msg::kVerbose) << "UgliGeometryReroot default ctor" << endl;

   if (UgliGeometry::kNotThere == GetMINFStatus()) {
      MSG("Ugli",Msg::kWarning) 
         << "UgliGeometryReroot default ctor with no GetMINFStatus" << endl;
//      UgliLoanPool::SetAlwaysUseDbi(true);
      return;
   }

   VldContext vldc = RerootExodus::BuildVldContext();

#ifndef NO_UGLI_DATABASE
   MakeTempTables(vldc);
#endif
   BuildAll(vldc);
}

//_____________________________________________________________________________
UgliGeometryReroot::UgliGeometryReroot(const VldContext& vldc)
   : UgliGeometry()
{
   // normal constructor

   MSG("Ugli",Msg::kVerbose) << "UgliGeometryReroot vldc ctor " << endl;

   if (UgliGeometry::kNotThere == GetMINFStatus()) {
      MSG("Ugli",Msg::kWarning) 
         << "UgliGeometryReroot vldc ctor with no GetMINFStatus" << endl;
//      UgliLoanPool::SetAlwaysUseDbi(true);
      return;
   }

#ifndef NO_UGLI_DATABASE
   MakeTempTables(vldc);
#endif
   BuildAll(vldc);
}

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

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

}

//_____________________________________________________________________________
UgliGeometry::EMINFStatus UgliGeometryReroot::GetMINFStatus() const
{ if (gMINFast) return UgliGeometry::kOkay;
 else           return UgliGeometry::kNotThere; 
}

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

#ifdef NO_UGLI_DATABASE
   fVldRange = RerootExodus::BuildVldRange();
#else
   UgliGeometry::BuildVldRange(vldc);
#endif

}

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

   MSG("Ugli",Msg::kInfo) << "UgliGeometryReroot::BuildShapes " << endl;

   if (!gMINFast) {
      MSG("Ugli",Msg::kFatal) 
         << "UgliGeometryReroot::BuildShapes lacked gMINFast" 
         << endl;
      return;
   }

   UgliGeometry::BuildShapes(vldc);

#ifdef NO_UGLI_DATABASE   
   MSG("Ugli",Msg::kInfo) 
      << "UgliGeometryReroot BuildShapes NO_UGLI_DATABASE " << endl << endl;

   TString name;
   MinosOutline *outline = 0;


   REROOT_Geom  *rgeo = gMINFast->GetREROOTGeom();
   const TClonesArray *geommiscs    = rgeo->geommiscs();
   const TClonesArray *supermodules = rgeo->supermodules();
   REROOT_GeomMisc    *geommisc     = (REROOT_GeomMisc*) geommiscs->At(0);
   REROOT_SuperModule *supermodule  = 0;

   TShape     *ashapeptr = 0;
   TNodeX     *anodeptr  = 0;
   TNodeX     *worldnode = 0;
   TNodeX     *hallnode  = 0;

   Float_t local[3];
   Float_t global[3];

   // build this geometry's shapes

   Float_t xsize = geommisc->VHall()[0] * Munits::cm;
   Float_t ysize = geommisc->VHall()[1] * Munits::cm;
   Float_t zsize = geommisc->VHall()[2] * Munits::cm;

   // override so we can dispense with TView for now
   xsize = TMath::Max(TMath::Abs(geommisc->HallXmin()*Munits::cm),
                      TMath::Abs(geommisc->HallXmax()*Munits::cm)) + 
           100.*Munits::cm;
   ysize = TMath::Max(TMath::Abs(geommisc->HallYmin()*Munits::cm),
                      TMath::Abs(geommisc->HallYmax()*Munits::cm)) + 
           100.*Munits::cm;
   zsize = 0.5*(geommisc->HallZmax() - geommisc->HallZmin())*Munits::cm;

   // scale xysize by sqrt(2) so rotated UV space still encloses hall
   Float_t xysize = TMath::Max(xsize,ysize) * TMath::Sqrt(2.0);
   xsize = xysize;
   ysize = xysize;

   ashapeptr = new TBRIK("worldvol","The world space","void",
                         xysize,xysize,zsize+100.*Munits::cm);

   worldnode  = new TNodeX("worldnode","The world space",
                          "worldvol",0.,0.,0.);
   worldnode->SetVisibility(1); // make the world outline invisible
   worldnode->SetLineColor(kYellow);
   worldnode->cd();


   ashapeptr = new TSPHE("originvol","origin","void",10.*Munits::cm);
   anodeptr  = new TNodeX("originnode","origin","originvol",0.,0.,0.);
   anodeptr->SetLineColor(kMagenta);
   
   ashapeptr = new TBRIK("hall","The hall","void",
                         geommisc->VHall()[0]*Munits::cm,
                         geommisc->VHall()[1]*Munits::cm,
                         zsize);

   Float_t x0hall = 0.5 * ( geommisc->HallXmin()*Munits::cm + 
                            geommisc->HallXmax()*Munits::cm);
   Float_t y0hall = 0.5 * ( geommisc->HallYmin()*Munits::cm + 
                            geommisc->HallYmax()*Munits::cm);
   Float_t z0hall = 0.5 * ( geommisc->HallZmin()*Munits::cm + 
                            geommisc->HallZmax()*Munits::cm);

   const Float_t huge = 1.0e30;

   if (x0hall>huge) x0hall = 0.0;
   if (y0hall>huge) y0hall = 0.0;
   // world z=0 is now at first face of steel
   //   if (z0hall>huge) 
   supermodule = (REROOT_SuperModule*) supermodules->At(0);
   z0hall = geommisc->VHall()[2]*Munits::cm - supermodule->UpSpace()*Munits::cm;

   z0hall = 0;  //rwh: override for funky placement of CalDet specials

   hallnode = new TNodeX("hall","The hall",
                         "hall",x0hall,y0hall,z0hall);
   hallnode->SetVisibility(1); // leave the hall outline invisible
   hallnode->SetLineColor(kRed);

   MSG("Ugli",Msg::kInfo)
        << " UgliGeometryReroot::BuildShapes hall is sized [" 
        << geommisc->VHall()[0]*Munits::cm << "," 
        << geommisc->VHall()[1]*Munits::cm << "," 
        << geommisc->VHall()[2]*Munits::cm << "] "
        << Munits::base_length_name << "s " << endl
        << "    centered at [" 
        << x0hall << "," 
        << y0hall << "," 
        << z0hall << "]" << endl; 

   MSG("Ugli",Msg::kInfo) << endl
      << " X hall limits " 
      << geommisc->HallXmin()*Munits::cm << " "
      << geommisc->HallXmax()*Munits::cm << endl
      << " Y hall limits " 
      << geommisc->HallYmin()*Munits::cm << " "
      << geommisc->HallYmax()*Munits::cm << endl
      << " Z hall limits " 
      << geommisc->HallZmin()*Munits::cm << " " 
      << geommisc->HallZmax()*Munits::cm << endl;
   

   // the VldRange describing this geometry should only have on bit set
   Detector::Detector_t nearfar = 
      (Detector::Detector_t) fVldRange.GetDetectorMask();
//      ( geommisc->NearFar() < 0 ) ? Detector::kNear : Detector::kFar;

   Int_t nsupmdl = geommisc->NSupmdl();

   Char_t xx[40];
   TString supmdl_name, outline_name;

   for (Int_t isupmdl = 0; isupmdl < nsupmdl; isupmdl++) {

      supermodule = (REROOT_SuperModule*) supermodules->At(isupmdl);

      hallnode->cd();
      hallnode->UpdateMatrix();

      Float_t zmin_supmdl = supermodule->Zmin()*Munits::cm + 
                            supermodule->UpSpace()*Munits::cm;
      Float_t zmax_supmdl = supermodule->Zmax()*Munits::cm - 
                            supermodule->DnSpace()*Munits::cm;
      Float_t dz_supmdl = 0.5*(zmax_supmdl-zmin_supmdl);
      Float_t z0_supmdl = 0.5*(zmax_supmdl+zmin_supmdl) - z0hall;
      Float_t x0_supmdl = supermodule->SupX0()*Munits::cm; // - x0hall;
      Float_t y0_supmdl = supermodule->SupY0()*Munits::cm; // - y0hall;

//      cout << " SM" << isupmdl << " zlimits [" 
//        << zmin_supmdl << "," 
//        << zmax_supmdl << "] centered at [" 
//        << x0_supmdl << "," 
//        << y0_supmdl << "," 
//        << z0_supmdl << "]" << endl; 

      global[0] = x0_supmdl;
      global[1] = y0_supmdl;
      global[2] = z0_supmdl;

      hallnode->Master2Local(global,local);

      x0_supmdl = local[0];
      y0_supmdl = local[1];
      z0_supmdl = local[2];

//      cout << " local position ["
//        << x0_supmdl << "," 
//        << y0_supmdl << "," 
//        << z0_supmdl << "]" << endl; 

      Float_t x0shift;
      PlaneView::PlaneView_t noview = PlaneView::kUnknown;
      PlaneCoverage::PlaneCoverage_t cover = PlaneCoverage::kComplete;
      if (nearfar == Detector::kNear)
                                     cover = PlaneCoverage::kNearFull;

      sprintf(xx,"%d",isupmdl);
      supmdl_name = "SM"; supmdl_name += xx;

// outline "partial" active -- only first SM of near detector
      if (nearfar == Detector::kNear && isupmdl == 0) {
         PlexPlaneId partActv(nearfar,-1,false,noview,
                              PlaneCoverage::kNearPartial);
         outline_name = supmdl_name + "PartialActive";
         outline = new MinosOutline(outline_name,outline_name,"void",
                                    partActv,false,dz_supmdl,1.);
         x0shift = outline->GetGlobalXOffset() * Munits::cm;
         anodeptr = new TNodeX(outline_name,outline_name,outline_name,
                              x0_supmdl+x0shift,y0_supmdl,z0_supmdl);
         anodeptr->SetLineColor(kGreen);
         anodeptr->SetVisibility(1);
      }

// special case for CalDet supermodules 5th+ (isupmdl>5) which are placed
// in odd location and orientation

     if (nearfar == Detector::kCalib && isupmdl >= 5) {

        outline_name = supmdl_name;
        Float_t dx = 0.5*(supermodule->Xmax()*Munits::cm - 
                          supermodule->Xmin()*Munits::cm);
        Float_t dy = 0.5*(supermodule->Ymax()*Munits::cm - 
                          supermodule->Ymin()*Munits::cm);
        Float_t dz = 0.5*(supermodule->Zmax()*Munits::cm - 
                          supermodule->Zmin()*Munits::cm);
        Float_t x0 = 0.5*(supermodule->Xmax()*Munits::cm + 
                          supermodule->Xmin()*Munits::cm);
        Float_t y0 = 0.5*(supermodule->Ymax()*Munits::cm + 
                          supermodule->Ymin()*Munits::cm);
        Float_t z0 = 0.5*(supermodule->Zmax()*Munits::cm + 
                          supermodule->Zmin()*Munits::cm);
        TBRIK *caldet_special = 0;
        caldet_special = new TBRIK(supmdl_name,supmdl_name,"void",dx,dy,dz);
        anodeptr = new TNodeX(supmdl_name,supmdl_name,supmdl_name,x0,y0,z0);
        anodeptr->SetLineColor(kGreen);
        anodeptr->SetVisibility(1);
        // skip the rest of the shapes for this "supermodule"
        // move on to next "supermodule"
        continue; 
     }

// outline "full" active
      outline_name = supmdl_name + "FullActive";
      PlexPlaneId fullActv(nearfar,-1,false,noview,cover);
      outline = new MinosOutline(outline_name,outline_name,"void",
                                 fullActv,false,dz_supmdl,1.);
      x0shift = outline->GetGlobalXOffset() * Munits::cm;
      anodeptr = new TNodeX(outline_name,outline_name,outline_name,
                           x0_supmdl+x0shift,y0_supmdl,z0_supmdl);
      anodeptr->SetLineColor(kGreen);
      anodeptr->SetVisibility(1);

      outline_name = supmdl_name + "SteelEars";
      PlexPlaneId steelid = fullActv;
      steelid.SetIsSteel(true);
      outline = new MinosOutline(outline_name,outline_name,"void",
                                 steelid,true,dz_supmdl,1.);
      x0shift = outline->GetGlobalXOffset() * Munits::cm;
      anodeptr = new TNodeX(outline_name,outline_name,outline_name,
                           x0_supmdl+x0shift,y0_supmdl,z0_supmdl);
      anodeptr->SetLineColor(kBlue);
      anodeptr->SetVisibility(1);

   }

      /*******************
  Double_t local[3];
  Double_t master[3];

  TPolyLine3D* line = new TPolyLine3D(2);
  local[0] = 0;
  local[1] = 0;
  local[2] = 0;
  westw->UpdateMatrix();
  westw->Local2Master(local,master);
  line->SetPoint(0,master[0],master[1],master[2]);
  eastw->UpdateMatrix();
  eastw->Local2Master(local,master);
  line->SetPoint(1,master[0],master[1],master[2]);
  *****************/                              
#endif

}

//_____________________________________________________________________________

void UgliGeometryReroot::BuildNodes(const VldContext& vldc)
{
   // build this geometry's basic nodes (planes)

   MSG("Ugli",Msg::kInfo) << "UgliGeometryReroot::BuildNodes " << endl;

   if (!gMINFast) {
      MSG("Ugli",Msg::kFatal) 
         << "UgliGeometryReroot::BuildNodes lacked gMINFast" 
         << endl;
      return;
   }

#ifndef NO_UGLI_DATABASE
   UgliGeometry::BuildNodes(vldc);
#else
   MSG("Ugli",Msg::kInfo) 
      << "UgliGeometryReroot BuildNodes NO_UGLI_DATABASE " << endl << endl;


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

   Int_t nscint = RerootExodus::NumberOfPlanes(kTRUE);
   Int_t nsteel = RerootExodus::NumberOfPlanes(kFALSE);
   Int_t npairs = TMath::Max(nscint,nsteel);
   
   if (!fPlaneNodes) fPlaneNodes = new TObjArray(nscint+nsteel);

   TNodeX* node = 0;

   for (Int_t rpln = 0; rpln < npairs; rpln++) {

      TString pname = RerootExodus::PasvPlaneName(rpln);
      if ( pname[0] == 'B' || pname[0] == 'S' ) {
         PlexPlaneId steelid = RerootExodus::RerootPln2PlnId(rpln,kFALSE);
         node = new UgliSteelPlnNode(this,steelid);
         fPlaneNodes->AddLast(node);
         fPlaneTable[steelid] = node;
      }

      TString aname = RerootExodus::ActvPlaneName(rpln);
      if ( aname[0] == 'F' || aname[0] == 'M' ) {
         PlexPlaneId scintid = RerootExodus::RerootPln2PlnId(rpln,kTRUE);
         node = new UgliScintPlnNode(this,scintid);
         fPlaneNodes->AddLast(node);
         fPlaneTable[scintid] = node;
      }

   }
#endif

}

//_____________________________________________________________________________

void UgliGeometryReroot::MakeTempTables(const VldContext& vldc)
{
   // use REROOT data to fill MySQL temporary tables

   MSG("Ugli",Msg::kInfo)
      << "UgliGeometryReroot::MakeTempTables --"
      << endl
      << " this step can be bypassed for standard geometries by adding the line: "
      << endl
      << "     UgliLoanPool::SetAlwaysUseDbi(true);"
      << endl
      << " in the job .C script before the any code triggers building the geometry."
      << endl;

   // writers expect a filled fVldRange
   fVldRange = RerootExodus::BuildVldRange();

   MakeTempDbiGeometry(vldc);
   MakeTempDbiScintStruct(vldc);
   MakeTempDbiPosInfo(vldc);

}

//_____________________________________________________________________________
void UgliGeometryReroot::MakeTempDbiGeometry(const VldContext& /* vldc */)
{
   // use REROOT data to fill MySQL temporary UgiDbiGeometry table

   const char* tblName  = "UGLIDBIGEOMETRY";
   const char* tblDescr =  UgliDbiGeometry::GetTableDescr();

   // get the cascader
   DbiCascader& cascader = 
      DbiTableProxyRegistry::Instance().GetCascader();

   // find a db we can write temp tables to
   Int_t dbNoTemp = cascader.CreateTemporaryTable(tblName,tblDescr);
   if ( dbNoTemp < 0 ) {
      MSG("Ugli",Msg::kWarning) 
         << "No database will accept temporary tables." << endl;
      return;
   }

   // create a DbiWriter
   Int_t aggNo    = -1;
   Dbi::Task task = 0;
   VldTimeStamp now;
   DbiWriter<UgliDbiGeometry> writer(fVldRange,aggNo,task,now,dbNoTemp);

   // clear any copy that's being cached
   writer.TableProxy().GetCache()->SetStale();

   // dangerous, but geometry can't but one bit set in VldRange's detmask
   Detector::Detector_t detector = 
      (Detector::Detector_t) fVldRange.GetDetectorMask();
   bool isXYUV = false;
   if (Detector::kCalDet == detector) isXYUV = true;

   REROOT_GeomMisc *geommisc = RerootExodus::GetGeomMisc();

   Float_t hall_min[3];
   Float_t hall_max[3];

   hall_min[0] = geommisc->HallXmin() * Munits::cm;
   hall_min[1] = geommisc->HallYmin() * Munits::cm;
   hall_min[2] = geommisc->HallZmin() * Munits::cm;
   hall_max[0] = geommisc->HallXmax() * Munits::cm;
   hall_max[1] = geommisc->HallYmax() * Munits::cm;
   hall_max[2] = geommisc->HallZmax() * Munits::cm;

   // create a row
   UgliDbiGeometry row(detector,isXYUV,hall_min,hall_max);

   // store the row into the DbiWriter
   writer << row;

   // in this case there is only one rot
   // close the writer (validate and write)
   bool success = writer.Close();

   if (!success) 
      MSG("Ugli",Msg::kWarning) 
         << "Failed to write to temporary table." << endl;

}

//_____________________________________________________________________________
void UgliGeometryReroot::MakeTempDbiScintStruct(const VldContext& /* vldc */)
{
   // use REROOT data to fill MySQL temporary tables:
   //   UgiDbiScintPlnStruct, UgliDbiScintMdlStruct and UgliDbiStripStruct;

   const char* plnTblName  = "UGLIDBISCINTPLNSTRUCT";
   const char* plnTblDescr =  UgliDbiScintPlnStruct::GetTableDescr();

   const char* mdlTblName  = "UGLIDBISCINTMDLSTRUCT";
   const char* mdlTblDescr =  UgliDbiScintMdlStruct::GetTableDescr();

   const char* stripTblName  = "UGLIDBISTRIPSTRUCT";
   const char* stripTblDescr =  UgliDbiStripStruct::GetTableDescr();

#undef ORDERED_ENTRY
//#define ORDERED_ENTRY
#ifdef ORDERED_ENTRY
   vector<UgliDbiScintPlnStruct>           plnRowVec;
   vector<UgliDbiScintPlnStruct>::iterator plnRowIter;
   vector<UgliDbiScintMdlStruct>           mdlRowVec;
   vector<UgliDbiScintMdlStruct>::iterator mdlRowIter;
   vector<UgliDbiStripStruct>            stripRowVec;
   vector<UgliDbiStripStruct>::iterator  stripRowIter;
#endif

   // get the cascader
   DbiCascader& cascader = 
      DbiTableProxyRegistry::Instance().GetCascader();

   // find a db we can write temp tables to 
   Int_t plnDb   = cascader.CreateTemporaryTable(plnTblName,plnTblDescr);
   Int_t mdlDb   = cascader.CreateTemporaryTable(mdlTblName,mdlTblDescr);
   Int_t stripDb = cascader.CreateTemporaryTable(stripTblName,stripTblDescr);
   if ( plnDb < 0 || mdlDb < 0 || stripDb < 0) {
      MSG("Ugli",Msg::kWarning) 
         << "No database will accept temporary tables." << endl;
      return;
   }

   // create DbiWriters
   Int_t aggNo    = -1;
   Dbi::Task task = 0;
   VldTimeStamp now;

   DbiWriter<UgliDbiScintPlnStruct> plnWriter(fVldRange,aggNo,task,now,plnDb);
   DbiWriter<UgliDbiScintMdlStruct> mdlWriter(fVldRange,aggNo,task,now,mdlDb);
   DbiWriter<UgliDbiStripStruct>  stripWriter(fVldRange,aggNo,task,now,stripDb);

   // clear any copy that's being cached
   plnWriter.TableProxy().GetCache()->SetStale();
   mdlWriter.TableProxy().GetCache()->SetStale();
   stripWriter.TableProxy().GetCache()->SetStale();

   // list of the indexes we've entered so far
   // this way we don't re-enter data
   typedef set<UInt_t>                 indxset;
   typedef set<UInt_t>::iterator       indxsetIter;
   typedef set<UInt_t>::const_iterator indxsetConstIter;
   typedef pair<indxsetIter,bool>      indxsetPair;
   indxset plnEntered, mdlEnterd, stripEnterd;

   // loop over the active detector planes
   int npairs = RerootExodus::GetGeomMisc()->NPlanes() + 1;
   for (int ipln = 0; ipln<npairs; ipln++) {
      int rr_scint = RerootExodus::SteelToRerootPlane(ipln,true);
      PlexPlaneId scintplnid = RerootExodus::RerootPln2PlnId(rr_scint,true);
      REROOT_PlaneSpec *spec = RerootExodus::GetPlaneSpec(scintplnid);
      // skip onward if there isn't an active at this position
      if (!spec) continue;

      // find natural index 
      UInt_t plnIndx = UgliDbiStructHash(scintplnid).HashAsPlane();
      indxsetPair ispair = plnEntered.insert(plnIndx);
      // check if we've already handled this combination of (view,coverage)
      // we can tell because if it was already in the set then 
      // the insert fails
      MSG("Ugli",Msg::kDebug)
         << " ScintPlnStruct " << scintplnid.AsString("c") 
         << " hash " << plnIndx 
         << " ispair.second " << (int)ispair.second << endl;
      if (!ispair.second) continue;

      TString aname = RerootExodus::ActvPlaneName(rr_scint);
      int mxstrips = RerootExodus::NStripsNonZero(rr_scint);
      // loop over the strips in the plane to find out about
      // MdlStruct and StripStruct
      int last_extru  = -1;
      int current_mdl = 0, first_strip = 0, last_strip = 0;  // current mdl info
      for (int istrip=0; istrip<mxstrips; istrip++) {
         PlexStripEndId seid(scintplnid,istrip);
         REROOT_CellPos *cellpos = RerootExodus::GetCellPos(seid);
         if (!cellpos) continue;
         if (cellpos->IExtr() != last_extru) {
            // starting new module
            if (last_extru == -1) { 
               // first module, just initialize
               current_mdl = 0;
               first_strip = 0;
            }
            else {
               // make a MdlStruct row entry, prepare for next
               string mdlName = StandardMdlName(scintplnid,current_mdl,aname);
               PlexScintMdlId scintmdlid(scintplnid,current_mdl);
               UgliDbiScintMdlStruct mdlRow(scintmdlid,mdlName,
                                            first_strip,last_strip);
               MSG("Ugli",Msg::kDebug)
                 << "UgliDbiScintMdlStruct entry " << scintplnid.AsString("c")
                 << " module " << current_mdl << " [" << first_strip
                 << "," << last_strip << "] (hash = "
                 << mdlRow.GetIndex(0) << ") " << endl;
#ifdef ORDERED_ENTRY
               UInt_t indx = mdlRow.GetIndex(-1);
               if (mdlRowVec.size()<=indx) mdlRowVec.resize(indx+1);
               // resize invalidated iters
               mdlRowIter = mdlRowVec.begin() + indx;
               mdlRowVec[indx] = mdlRow;
#else
               mdlWriter << mdlRow;
#endif
               // prepare for next
               current_mdl++;
               first_strip = last_strip+1;
            }
            last_extru = cellpos->IExtr();
            last_strip = first_strip; 
         } // IExtr != last_extru

         // unpack info about this strip
         Float_t totlen, wls_east, wls_west, len_east, len_west, len_bypass;
         totlen = TMath::Abs(cellpos->XYZReadout()[0] -
                             cellpos->XYZFarend()[0]    ) * Munits::cm;
         ABtoEastWest(cellpos->FiberTailA() * Munits::cm,
                      cellpos->FiberTailB() * Munits::cm,
                      scintplnid,aname,wls_east,wls_west);
                      
         // for now don't worry about physically split strips
         len_east = len_west = totlen;
         len_bypass = 0 * Munits::cm;

         // make a StripStruct row entry
         UgliDbiStripStruct 
            stripRow(seid,current_mdl,totlen,wls_east,wls_west,
                     len_east,len_west,len_bypass);
#ifdef ORDERED_ENTRY
               UInt_t indx = stripRow.GetIndex(-1);
               if (stripRowVec.size()<=indx) stripRowVec.resize(indx+1);
               // resize invalidated iters
               stripRowIter = stripRowVec.begin() + indx;
               stripRowVec[indx] = stripRow;
#else
         stripWriter << stripRow;
#endif
                                        
         last_strip = istrip;
      } // end loop over strips
      if (last_extru != -1) {
         // flush out last MdlStruct row entry
         string mdlName = StandardMdlName(scintplnid,current_mdl,aname);
         UgliDbiScintMdlStruct mdlRow(PlexScintMdlId(scintplnid,current_mdl),
                                      mdlName,first_strip,last_strip);
      MSG("Ugli",Msg::kDebug)
        << "UgliDbiScintMdlStruct entry " << scintplnid.AsString("c")
        << " module " << current_mdl << " [" << first_strip
        << "," << last_strip << "] (hash = "
        << mdlRow.GetIndex(0) << ") " << endl;
#ifdef ORDERED_ENTRY
         UInt_t indx = mdlRow.GetIndex(-1);
         if (mdlRowVec.size()<=indx) mdlRowVec.resize(indx+1);
         // resize invalidated iters
         mdlRowIter = mdlRowVec.begin() + indx;
         mdlRowVec[indx] = mdlRow;
#else
         mdlWriter << mdlRow;
#endif
      }

      // create a PlnStruct row, store it in the writer
      Short_t nmodules = current_mdl+1;
      UgliDbiScintPlnStruct plnRow(scintplnid,nmodules);
      MSG("Ugli",Msg::kDebug)
        << "UgliDbiScintPlnStruct entry " << scintplnid.AsString("c")
        << " has " << nmodules << " modules (hash = "
        << plnRow.GetIndex(0) << ") " << endl;
#ifdef ORDERED_ENTRY
      UInt_t indx = plnRow.GetIndex(-1);
      if (plnRowVec.size()<=indx) plnRowVec.resize(indx+1);
      // resize invalidated iters
      plnRowIter = plnRowVec.begin() + indx;
      plnRowVec[indx] = plnRow;
#else
      plnWriter << plnRow;
#endif

   } // loop over planes

#ifdef ORDERED_ENTRY
   // if where in this block we've delayed entry so that
   // we could write the elements in order
   MSG("Ugli",Msg::kInfo) 
      << "plnRowVec had " << plnRowVec.size() << " entries " << endl;
   for (UInt_t i = 0; i< plnRowVec.size(); i++) 
     plnWriter << plnRowVec[i];

   MSG("Ugli",Msg::kInfo) 
      << "mdlRowVec had " << mdlRowVec.size() << " entries " << endl;
   for (UInt_t i = 0; i< mdlRowVec.size(); i++) 
     mdlWriter << mdlRowVec[i];

   MSG("Ugli",Msg::kInfo) 
      << "stripRowVec had " << stripRowVec.size() << " entries " << endl;
   for (UInt_t i = 0; i< stripRowVec.size(); i++) 
     stripWriter << stripRowVec[i];

   MSG("Ugli",Msg::kInfo) << "Struct data entry complete" << endl;
#endif

   // close the writers (validate and write)
   bool plnSuccess   = plnWriter.Close();
   MSG("Ugli",Msg::kInfo) 
      << "plnStructWriter " << ((plnSuccess)?"ok":"failed") << endl;
   bool mdlSuccess   = mdlWriter.Close();
   MSG("Ugli",Msg::kInfo) 
      << "mdlStructWriter " << ((mdlSuccess)?"ok":"failed") << endl;
   bool stripSuccess = stripWriter.Close();
   MSG("Ugli",Msg::kInfo) 
      << "stripStructWriter " << ((stripSuccess)?"ok":"failed") << endl;

   if (!plnSuccess || !mdlSuccess || ! stripSuccess) 
      MSG("Ugli",Msg::kWarning) 
         << "Failed to write to temporary table." << endl;
}

//_____________________________________________________________________________
void UgliGeometryReroot::MakeTempDbiPosInfo(const VldContext& vldc)
{
   // use REROOT data to fill MySQL temporary tables:
   // UgiDbiSteelPln, UgiDbiScintPln, UgiDbiScintMdl, UgiDbiStrip 

  MSG("Ugli",Msg::kInfo) << "UgliGeometryReroot: Start MakeTempDbiPosInfo" << endl;

   const char* steelTblName  = "UGLIDBISTEELPLN";
   const char* steelTblDescr =  UgliDbiSteelPln::GetTableDescr();

   const char* plnTblName  = "UGLIDBISCINTPLN";
   const char* plnTblDescr =  UgliDbiScintPln::GetTableDescr();

   const char* mdlTblName  = "UGLIDBISCINTMDL";
   const char* mdlTblDescr =  UgliDbiScintMdl::GetTableDescr();

   const char* stripTblName  = "UGLIDBISTRIP";
   const char* stripTblDescr =  UgliDbiStrip::GetTableDescr();

   // get the cascader
   DbiCascader& cascader = 
      DbiTableProxyRegistry::Instance().GetCascader();

   // find a db we can write temp tables to 
   Int_t steelDb = cascader.CreateTemporaryTable(steelTblName,steelTblDescr);
   Int_t plnDb   = cascader.CreateTemporaryTable(plnTblName,plnTblDescr);
   Int_t mdlDb   = cascader.CreateTemporaryTable(mdlTblName,mdlTblDescr);
   Int_t stripDb = cascader.CreateTemporaryTable(stripTblName,stripTblDescr);
   if ( steelDb < 0 || plnDb < 0 || mdlDb < 0 || stripDb < 0) {
      MSG("Ugli",Msg::kWarning) 
         << "No database will accept temporary tables." << endl;
      return;
   }

   typedef struct angles { Char_t view; 
      Float_t thetax, phix, thetay, phiy, thetaz, phiz; } angles_t;

   angles_t gminos_angles[] =
   { {'X',  90,   0,  90,  90,   0,   0}, //[0]
     {'Y',  90, 270,  90,   0,   0,   0}, //[1]
     {'U',  90, -45,  90,  45,   0,   0}, //[2]  90,315, 90, 45,  0,  0
     {'V',  90,  45,  90, 135,   0,   0}, //[3]  90,225, 90,315,  0,  0 !!
     {'A',  90,   0,   0,   0,  90, 270}, //[4]
     {'B', 180,   0,  90,   0,  90, 270}, //[5]
     {'W',  90,  45,  90, 135,   0,   0}, //[6]  90, 45, 90,135,  0,  0
     {'?',  90,   0,  90,  90,   0,   0}  //[7]
   };
   int nangles = sizeof(gminos_angles) / sizeof(angles_t);

   for (int i=0; i<nangles; i++) {
      // convert to radians by saying these numbers are in degrees
      gminos_angles[i].thetax *= Munits::degree;
      gminos_angles[i].thetay *= Munits::degree;
      gminos_angles[i].thetaz *= Munits::degree;
      gminos_angles[i].phix   *= Munits::degree;
      gminos_angles[i].phiy   *= Munits::degree;
      gminos_angles[i].phiz   *= Munits::degree;
   }

   // loop over the all detector planes
   // +1 because of active-passive switch
   int npairs = RerootExodus::GetGeomMisc()->NPlanes() + 1;

   // a fake in case there is a missing PlanePos
   REROOT_PlanePos *fake_scintpos = 0;
   REROOT_PlanePos *fake_steelpos = 0;

   // consistent set of times for DbiWriter's
   VldTimeStamp now;
   Dbi::Task task = 0;

   int iplnLastWritten = -1;
   for (int ipln = 0; ipln<npairs; ipln++) {

      MSG("Ugli",Msg::kInfo) 
         << "UgliGeometryReroot: fill temp position table for plane " 
         << ipln << "\r" << flush;

      // create DbiWriter for SteelPln, aggregation is by plane #
      Int_t aggNo    = ipln;

      // only the steel one here
      // others after we know that there is a scint plane
      // all scint are attached to a steel (even if it has no thickness)
      DbiWriter<UgliDbiSteelPln> steelWriter(fVldRange,aggNo,task,now,steelDb);

      // RWH: Do the others here so that we get a VLD record but no data
      // entries for planes that don't have scintillator.  This will
      // obscure potentially other entries that it could otherwise
      // pick up.
      // create DbiWriter for ScintPln, ScintMdl, Strip
      // aggregation is by plane #
      DbiWriter<UgliDbiScintPln>   plnWriter(fVldRange,aggNo,task,now,plnDb);
      DbiWriter<UgliDbiScintMdl>   mdlWriter(fVldRange,aggNo,task,now,mdlDb);
      DbiWriter<UgliDbiStrip>    stripWriter(fVldRange,aggNo,task,now,stripDb);

      // clear any copy that's being cached
      steelWriter.TableProxy().GetCache()->SetStale();
      plnWriter.TableProxy().GetCache()->SetStale();
      mdlWriter.TableProxy().GetCache()->SetStale();
      stripWriter.TableProxy().GetCache()->SetStale();

      // start looking up REROOT info
      int rr_scint = RerootExodus::SteelToRerootPlane(ipln,true);
      int rr_steel = RerootExodus::SteelToRerootPlane(ipln,false);
      PlexPlaneId scintplnid = RerootExodus::RerootPln2PlnId(rr_scint,true);
      PlexPlaneId steelplnid = RerootExodus::RerootPln2PlnId(rr_steel,false);
      REROOT_PlanePos  *scintpos  = RerootExodus::GetPlanePos(scintplnid);
      REROOT_PlaneSpec *scintspec = RerootExodus::GetPlaneSpec(scintplnid);
      REROOT_PlanePos  *steelpos  = RerootExodus::GetPlanePos(steelplnid);
      REROOT_PlaneSpec *steelspec = RerootExodus::GetPlaneSpec(steelplnid);


      // alas some poorly constructed REROOT files have
      // no trailing steel behind the last active
      // as well as the more normal lead steel without active
      bool ok_steel = (steelplnid.GetPlane() == ipln);
      bool ok_scint = (scintplnid.GetPlane() == ipln);
      if (!ok_steel && !ok_scint) {
        MSG("Ugli",Msg::kError)
          << endl << "Neither ok_steel nor ok_scint."
          << endl;
        continue; // this shouldn't happen
      }
      if (!ok_steel &&  ok_scint) { // construct a valid id
         steelplnid = scintplnid;
         steelplnid.SetIsSteel(true);
         steelpos  = RerootExodus::GetPlanePos(steelplnid);
         steelspec = RerootExodus::GetPlaneSpec(steelplnid);
      }

      // special case for CalDet ...
      // PlexPlaneId expects a plane 0 active it might not be there in REROOT
      // GMINOS has no real steel downstream of plane 60
      //    the following steel is for the cosmic planes
      
      bool iscaldet = scintplnid.GetDetector() == Detector::kCalDet;
      bool noinfo   = ( !scintspec || !scintpos );
      bool caldet0  = iscaldet && noinfo && scintplnid.GetPlane() == 0;
      bool caldet60 = iscaldet && scintplnid.GetPlane() == 60;

      char key = RerootExodus::ActvPlaneName(rr_scint)[0];
      bool trailing_scint = ( ipln == npairs-1 && ok_scint && !ok_steel 
           && ( key == 'F' || key == 'M' ) );

      if (caldet0) {
         // for a fake caldet active plane 0 use plane 2 shifted by 2
         // assumes dz for both views are the same
         PlexPlaneId caldet2id = scintplnid; 
         caldet2id.SetPlane(2);
         scintpos  = RerootExodus::GetPlanePos(caldet2id);
         
         // produce an fake REROOT_PlanePos for scintpos
         PLANEPOS_DEF *pp = CreateAndBackFillPlanePosDef(scintpos);
         // modify it to be the plane it should be
         pp->ID       -= 2;
         pp->InMdl    -= 2;
         Float_t dz = pp->PairZmax - pp->PairZmin;
         pp->PairZmin  -= 2*dz - zoffset_REROOT();
         pp->PairZmax  -= 2*dz - zoffset_REROOT();
         pp->ZFrntPasv -= 2*dz - zoffset_REROOT();
         pp->ZFrntActv -= 2*dz - zoffset_REROOT();
         // create new fake scintpos
         if (fake_scintpos) delete fake_scintpos;
         fake_scintpos = new REROOT_PlanePos(pp);
         // delete intermediary PLANEPOS_DEF
         delete pp;
         // use this REROOT_PlanePos for calculations
         scintpos = fake_scintpos;

         steelspec = RerootExodus::GetPlaneSpec(caldet2id);

      } // missing caldet active plane 0
      else if (caldet60) {
         // for a fake caldet passive 60 use plane 58 shifted by 2
         // assumes dz for both views are the same
         PlexPlaneId caldet58id = steelplnid; 
         caldet58id.SetPlane(58);
         steelpos  = RerootExodus::GetPlanePos(caldet58id);
         
         // produce an fake REROOT_PlanePos for steelpos
         PLANEPOS_DEF *pp = CreateAndBackFillPlanePosDef(steelpos);
         // modify it to be the plane it should be
         pp->ID       += 2;
         pp->InMdl    += 2;
         Float_t dz = pp->PairZmax - pp->PairZmin;
         pp->PairZmin  += 2*dz - zoffset_REROOT();
         pp->PairZmax  += 2*dz - zoffset_REROOT();
         pp->ZFrntPasv += 2*dz - zoffset_REROOT();
         pp->ZFrntActv += 2*dz - zoffset_REROOT();
         // create new fake steelpos
         if (fake_steelpos) delete fake_steelpos;
         fake_steelpos = new REROOT_PlanePos(pp);
         // delete intermediary PLANEPOS_DEF
         delete pp;
         // use this REROOT_PlanePos for calculations
         steelpos = fake_steelpos;

         steelspec = RerootExodus::GetPlaneSpec(caldet58id);

      } // missing caldet steel for plane 60
      else if ( trailing_scint ) {
         MSG("Ugli",Msg::kInfo) << endl; // don't overwrite last info message
         MSG("Ugli",Msg::kWarning) 
            << " Geometry with trailing scint plane " << endl;

         // for a GMINOS geometries (namely 24 pln far detector)
         // that have N*<steel+active> rather than
         // stell + N*<active+steel>

         PlexPlaneId fakesteelid = steelplnid; 
         fakesteelid.SetPlane(steelplnid.GetPlane()-2);
         steelpos  = RerootExodus::GetPlanePos(fakesteelid);
         
         // produce an fake REROOT_PlanePos for steelpos
         PLANEPOS_DEF *pp = CreateAndBackFillPlanePosDef(steelpos);
         // modify it to be the plane it should be
         pp->ID       += 2;
         pp->InMdl    += 2;
         Float_t dz = pp->PairZmax - pp->PairZmin;
         pp->PairZmin  += 2*dz - zoffset_REROOT();
         pp->PairZmax  += 2*dz - zoffset_REROOT();
         pp->ZFrntPasv += 2*dz - zoffset_REROOT();
         pp->ZFrntActv += 2*dz - zoffset_REROOT();
         // create new fake steelpos
         if (fake_steelpos) delete fake_steelpos;
         fake_steelpos = new REROOT_PlanePos(pp);
         // delete intermediary PLANEPOS_DEF
         delete pp;
         // use this REROOT_PlanePos for calculations
         steelpos = fake_steelpos;

         steelspec = RerootExodus::GetPlaneSpec(fakesteelid);
      }

      // Every (interesting) plane has a steel (of some sort)
      if (!steelpos) {
        MSG("Ugli",Msg::kInfo)
          << endl << "!steelpos for ipln " << ipln << "." << endl;
          continue;
      }

      // copy locally because AsString uses static 
      char steelnam[16], scintnam[16];
      sprintf(steelnam,"%s",steelplnid.AsString("c"));
      sprintf(scintnam,"%s",scintplnid.AsString("c"));

      MSG("Ugli",Msg::kVerbose) 
         << "UgliGeometryReroot: build table info for " 
         << steelnam << " " << (int)ok_steel 
         << " " << steelpos << " " << steelspec << " "
         << scintnam << " " << (int)ok_scint 
         << " " << scintpos << " " << scintspec << " "
         << RerootExodus::ActvPlaneName(rr_scint)
         << endl;

      PlaneCoverage::PlaneCoverage_t cover = scintplnid.GetPlaneCoverage();

      Float_t cell_width   =  0;
      Float_t scint_thick  =  0;
      Float_t gap_scint    =  0;

      Float_t steel_thick  =  0;
      Float_t gap_steel    =  0;
      Int_t   melt         = -1;
      Float_t x0steel      =  0;
      Float_t y0steel      =  0;

      if (scintspec && cover != PlaneCoverage::kNoActive) {
         cell_width  = scintspec->CellWidth() * Munits::cm;
         scint_thick = scintspec->Thickness() * Munits::cm;
         gap_scint   = scintspec->AirGap()[1] * Munits::cm;
      }

      if (steelspec) {
         steel_thick = steelspec->Thickness() * Munits::cm;
         gap_steel   = steelspec->AirGap()[0] * Munits::cm;
         melt        = steelspec->BMap() + 1000000;
      }

      // steel in GMINOS is always "X" orientation
      // (unless it is a CalDet A/B plane)
      angles_t steel_angles = gminos_angles[0];

      PlaneView::PlaneView_t view = scintplnid.GetPlaneView();
      if (vldc.GetDetector() == Detector::kCalDet ) {
         // CalDet U/V are old GMINOS Y/X (yes, that order)
         if (view == PlaneView::kU) view = PlaneView::kY;
         if (view == PlaneView::kV) view = PlaneView::kX;
      }

      // play special games in case of CalDet A & B view planes
      if (PlaneView::kA == view || PlaneView::kB == view) {
         // UGH!!! those nasty A/B views

         steel_angles = gminos_angles[(int)view];

         // use the info for the steel *upstream*
         // as it is used in GMINOS
         PlexPlaneId steelid_AB =
            RerootExodus::RerootPln2PlnId(rr_scint,false);
         steelpos  = RerootExodus::GetPlanePos(steelid_AB);
         steelspec = RerootExodus::GetPlaneSpec(steelid_AB);

         steel_thick = steelspec->Thickness() * Munits::cm;
         gap_steel   = steelspec->AirGap()[0] * Munits::cm;
         melt        = steelspec->BMap() + 1000000;

         // produce an fake REROOT_PlanePos for steelpos
         PLANEPOS_DEF *pp = CreateAndBackFillPlanePosDef(steelpos);
         // modify it
         // compensate for various bits
         Float_t dz = 0.5*scintspec->Thickness();
         REROOT_Geom  *rgeo = gMINFast->GetREROOTGeom();

#ifdef XYZZY_DEBUG
         cout << " pp->ZFrntPasv " << pp->ZFrntPasv << " cm "
              << ", dz " << dz << " cm "
              << ", shift " << rgeo->GetGlobalZ0Shift() << " cm "
              << ", steel " << steelspec->Thickness() << " cm "
              << endl;
//pp->ZFrntPasv 49.99946594 cm , dz 0.55 cm , shift -123.0 cm , steel 0.001 cm 
#endif

         // the following adjustments seem to work ... to within
         // either the precision and/or some complicated function of
         // the fake steel thickness (0.001cm).
         // possibly not enough precision in the rotation angle
         // (gets lost in the SQL transfer to/from the DB).
         pp->ZFrntPasv +=      dz - rgeo->GetGlobalZ0Shift();
         pp->XYPasv[0] -=      dz;
         pp->XYPasv[1] -=  2.0*dz;
//gminos  61   0 [  -45.125, -160.476,   -0.200]  [  -49.175, -159.525,   99.800]
//reroot  61   0 [  -45.125, -160.474,   -0.199]  [  -49.176, -159.524,   99.801]
         pp->ZFrntPasv += 0.0*steelspec->Thickness();
         pp->XYPasv[0] -= 1.0*steelspec->Thickness();
         pp->XYPasv[1] -= 1.0*steelspec->Thickness();
//gminos  61   0 [  -45.125, -160.476,   -0.200]  [  -49.175, -159.525,   99.800]
//reroot  61   0 [  -45.125, -160.475,   -0.200]  [  -49.176, -159.525,   99.800]

         if (fake_steelpos) delete fake_steelpos;
         fake_steelpos = new REROOT_PlanePos(pp);
         delete pp;
         steelpos = fake_steelpos;

      } // A & B views

      // scint is on the upstream face of steel
      Float_t gap     = gap_scint + gap_steel;
      Float_t total_z = scint_thick + gap + steel_thick;

      if (steelpos) {
         x0steel = steelpos->XYPasv()[0] * Munits::cm;
         y0steel = steelpos->XYPasv()[1] * Munits::cm;
      }

      Float_t z_back = steelpos->ZFrntPasv()*Munits::cm + steel_thick;

      // deal with the steel before the scintillator
      
      // create a SteelPln row, store it in the writer
      UgliDbiSteelPln steelRow(steelplnid,melt,steel_thick,total_z,
                               x0steel,y0steel,z_back,
                               steel_angles.thetax,steel_angles.phix,
                               steel_angles.thetay,steel_angles.phiy,
                               steel_angles.thetaz,steel_angles.phiz);
      steelWriter << steelRow;
      //cout << "SteelPln "; steelRow.Print();  //rwh

      // UgliDbiSteelPln is aggregated by plane #, so we're done with it.
      bool steelSuccess = steelWriter.Close();
      if (!steelSuccess) 
         MSG("Ugli",Msg::kWarning) 
            << "Failed to write to temporary table." << endl;

      bool doscint = true;
      // now do the scintillator plane and sub components
      if (cover == PlaneCoverage::kNoActive) doscint = false;
      if (cover == PlaneCoverage::kUnknown ) doscint = false;
      if ( noinfo && !caldet0 ) doscint = false;
      
      // one more weird case for actives ... not being a scint plane
      TString aname = RerootExodus::ActvPlaneName(rr_scint);
      if ( aname[0] != 'F' && aname[0] != 'M' && !caldet0 ) doscint = false;

      if (doscint) {
        Float_t x0scint_rel = scintpos->XYActv()[0]*Munits::cm - x0steel;
        Float_t y0scint_rel = scintpos->XYActv()[1]*Munits::cm - y0steel;

        // angle of scint relative to steel in the plane of the steel
        angles_t scint_angles = gminos_angles[(int)view];
        
        Float_t zrot = scint_angles.phix - steel_angles.phix;
        
        // create a ScintPln row, store it in the writer
        UgliDbiScintPln plnRow(scintplnid,scint_thick,gap,
                               x0scint_rel,y0scint_rel, zrot);
        plnWriter << plnRow;
        //cout << "ScintPln "; plnRow.Print();
        
        // use the UgliDbiScintPlnStruct and UgliDbiScintMdlStruct tables
        // to tell us the number of modules/plane and strip range in a module
        VldContext vldc = RerootExodus::BuildVldContext();
        DbiResultPtr<UgliDbiScintPlnStruct> plnStructTable(vldc);
        DbiResultPtr<UgliDbiScintMdlStruct> mdlStructTable(vldc);
        
        unsigned int pln_indx = UgliDbiStructHash(scintplnid).HashAsPlane();
        const UgliDbiScintPlnStruct* plnStruct = 
                                      plnStructTable.GetRowByIndex(pln_indx);
        
        // loop over the modules in the plane
        for (short mdl = 0; mdl<plnStruct->GetNModules(); mdl++) {
          
          PlexScintMdlId scintmdlid(scintplnid,mdl);
          unsigned int mdl_indx = 
                       UgliDbiStructHash(scintmdlid).HashAsScintMdl();
          const UgliDbiScintMdlStruct* mdlStruct = 
                       mdlStructTable.GetRowByIndex(mdl_indx);
          
          int first = mdlStruct->GetFirstStrip();
          int last  = mdlStruct->GetLastStrip();
          
          Float_t sum_clrA =0, sum_clrB = 0, sum_tpos = 0;
          Float_t tposFirst=9999., tposLast=-9999.;
          Int_t   nstrips=0, nstripA=0, nstripB=0;
          
          // loop over the strips in the module, for determining module params
          for (short istrip = first; istrip <= last; istrip++) {
            PlexStripEndId seid(scintplnid,istrip);
            REROOT_CellPos *cellpos = RerootExodus::GetCellPos(seid);
            
            const Float_t maxclr = 10.0 * Munits::m;
            Float_t clrA = cellpos->ClearFiberA() * Munits::cm;
            if (clrA < maxclr) { sum_clrA += clrA; nstripA++; }
            Float_t clrB = cellpos->ClearFiberB() * Munits::cm;
            if (clrB < maxclr) { sum_clrB += clrB; nstripB++; }
            
            // cellpos->XYZCenter()[1] "y" measures tpos  ... sort of
            // use function so we don't worry about the V flip
            Float_t tpos = RerootExodus::SEIdToTPos(seid) * Munits::cm; 
            sum_tpos += tpos;
            nstrips++;
            if (istrip == first) tposFirst = tpos;
            if (istrip == last)  tposLast  = tpos;
            
            
          } // loop over strips in module
          
          // all strips in a module should have the same clear fiber length
          // alas there's a mismatch between where GMINOS had modules
          // and where the real detector does 
          // (the clear lengths followed reality, GMINOS had fixed
          //  modules of 24 strips) ... take the average
         
          if (nstripA<=0||sum_clrA<=0.0) {nstripA=1; sum_clrA=99.99*Munits::m;}
          if (nstripB<=0||sum_clrB<=0.0) {nstripB=1; sum_clrB=99.99*Munits::m;}
          Float_t clear_east, clear_west;
          ABtoEastWest(sum_clrA/nstripA,sum_clrB/nstripB,
                       scintplnid,aname,clear_east,clear_west);
          
          int ipln = scintplnid.GetPlane();
          if (ipln == 1 || ipln == 2 || ipln == 3 || ipln == 6 )
            MSG("Exodus",Msg::kInfo) 
              << "Module " << scintmdlid 
              << " clear E=" << clear_east << "(" << nstripA << ") "
              << " W=" << clear_west << "(" << nstripB << ") "
              << endl;
          
          // individual tpos measures the centerline of the strip
          Float_t mdl_width = TMath::Abs(tposFirst - tposLast) + cell_width;
          Float_t tpos_center = sum_tpos/nstrips;
          // modules are define to have zero lpos
          Float_t lpos_mdl = 0 * Munits::cm; 
          Float_t zrot_mdl = 0; // gminos doesn't rotate modules
          
          // create a ScintMdl row, store it in the writer
          UgliDbiScintMdl mdlRow(PlexScintMdlId(scintplnid,mdl),
                                 mdl_width,tpos_center,
                                 lpos_mdl,zrot_mdl,clear_east,clear_west);
          mdlWriter << mdlRow;
          //cout << "ScintMdl "; mdlRow.Print();
          
          // since strip info is relative to the module we have to loop again
          // loop over the strips in the module, make Strip row entries
          for (int istrip = first; istrip <= last; istrip++) {
            PlexStripEndId seid(scintplnid,istrip);
            
            // cellpos->XYZCenter()[1] "y" measures tpos  ... sort of
            // use function so we don't worry about the V flip
            Float_t tpos = 
                  RerootExodus::SEIdToTPos(seid) * Munits::cm - tpos_center;
               
            // lpos is the like average of the two ends along "x"
            Float_t lpos =
                  RerootExodus::SEIdToLPos(seid) * Munits::cm;
            
            if (vldc.GetDetector() == Detector::kNear && seid.GetPlane()<6)
              MSG("Ugli",Msg::kDebug)
                << seid.AsString("c") << " lpos " << lpos << endl;
            Float_t zrot = 0; // gminos doesn't rotate strips
            
            UgliDbiStrip stripRow(seid,tpos,lpos,zrot);
            stripWriter << stripRow;
            //cout << "Strip "; stripRow.Print();
            
          } // loop over strips in module
          
          
        } // loop over modules in plane

      } // actual scint information to write (not just VLD entry)

      // close the Mdl and Strip writers (validate and write)
      // these are aggregated by plane #, so now's the appropriate time
      bool plnSuccess   = plnWriter.Close();
      bool mdlSuccess   = mdlWriter.Close();
      bool stripSuccess = stripWriter.Close();
      
      if (! plnSuccess || ! mdlSuccess || ! stripSuccess) 
         MSG("Ugli",Msg::kWarning) 
            << "Failed to write to temporary table." << endl;
      else
        iplnLastWritten = ipln;

   } // loop over planes

   if (vldc.GetDetector() == Detector::kFar) {
     // make VLD rows (but no data) for planes that might have
     // previously existed in GMINOS but don't now.

     for (int ipln = iplnLastWritten+1; ipln<2*249; ++ipln) {
       MSG("Ugli",Msg::kInfo) 
         << "UgliGeometryReroot: fill temp position table for plane " 
         << ipln << "\r" << flush;

       Int_t aggNo    = ipln;
       
       DbiWriter<UgliDbiSteelPln> steelWriter(fVldRange,aggNo,task,now,steelDb);
       DbiWriter<UgliDbiScintPln>   plnWriter(fVldRange,aggNo,task,now,plnDb);
       DbiWriter<UgliDbiScintMdl>   mdlWriter(fVldRange,aggNo,task,now,mdlDb);
       DbiWriter<UgliDbiStrip>    stripWriter(fVldRange,aggNo,task,now,stripDb);
       
       // clear any copy that's being cached
       steelWriter.TableProxy().GetCache()->SetStale();
       plnWriter.TableProxy().GetCache()->SetStale();
       mdlWriter.TableProxy().GetCache()->SetStale();
       stripWriter.TableProxy().GetCache()->SetStale();
     
       // attach no data rows
     
       // close the writer
       if (!steelWriter.Close() || !plnWriter.Close() ||
           !mdlWriter.Close()   || !stripWriter.Close()  ) {
         MSG("Ugli",Msg::kWarning)
           << "Failed to write to temporary table." << endl;
       }
     } //loop over non-existent planes
   } // FarDet empty VLD records
      
   if (fake_scintpos) delete fake_scintpos; fake_scintpos = 0;
   if (fake_steelpos) delete fake_steelpos; fake_steelpos = 0;

   MSG("Ugli",Msg::kInfo) << endl << "temp position table filled" << endl;

}

//_____________________________________________________________________________
string UgliGeometryReroot::StandardMdlName(PlexPlaneId plnid, int module,
                                           TString& aname)
{
   // lookup the standard module name
   // (this is used for general shape info)

   Detector::Detector_t detector    = plnid.GetDetector();
   PlaneView::PlaneView_t view          = plnid.GetPlaneView();
   PlaneCoverage::PlaneCoverage_t cover = plnid.GetPlaneCoverage();

   char mchar = '?';
   char vchar = PlaneView::AsString(view)[0];

   static char scratch[32];

   switch (detector) {
      case (Detector::kNear): {
         char key = aname[0];
         if      (cover == PlaneCoverage::kNearPartial) {
//            if (module >= 3) break;
            if (module >= 4) break;  // wierd GMINOS breakup
            const char* mdl_list;
            // Q is a fake module having to do with how GMINOS
            // uses fixed 24 strip modules
//            if      ('U' == vchar) mdl_list = "IHG";
//            else if ('V' == vchar) mdl_list = "GHI";
            if (key == 'F') {
              if      ('U' == vchar) mdl_list = "qihg";
              else if ('V' == vchar) mdl_list = "ghiq";
              else break; // bad view
            }
            else {
              // 'M' planes
              if      ('U' == vchar) mdl_list = "IHG";
              else if ('V' == vchar) mdl_list = "GHI";
              else break; // bad view              
            }
            mchar = mdl_list[module];
         }
         else if (cover == PlaneCoverage::kNearFull) {
            const char* mdl_list;
            if (key == 'F') {
              if      ('U' == vchar) mdl_list = "NMLKJ";
              else if ('V' == vchar) mdl_list = "JKLMN";
              else break; // bad view
            }
            else {
              // 'M' planes
              if      ('U' == vchar) mdl_list = "NMLKJ";
              else if ('V' == vchar) mdl_list = "JKLMN";
              else break; // bad view
            }
            mchar = mdl_list[module];
         }
         break; // case kNear
      }
      case (Detector::kFar): {
         if (cover != PlaneCoverage::kComplete) break;
         if (module >= 8) break;
         const char* mdl_list;
         if      ('U' == vchar) mdl_list = "abefFEBA";
         else if ('V' == vchar) mdl_list = "abcdDCBA";
         else break; // bad view
         mchar = mdl_list[module];
         break; // case kFar
      }
      case (Detector::kCalDet): {
         if (cover != PlaneCoverage::kComplete) break;
         mchar = 'X';
         break; // case kCalDet
      }
   default:  // default to keep away the Warnings
      mchar = '?';
      break;
   }

   if ('?' == mchar) {
      char cchar = PlaneCoverage::AsString(cover)[0];
      sprintf(scratch,"%c:%c%c%2.2d",Detector::AsString(detector)[0],
              cchar,vchar,module);
   }
   else sprintf(scratch,"%c%c",mchar,vchar);

   return scratch;
}

//_____________________________________________________________________________
void UgliGeometryReroot::ABtoEastWest(Float_t a, Float_t b, 
                                      PlexPlaneId plnid, TString& aname,
                                      Float_t& east, Float_t& west)
{
   // convert an A,B pair into a East,West set
   // considering all the weirdnesses

   // use temporaries in case output == input
   Float_t tmpA = a;
   Float_t tmpB = b;

   if ( plnid.GetPlaneView() != PlaneView::kV ||     // rwh: fix 'M' plane
        plnid.GetDetector()  == Detector::kCalDet ) {
      // normal case, U and all kinds of CalDet
      east = tmpA;
      west = tmpB;
   }
   else {
     if ( aname[0] == 'F' ) {
       // old GMINOS V was swapped in direction of TPos
       // CalDet U/V were really GMINOS Y/X
       east = tmpB;
       west = tmpA;
     }
     else {
       // 'M' type planes are really 'W' rotated
       east = tmpA;
       west = tmpB;
     }
   }

}

//_____________________________________________________________________________

PLANEPOS_DEF* UgliGeometryReroot::CreateAndBackFillPlanePosDef(REROOT_PlanePos *reroot_PlanePos)
{
   // create a PLANEPOS_DEF structure from a REROOT_PlanePos object
   // (the reverse of the REROOT_PlanePos ctor)

         PLANEPOS_DEF *ppdef = new PLANEPOS_DEF;
         ppdef->ID = reroot_PlanePos->ID() + 1;              // C->F77 index
         ppdef->ISuper  = reroot_PlanePos->ISuper() + 1;     // C->F77 index
         ppdef->IModule = reroot_PlanePos->IModule() + 1;    // C->F77 index
         ppdef->InMdl   = reroot_PlanePos->InMdl() + 1;      // C->F77 index
         ppdef->PairZmin = reroot_PlanePos->PairZmin();
         ppdef->PairZmax = reroot_PlanePos->PairZmax();
         strncpy(ppdef->PasvName,reroot_PlanePos->PasvName(),4);
         ppdef->XYPasv[0] = reroot_PlanePos->XYPasv()[0];
         ppdef->XYPasv[1] = reroot_PlanePos->XYPasv()[1];
         ppdef->ZFrntPasv = reroot_PlanePos->ZFrntPasv();
         strncpy(ppdef->ActvName,reroot_PlanePos->ActvName(),4);
         ppdef->XYActv[0] = reroot_PlanePos->XYActv()[0];
         ppdef->XYActv[1] = reroot_PlanePos->XYActv()[1];
         ppdef->ZFrntActv = reroot_PlanePos->ZFrntActv();
         strncpy(ppdef->Rotm,reroot_PlanePos->Rotm(),4);
         ppdef->ActvSpec  = reroot_PlanePos->ActvSpec() + 1; // C->F77 index
         ppdef->PasvSpec  = reroot_PlanePos->PasvSpec() + 1; // C->F77 index
         ppdef->RotmID    = reroot_PlanePos->RotmID() + 1;   // C->F77 index

         return ppdef;
}

//_____________________________________________________________________________

---