UgliStripNode.cxx

Go to the documentation of this file.

// $Id: UgliStripNode.cxx,v 1.41 2007/02/04 05:04:45 rhatcher Exp $
//
// UgliStripNode
//
// UgliStripNode is handle to a single strip
//
// Author:  R. Hatcher 2000.11.15
//

#include "UgliGeometry/UgliStripNode.h"

#include "UgliGeometry/UgliGeometry.h"
#include "UgliGeometry/TGeometryX.h"
#include "UgliGeometry/UgliScintMdlNode.h"
#include "UgliGeometry/UgliScintPlnNode.h"

#include "Plex/PlexVetoShieldHack.h"

#include "MessageService/MsgService.h"
CVSID("$Id: UgliStripNode.cxx,v 1.41 2007/02/04 05:04:45 rhatcher Exp $");

#include "TMath.h"

#ifdef UGLI_USE_EXODUS
#include "RerootExodus/RerootExodus.h"
#include "REROOT_Classes/REROOT_CellPos.h"
int isABside(PlaneView::PlaneView_t view, StripEnd::StripEnd_t end) {
// determine if GMINOS A side (0) or B side (1)
// don't call this with end other than kEast or kWest
// return 2 if non-sensical
   
   if (end != StripEnd::kEast && end != StripEnd::kWest) {
      MSG("Ugli",Msg::kWarning) 
         << "isABside view \"" << PlaneView::AsString(view) << "\" "
         << " end \"" << StripEnd::AsString(end) << "\"" << endl;
      return 2;
   }

   switch (view) {
   case PlaneView::kU: 
      return (end == StripEnd::kEast) ? 0 : 1 ;
   case PlaneView::kV: 
      return (end == StripEnd::kEast) ? 1 : 0 ;
   case PlaneView::kY: 
      return (end == StripEnd::kEast) ? 0 : 1 ;
   case PlaneView::kX: 
      return (end == StripEnd::kDown) ? 1 : 0 ;
   case PlaneView::kA: 
      return (end == StripEnd::kEast) ? 0 : 1 ;
   case PlaneView::kB: 
      return (end == StripEnd::kDown) ? 1 : 0 ;
   default:
      MSG("Ugli",Msg::kWarning) 
         << "isABside view \"" << PlaneView::AsString(view) << "\" "
         << " end \"" << StripEnd::AsString(end) << "\"" << endl;
      return 2;
   }
}
#endif

#include "UgliGeometry/UgliDbiTables.h"

#include "Conventions/Munits.h"
#include "TBRIK.h"

#include <cassert>

const Float_t huge_length = 1.0e30;
const char* noshapeName = "noshape";

ClassImp(UgliStripNode)

//_____________________________________________________________________________
#ifdef DEBUGSTUFF
// A helper function for outputting TVector3's in a convenient format
std::ostream& operator<<(std::ostream& os, const TVector3& tv3) 
{
  int prec = os.precision();
  os << "[" << setw(11) << setprecision(6) << tv3.x() 
     << "," << setw(11) << setprecision(6) << tv3.y() 
     << "," << setw(11) << setprecision(6) << tv3.z() 
     << "]";
  os << resetiosflags(ios::floatfield);  // reset to "%g" format
  os << setprecision(prec); // restore precision
  return os;
}
#endif
//_____________________________________________________________________________
UgliStripNode::UgliStripNode()
  : fUgliGeometry(0)
{
   // Default constructor (for i/o)
}

//_____________________________________________________________________________
UgliStripNode::~UgliStripNode()
{
   // destructor should delete any owned objects
   if (CountRef()) {
      MSG("Ugli",Msg::kWarning)
         << "~UgliStripNode still had " << CountRef()
         << " outstanding references " << endl;
   }
}

//_____________________________________________________________________________
UgliStripNode::UgliStripNode(const PlexStripEndId seid,
                             UgliScintMdlNode *mdlnode,
                             const UgliDbiTables& ugliTables)
   : TNodeX(seid.AsString("c"),seid.AsString("c"),noshapeName), //note below
     fUgliGeometry(mdlnode->GetUgliGeometry()), fSEId(seid)     
{
   // DBI driven ctor under UgliScintMdlNodes

   SetParent(mdlnode);

   fMirrorMask = 0;
   if (seid.GetDetector() == Detector::kNear) 
      fMirrorMask = StripEnd::kEast;

   // NOTE: we set the shape name here because seid.AsString
   // uses a static space such that having both "s" and "c"
   // options on the initialization line means we only see one
   // of the two possibilities
   fShape = fUgliGeometry->GetShape(seid.AsString("s"));

   UgliStripShape* sshape = dynamic_cast<UgliStripShape*>(fShape);
   if (!sshape) {
      gGeometry->ls("s");
      const char* name = "(nil)";
      if (fShape) name = fShape->GetName();
      MSG("Ugli",Msg::kWarning)
         << "ctor for " << seid.AsString("c") 
         << "(" << GetName() << "," << GetTitle() << ")" 
         << endl
         << "   found shape wasn't the UgliStripShape " 
         << seid.AsString("s") 
         << " instead was named " << name << endl;
   }

   unsigned int stripstruct_indx = UgliDbiStructHash(seid).HashAsStrip();
   const UgliDbiStripStruct *stripStructRow = 
      ugliTables.fStripStructTbl.GetRowByIndex(stripstruct_indx);
   int inmdl = stripStructRow->GetInModule();

   // for now some module level info lives at this level
   // since we don't have modules to ask
   const UgliDbiScintMdl *mdlRow = 
      ugliTables.GetDbiScintMdlById(PlexScintMdlId(seid,inmdl));
   if (!mdlRow) {
      MSG("Ugli",Msg::kError)
         << "UgliStripNode ctor failed to get UgliDbiScintMdl" 
         << PlexScintMdlId(seid,inmdl)
         << endl;
      return;
   }

   const UgliDbiStrip *stripRow = ugliTables.GetDbiStripById(seid);
   if (!stripRow) {
      MSG("Ugli",Msg::kError)
         << "UgliStripNode ctor failed to get UgliDbiStrip" 
         << seid
         << endl;
      return;
   }
   // for now we're positioning ourselves in the plane
   // as there are no modules
   if (mdlRow->GetZRotRelPlnDeg() != 0) 
      MSG("Ugli",Msg::kWarning)
         << " module  " << mdlRow->GetScintMdlId()
         << ", " << mdlRow->GetModule()
         << " has rotation of " << mdlRow->GetZRotRelPlnDeg()
         << " degrees, but we're not placing strip in module" << endl
         << "     rotation is effectively ignored" << endl;
   Float_t tpos = stripRow->GetTPosRelMdl();
   Float_t lpos = stripRow->GetLPosRelMdl();

   SetLTPosRelMdl(lpos,tpos);
   
   if (!seid.IsValid()) {
      static int nmsg = 20;
      if (nmsg) {
        MSG("Ugli",Msg::kInfo) 
          << "UgliStripNode::ctor: "
          << seid.AsString("c") << " @ "
          << " tpos " << tpos << " = " 
          << mdlRow->GetTPosRelPln() << " + " << stripRow->GetTPosRelMdl()
          << endl
          << "  not a valid strip: "
          << "  seid.IsValid() " << (int)seid.IsValid()
          // << ", encoded 0x" << hex << seid.GetEncoded() << dec 
          // << ", masked out plane 0x" << hex << (seid.GetEncoded()&maskPlexIdPlane) << dec 
          // << ", !=mask is " << hex << (int)((seid.GetEncoded()&maskPlexIdPlane)!=maskPlexIdPlane) << dec 
          << endl;
        nmsg--;
        if (nmsg==0) 
          MSG("Ugli",Msg::kInfo) << "  ... last message of this type." << endl;
      }
   }

   Float_t zrot = stripRow->GetZRotRelMdlRad();
   SetZRotRelMdlRad(zrot);

   SetLineColor(18);  // a nice light gray
   SetVisibility(0);  // visible
//   if (seid.GetStrip()%8 != 0) SetVisibility(0);

}

//_____________________________________________________________________________
void UgliStripNode::SetZRotRelMdlRad(Float_t radians)
{
   // set the rotation matrix for this strip
   // limit ourselves to -xx.x mrad

   // build the rotation matrices as we need them so we can share
   // if we expect a range of +/- 4cm at the furthest extreme of the far
   // theta = asin(4cm/400cm) ~ .01 rad = 10mrad
   // if we limit ourself to +/- 0.1 mrad then the smallest non-zero
   // deviation is .04cm which should be sufficient
   const float rad2mrad = 1000.;
   const float mrad2rad = 0.001;

   const char* rname = "Identity";
   char rname_mrad[16];
   if (radians != 0) {
      sprintf(rname_mrad,"%+5.1fmrad",radians*rad2mrad);
      rname = rname_mrad;
   }
   TRotMatrix* rotm = fUgliGeometry->GetRotMatrix(rname);
   if (!rotm) {
      Double_t zrot_trunc;
      sscanf(rname,"%5lf",&zrot_trunc);
      zrot_trunc *= Ugli::rad2deg * mrad2rad;
      MSG("Ugli",Msg::kDebug) 
         << "UgliStripNode::SetZRotRelMdlRad no rotm '" 
         << rname << "' zrot = " 
         << zrot_trunc << " deg" << endl;
      Double_t deg90 = 90;
      rotm = new TRotMatrix(rname,rname,deg90,zrot_trunc,deg90,
                            zrot_trunc+deg90,0,0);
   }
   fMatrix = rotm;
}

//_____________________________________________________________________________

void UgliStripNode::IncrementRef()
{
   fRef++; 
   fUgliGeometry->IncrementRef();
//   cout << fSEId.AsString("c") << " ++ ref to " << fRef << endl;
   SetVisibility(1);
}

void UgliStripNode::DecrementRef()
{ 
   fRef--; 
   fUgliGeometry->DecrementRef();
//   cout << fSEId.AsString("c") << " -- ref to " << fRef 
//        << ( (!fRef) ? " make invisible" : " " ) << endl;
   if (!fRef) SetVisibility(0);
}

//_____________________________________________________________________________
Float_t UgliStripNode::GetHalfLength() const
{ 
   // get the strip's half length
   TBRIK* brik = dynamic_cast<TBRIK*>(fShape);
   if (brik) return brik->GetDx(); else return 0;
}

//_____________________________________________________________________________
Float_t UgliStripNode::GetHalfThickness() const
{ 
   // get the strip's half length
   TBRIK* brik = dynamic_cast<TBRIK*>(fShape);
   if (brik) return brik->GetDz(); else return 0;
}

//_____________________________________________________________________________
Float_t UgliStripNode::GetHalfWidth() const
{ 
   // get the strip's half length
   TBRIK* brik = dynamic_cast<TBRIK*>(fShape);
   if (brik) return brik->GetDy(); else return 0;
}
//_____________________________________________________________________________
Float_t UgliStripNode::GetTPos(Float_t orthCoord) const
{ 
   // get the strip's tpos offset
   // orthCoord is the position in the orthogonal view, this allows one to
   // include rotation corrections.
   // if orthCoord>1000 use the center of the strip

   PlaneView::PlaneView_t view = fSEId.GetPlaneView();
   bool viewIsUV = PlaneView::kU==view || PlaneView::kV==view;
   Detector::Detector_t detector = fSEId.GetDetector();

   const Double_t rsqrt2 = 1.0/TMath::Sqrt(2.);
   const TVector3 dir_x(1.,0.,0.);
   const TVector3 dir_y(0.,1.,0.);
   const TVector3 dir_u(rsqrt2,rsqrt2,0.);
   const TVector3 dir_v(-rsqrt2,rsqrt2,0.);
   const TVector3 dir_u_caldet(1.,0.,0.);
   const TVector3 dir_v_caldet(0.,1.,0.);
   const TVector3 dir_a(0.,0.,1.);
   const TVector3 dir_b(1.,0.,0.);

   TVector3 dir_tpos, dir_orthCoord;

   switch (view) {
   case PlaneView::kX:
     dir_tpos = dir_x; dir_orthCoord = dir_y;
     break;
   case PlaneView::kY:
     dir_tpos = dir_y; dir_orthCoord = dir_x;
     break;
   case PlaneView::kU:
     if (Detector::kCalib != detector) {
       dir_tpos = dir_u; dir_orthCoord = dir_v;
     } else {
       dir_tpos = dir_u_caldet; dir_orthCoord = dir_v_caldet;
     }
     break;
   case PlaneView::kV:
     if (Detector::kCalib != detector) {
       dir_tpos = dir_v; dir_orthCoord = dir_u;
     } else {
       dir_tpos = dir_v_caldet; dir_orthCoord = dir_u_caldet;
     }
     break;
   case PlaneView::kA:
     dir_tpos = dir_a;
     break;
   case PlaneView::kB:
     dir_tpos = dir_b;
     break;
   case PlaneView::kVSTopFlat:
   case PlaneView::kVSTopEastSlant:
   case PlaneView::kVSTopWestSlant:
   case PlaneView::kVSWallOnEdge:
   case PlaneView::kVSWallEastSlant:
   case PlaneView::kVSWallWestSlant:
     MSG("Ugli",Msg::kError)
       << "UgliStripNode::GetTPos() not meaningful for veto shield strips "
       << fSEId << endl;
     return huge_length;
     break;
   default:
      MSG("Ugli",Msg::kWarning)
         << "UgliStripNode::GetTPos unknown view " 
         << PlaneView::AsString(fSEId.GetPlaneView())
         << " in " << fSEId
         << endl;
      return huge_length;
   }

   //cout << " " << fSEId.AsString("c");

   Float_t alongLength = 0.0;  // for wild orthCoord choose *strip* center
   if (orthCoord < 1000. && viewIsUV) {
     // orthCoord is sensible and we're a U or V plane
     // so we need to translate that orthogonal position
     // into a position along the strip in order to do rotation corrections

     TVector3 gstrip_center  = GlobalPos(0.,kFALSE);
     TVector3 gstrip_plusend = GlobalPos(1.,kFALSE);
     TVector3 gstrip_dir = gstrip_plusend - gstrip_center;

     TVector3 tpos_base = orthCoord * dir_orthCoord;
     Double_t z = this->GetScintMdlNode()->GetScintPlnNode()->GetZ0();
     tpos_base.SetZ(z);

     // aliases, just 'cause it's easier to translate the formula
     TVector3& base_s = gstrip_center;
     TVector3& dir_s  = gstrip_dir;
     TVector3& base_t = tpos_base;
     TVector3& dir_t  = dir_tpos;
     
     TVector3 txs  = dir_t.Cross(dir_s);
     TVector3 dpst = base_s - base_t;
     TVector3 dpxs = dpst.Cross(dir_s);
     Float_t  t    = dpxs.Dot(txs) / txs.Mag2();

     return t;

     /* 
        // the unnecessarily hard way ...
        TVector3 sxt  = dir_s.Cross(dir_t);
        TVector3 dpts = base_t - base_s;
        TVector3 dpxt = dpts.Cross(dir_t);
        Float_t  s    = dpxt.Dot(sxt) / sxt.Mag2();
        
        alongLength  = s;
     */

   }
   TVector3 globalpos = GlobalPos(alongLength,kFALSE);
   //return   globalpos.Dot(dir_tpos);
   Float_t tpos = globalpos.Dot(dir_tpos);
   //cout << " return " << tpos << endl;
   return  tpos;
}

//_____________________________________________________________________________
Float_t UgliStripNode::TotalAttenuation(const StripEnd::StripEnd_t /* end */,
                                        const Float_t /* alongLength */) const
{ 
   // get the attenuation from some point towards pixel at one end
   MSG("Ugli",Msg::kFatal)
      << "UgliStripNode::GetTotalAttenuation not yet implemented" << endl;
   return 0;
}

//_____________________________________________________________________________
TVector3 UgliStripNode::GlobalPos(const Float_t alongLength,
                                  const Bool_t onWLS) const
{ 
   // get the position based on distance along centerline *or* WLS fiber
   // global position is assumed to be in XYZ (hall) coordinates

   if (onWLS) {
      MSG("Ugli",Msg::kFatal)
         << "UgliStripNode::GlobalPos not yet implemented with onWLS=kTRUE" << endl;
      return LocalToGlobal(TVector3(alongLength,0.,0.));
   } else {
      return LocalToGlobal(TVector3(alongLength,0.,0.));
   }
}

//_____________________________________________________________________________
TVector3 UgliStripNode::GlobalToLocal(const TVector3& global) const
{ 
   // get the local position based on global position
   // global position is assumed to be in XYZ (hall) coordinates

   Double_t gxyz[3], lxyz[3];

   gxyz[0] = global.X();
   gxyz[1] = global.Y();
   gxyz[2] = global.Z();

   // deal with fact that TNode::Master2Local isn't declared const
   UgliStripNode* self = const_cast<UgliStripNode*>(this);
   self->cd();
   self->UpdateMatrix();
   self->Master2Local(gxyz,lxyz);

   return TVector3(lxyz[0],lxyz[1],lxyz[2]);
}

//_____________________________________________________________________________
TVector3 UgliStripNode::LocalToGlobal(const TVector3& local) const
{ 
   // get the global position based on local position
   // global position is assumed to be in XYZ (hall) coordinates

   Double_t gxyz[3], lxyz[3];

   lxyz[0] = local.X();
   lxyz[1] = local.Y();
   lxyz[2] = local.Z();

   // deal with fact that TNode::Local2Master isn't declared const
   UgliStripNode* self = const_cast<UgliStripNode*>(this);
   self->cd();
   self->UpdateMatrix();
   self->Local2Master(lxyz,gxyz);

   return TVector3(gxyz[0],gxyz[1],gxyz[2]);
}

//_____________________________________________________________________________
Float_t UgliStripNode::DistanceAlong(const PlexStripEndId& orthogonalStrip) const
{ 
   // Get the distance along a strip represented by orthogonal strip.
   // Note this is relative to the strip's local co-ordinate system
   // origin (which for NearDet is not along the U or V axis), so
   // one can use it for attenuation corrections but not directly
   // for TPos position information.
  
   // The closest approach ponts on the "s" and "t" lines are:
   //    xyz_t(i) = base_t(i) + t*dir_t(i) for i=0..2 {x,y,z} 
   //    xyz_o(i) = base_o(i) + o*dir_o(i) for i=0..2 {x,y,z}
   // where base_x is  LocalToGlobal(TVector3(0,0,0))
   // and   dir_x  is (LocalToGlobal(TVector3(1,0,0))-base_x)
   //
   // Finding the intersection or closest appraoch of two skew lines
   // algorithm was adapted from:
   //   Graphic Gems, ed. Andrew S. Glassner, pg 304
   //   ISBN 0-12-286165-5   T385.G697(1990)
   //
   const Double_t farAway = 1.0e25;

   UgliStripNode* otherNode = GetUgliGeometry()->GetStripNode(orthogonalStrip);

   if ( ! otherNode ) {
     MSG("Ugli",Msg::kError)
       << "UgliStripNode::DistanceAlong(), other strip " 
       << orthogonalStrip << " does not exist" << endl;
     return farAway;
   }
   
   // s=this, t=other
   TVector3 baseThis  = this->GlobalPos(0.,false);
   TVector3 dirThis   = this->GlobalPos(1.,false) - baseThis;
   
   TVector3 baseOther = otherNode->GlobalPos(0.,false);
   TVector3 dirOther  = otherNode->GlobalPos(1.,false) - baseOther;
   
   TVector3 dirCross  = dirThis.Cross(dirOther);
   Double_t vxvm2 = dirCross.Mag2();
   if (0.0 == vxvm2) {
     // exactly parallel strips!
     return farAway;
   }
   
   TVector3 dp   = baseOther - baseThis;
   TVector3 dpxv = dp.Cross(dirOther);
   Double_t s = dpxv.Dot(dirCross) / vxvm2;
   
   return s;   
}

//_____________________________________________________________________________
TVector3 UgliStripNode::Intersection(const PlexStripEndId& orthogonalStrip) const
{ 
   // get the 3-space "intersection" of two strips

   // The closest approach ponts on the "s" and "t" lines are:
   //    xyz_t(i) = base_t(i) + t*dir_t(i) for i=0..2 {x,y,z} 
   //    xyz_o(i) = base_o(i) + o*dir_o(i) for i=0..2 {x,y,z}
   // where base_x is  LocalToGlobal(TVector3(0,0,0))
   // and   dir_x  is (LocalToGlobal(TVector3(1,0,0))-base_x)
   //
   // Finding the intersection or closest appraoch of two skew lines
   // algorithm was adapted from:
   //   Graphic Gems, ed. Andrew S. Glassner, pg 304
   //   ISBN 0-12-286165-5   T385.G697(1990)
   //
   const Double_t farAway = 1.0e25;
   const TVector3 farAway3(farAway,farAway,farAway);

   UgliStripNode* otherNode = GetUgliGeometry()->GetStripNode(orthogonalStrip);
   
   if ( ! otherNode ) {
     MSG("Ugli",Msg::kError)
       << "UgliStripNode::Intersection() other strip " 
       << orthogonalStrip << " does not exist" << endl;
     return farAway3;
   }
   
   // s=this, t=other
   TVector3 baseThis  = this->GlobalPos(0.,false);
   TVector3 dirThis   = this->GlobalPos(1.,false) - baseThis;
   
   TVector3 baseOther = otherNode->GlobalPos(0.,false);
   TVector3 dirOther  = otherNode->GlobalPos(1.,false) - baseOther;
   
   TVector3 dirCross  = dirThis.Cross(dirOther);
   Double_t vxvm2 = dirCross.Mag2();
   if (0.0 == vxvm2) {
     // Exactly parallel strips!
     return 0.5*(baseThis+baseOther) + farAway*dirThis;
   }
   
   TVector3 dp   = baseOther - baseThis;
   TVector3 dpxvThis = dp.Cross(dirOther);
   Double_t s = dpxvThis.Dot(dirCross) / vxvm2;
   
   TVector3 thisPoint = baseThis + s*dirThis;

   dirCross *= -1;
   dp       *= -1;
   TVector3 dpxvOther = dp.Cross(dirThis);
   Double_t t = dpxvOther.Dot(dirCross) / vxvm2;

   TVector3 otherPoint = baseOther + t*dirOther;

   return 0.5*(thisPoint+otherPoint);
}

//_____________________________________________________________________________
Float_t UgliStripNode::PartialLength(const StripEnd::StripEnd_t end) const
{
   // return the (total) length of one of the parts of a split strip
   // (if strip is not split return total length regardless of end)

   // this is, to be proper, info of the strip shape
   UgliStripShape* strip_shape = GetUgliStripShape();

   if (strip_shape) {

      switch (end) {
      case StripEnd::kNegative: 
      case StripEnd::kPositive: 
         return strip_shape->GetLenPart(end);
         break;
      default: return huge_length;
      }
   }
   
   MSG("Ugli",Msg::kWarning) << "PartialLength() " << endl
      << "  shape isn't a UgliStripShape" << endl;

   // fake up a context from the range
   VldContext vldc = BackConstructVldContext();

   DbiResultPtr<UgliDbiStripStruct> stripStructTbl(vldc);
   unsigned int stripstruct_indx = UgliDbiStructHash(fSEId).HashAsStrip();
   const UgliDbiStripStruct *stripStructRow = 
      stripStructTbl.GetRowByIndex(stripstruct_indx);

   if (stripStructRow) {
      switch (end) {
      case StripEnd::kEast: 
         return stripStructRow->GetLenEastPart();
         break;
      case StripEnd::kWest: 
         return stripStructRow->GetLenWestPart();
          break;
      default: return huge_length;
      }
   } 

   MSG("Ugli",Msg::kWarning) 
     << " PartialLength() missing UgliDbiStripStruct" << endl;
   return huge_length;

}

//_____________________________________________________________________________
Float_t UgliStripNode::WlsPigtail(const StripEnd::StripEnd_t end) const
{
   // return the length of the WLS pigtail

   // this is, to be proper, info of the strip shape
   UgliStripShape* strip_shape = GetUgliStripShape();
   UgliScintMdlNode* mdl = dynamic_cast<UgliScintMdlNode*>(fParent);

   if (strip_shape && mdl) {

      switch (end) {
      case StripEnd::kNegative: 
      case StripEnd::kPositive: 
         return 
            strip_shape->GetWls(end) + 
            mdl->GetExtraWlsFiber(end);
         break;
      default: return huge_length;
      }
   }
   
   MSG("Ugli",Msg::kWarning) << "WlsPigtail() " << endl
      << "  shape isn't a UgliStripShape or parent isn't a UgliScintMdlNode" << endl;

   // fake up a context from the range
   VldContext vldc = BackConstructVldContext();

   DbiResultPtr<UgliDbiStripStruct> stripStructTbl(vldc);
   unsigned int stripstruct_indx = UgliDbiStructHash(fSEId).HashAsStrip();
   const UgliDbiStripStruct *stripStructRow = 
      stripStructTbl.GetRowByIndex(stripstruct_indx);
   int inmdl = stripStructRow->GetInModule();

   DbiResultPtr<UgliDbiScintMdl> mdlTbl(vldc);
   int mdl_indx = UgliDbiScintMdl::HashToIndex(PlexScintMdlId(fSEId,inmdl));
   const UgliDbiScintMdl *mdlRow = mdlTbl.GetRowByIndex(mdl_indx);

   if (stripStructRow && mdlRow) {
      switch (end) {
      case StripEnd::kEast: 
         return 
            stripStructRow->GetWlsLenEast() +
            mdlRow->GetWlsLenEast();
         break;
      case StripEnd::kWest: 
         return 
            stripStructRow->GetWlsLenWest() +
            mdlRow->GetWlsLenWest();
         break;
      default: return huge_length;
      }
   } 
#ifdef UGLI_USE_EXODUS
   else if (fUgliGeometry->GetVldRange().GetSimMask() & SimFlag::kReroot) {

      REROOT_CellPos *cellpos = RerootExodus::GetCellPos(fSEId);
      if (!cellpos) {
         MSG("Ugli",Msg::kWarning) 
            << "No CellPos for " << fSEId.AsString() << endl;
         return huge_length;
      }

      Float_t fWlsPigtail[3];
      fWlsPigtail[0] = cellpos->FiberTailA() * Munits::cm;
      fWlsPigtail[1] = cellpos->FiberTailB() * Munits::cm;
      fWlsPigtail[2] = huge_length;
      PlaneView::PlaneView_t view = fSEId.GetPlaneView();

      return fWlsPigtail[isABside(view,end)];
      
   }
#endif
   MSG("Ugli",Msg::kWarning) 
     << " WlsPigtail() missing info: " << endl
     << "     stripStructRow " << stripStructRow
     << " MdlRow " << mdlRow << endl;
   return huge_length;

}

//_____________________________________________________________________________
Float_t UgliStripNode::WlsBypass() const
{
   // return the length of the WLS of the central bypass

   // this is, to be proper, info of the strip shape
   UgliStripShape* strip_shape = GetUgliStripShape();

   if (strip_shape) return strip_shape->GetWlsLenBypass();
   
   MSG("Ugli",Msg::kWarning) << "WlsBypass() " << endl
      << "  shape isn't a UgliStripShape" << endl;

   // fake up a context from the range
   VldContext vldc = BackConstructVldContext();

   DbiResultPtr<UgliDbiStripStruct> stripStructTbl(vldc);
   unsigned int stripstruct_indx = UgliDbiStructHash(fSEId).HashAsStrip();
   const UgliDbiStripStruct *stripStructRow = 
      stripStructTbl.GetRowByIndex(stripstruct_indx);

   if (stripStructRow) return stripStructRow->GetWlsLenBypass();

   MSG("Ugli",Msg::kWarning) 
     << " WlsBypass() missing UgliDbiStripStruct " << endl;

   return 0.0;

}

//_____________________________________________________________________________
Float_t UgliStripNode::ClearFiber(const StripEnd::StripEnd_t end) const
{

   UgliScintMdlNode* mdl = dynamic_cast<UgliScintMdlNode*>(fParent);

   if (mdl) return mdl->GetClearFiber(end);
      
   MSG("Ugli",Msg::kWarning) << "ClearFiber() " << endl
                             << "  parent isn't a UgliScintMdlNode" << endl;

   // fake up a context from the range
   VldContext vldc = BackConstructVldContext();

   DbiResultPtr<UgliDbiStripStruct> stripStructTbl(vldc);
   unsigned int stripstruct_indx = UgliDbiStructHash(fSEId).HashAsStrip();
   const UgliDbiStripStruct *stripStructRow = 
      stripStructTbl.GetRowByIndex(stripstruct_indx);
   int inmdl = stripStructRow->GetInModule();

   DbiResultPtr<UgliDbiScintMdl> mdlTbl(vldc);
   int mdl_indx = UgliDbiScintMdl::HashToIndex(PlexScintMdlId(fSEId,inmdl));
   const UgliDbiScintMdl *mdlRow = mdlTbl.GetRowByIndex(mdl_indx);

   if (mdlRow) {
      switch (end) {
      case StripEnd::kEast: return mdlRow->GetClearLenEast(); break;
      case StripEnd::kWest: return mdlRow->GetClearLenWest(); break;
      default: return huge_length;
      }
   }
#ifdef UGLI_USE_EXODUS
   else if (fUgliGeometry->GetVldRange().GetSimMask() & SimFlag::kReroot) {

      REROOT_CellPos *cellpos = RerootExodus::GetCellPos(fSEId);
      if (!cellpos) {
         MSG("Ugli",Msg::kWarning) 
            << "No CellPos for " << fSEId.AsString() << endl;
         return huge_length;
      }

      Float_t fClearFiber[3];
      fClearFiber[0] = cellpos->ClearFiberA() * Munits::cm;
      fClearFiber[1] = cellpos->ClearFiberB() * Munits::cm;
      fClearFiber[2] = huge_length;
      PlaneView::PlaneView_t view = fSEId.GetPlaneView();

      return fClearFiber[isABside(view,end)];

   }
#endif
   MSG("Ugli",Msg::kWarning) 
     << " ClearFiber() missing info:  MdlRow " << mdlRow << endl;
   return huge_length;

}

//_____________________________________________________________________________
VldContext UgliStripNode::BackConstructVldContext() const
{
   // build a fake VldContext from the VldRange
   // so we can access the DBI

   VldRange vrng = fUgliGeometry->GetVldRange();
   int det = vrng.GetDetectorMask();
   int sim = vrng.GetSimMask();
   // trim "det" and "sim" down to single bit
   for (int i=0; i<32; ++i) {
      int bit = 1<<i;
      if (det&bit) det=bit;
      if (sim&bit) sim=bit;
   }
   
   return VldContext((Detector::Detector_t)det,
                     (SimFlag::SimFlag_t)sim,
                     vrng.GetTimeStart());

}

//_____________________________________________________________________________
// inlining this causes circular dependencies

//inline 
UgliScintMdlNode* UgliStripNode::GetScintMdlNode(void) const
{  return dynamic_cast<UgliScintMdlNode*>(fParent); }

//_____________________________________________________________________________

---