UgliSteelPlnNode.cxx

Go to the documentation of this file.

// $Id: UgliSteelPlnNode.cxx,v 1.26 2006/06/27 20:08:23 rhatcher Exp $
//
// UgliSteelPlnNode
//
// UgliSteelPlnNode is a single steel plane
//
// Author:  R. Hatcher 2000.11.15
//

#include "UgliGeometry/UgliSteelPlnNode.h"

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

#include "UgliGeometry/MinosOutline.h"
#include "UgliGeometry/UgliDbiTables.h"
#ifdef UGLI_USE_EXODUS
#include "RerootExodus/RerootExodus.h"
#endif

#include "Conventions/Munits.h"

#include "TBRIK.h"
#include "TVector3.h"

#include "MessageService/MsgService.h"
CVSID("$Id: UgliSteelPlnNode.cxx,v 1.26 2006/06/27 20:08:23 rhatcher Exp $");

#include <cassert>

ClassImp(UgliSteelPlnNode)

//_____________________________________________________________________________
UgliSteelPlnNode::UgliSteelPlnNode()
  : UgliPlnNode()
{
   // Default constructor (for i/o)
}

//______________________________________________________________________________
UgliSteelPlnNode::~UgliSteelPlnNode()
{
   // destructor should delete any owned objects
#ifdef DUPLICATE_WARNING
   // this check is done in the base ~UgliPlnNode()
   if (CountRef()) {
      MSG("Ugli",Msg::kWarning)
        << "~UgliSteelPlnNode " << GetPlexPlaneId()
        << " still had " << CountRef()
        << " outstanding references " << endl;
   }
#endif
}

//_____________________________________________________________________________
UgliSteelPlnNode::UgliSteelPlnNode(UgliGeometry *ugliGeometry,
                                   const PlexPlaneId planeid)
   : UgliPlnNode(ugliGeometry,planeid)
{
   // ctor that old REROOT-basaed UgliGeometry uses in constructing

   static Int_t nwarn = 2;

   if (nwarn > 0 ) {
      MSG("Ugli",Msg::kInfo) 
         << "UgliSteelPlnNode::ctor " 
         << "    " << planeid.AsString("p") 
         << "... needs DBI interface" << endl;
      nwarn--;
   }

   TGeometryX* fRootGeom = fUgliGeometry->GetTGeometryX();

   // assign the correct shape to this node
   // build an appropriate shape if necessary
   const char *shapename = "nshape";
   bool hasEars = true;
   if (!planeid.IsSteel()) {
      // this shouldn't be ...
      MSG("Ugli",Msg::kWarning) 
         << "UgliSteelPlnNode::ctor saw Scint PlaneId "
         << planeid.AsString() << endl;
   }
   switch (planeid.GetDetector()) {
   case Detector::kFar:
      shapename = "FarSteel";
      break;
   case Detector::kNear:
      shapename = "NearSteel";
      break;
   case Detector::kCalib:
      shapename = "CalDetSteel";
      break;
   default:
      shapename = "noshape";
      break;
   }

   MinosOutline* the_shape =
      dynamic_cast<MinosOutline*>(fRootGeom->GetShape(shapename));
   if ( ! the_shape ) {
      MSG("Ugli",Msg::kInfo)
         << "UgliSteelPlnNode ctor creating shape " << shapename << endl;
      Float_t halfthick  = 0.5 * 2.54 * Munits::cm;

      if (nwarn > 0 ) {
         MSG("Ugli",Msg::kDebug) 
            << "UgliSteelPlnNode::ctor kludge plane thickness" << endl;
         nwarn--;
      }

      the_shape = new MinosOutline(shapename,shapename,"void",
                                   planeid,hasEars,halfthick,1.);
   }
   fShape = the_shape;  // assign TNode member the correct shape

   // position and orient the shape correctly
   TNode* hallnode = fRootGeom->GetNode("hall");
   hallnode->cd();
   hallnode->UpdateMatrix();

   SetParent(hallnode);

   Float_t global[3], local[3];
   if (fUgliGeometry->GetVldRange().GetSimMask() & SimFlag::kReroot) {
#ifdef UGLI_USE_EXODUS
      RerootExodus::RerootPlaneXYZ0(planeid,global);
      global[0] *= Munits::cm;
      global[1] *= Munits::cm;
      global[2] *= Munits::cm;
#else
      static int nmsg = 5;
      if (nmsg-- > 0) 
         MSG("Ugli",Msg::kWarning) 
            << " steelpln positioning code must go here" << endl;
      assert(0);
#endif
   }

   Float_t x0shift = the_shape->GetGlobalXOffset() * Munits::cm;

   hallnode->Master2Local(global,local);
   
   SetPosition(local[0]+x0shift,local[1],local[2]);

   SetVisibility(0);
}

//_____________________________________________________________________________
UgliSteelPlnNode::UgliSteelPlnNode(const PlexPlaneId planeid,
                                   UgliGeometry *ugliGeometry,
                                   const UgliDbiTables& ugliTables)
   : UgliPlnNode(ugliGeometry,planeid)
{
   // ctor for DBI driven UgliGeometry

   // expand the x-y size of the enclosing box 
   // just so we can see which is which
   // changing scale mucks up the global x shift
   Float_t xyscale_box = 1.0;
   Float_t xyscale_stl = 1.0;
   // set this ~100 to expand z coordinate
   Float_t bombz = 1.; // 100.;
   
   bool hasEars = true;

   //
   // build the enclosing box of steel (+ scint)
   //
   char boxname[16], stlname[16];
   sprintf(boxname,"%s",planeid.AsString("b"));  // dNNNBvc
   sprintf(stlname,"%s",planeid.AsString("p"));  // dNNNPvc
   if (planeid.IsVetoShield()) stlname[4] = 'P'; // force 'P'-ness

   UInt_t ipln = planeid.GetPlane();
   const UgliDbiSteelPln* steelRow = ugliTables.GetDbiSteelPlnByIndex(ipln);
   if (!steelRow) {
     MSG("Ugli",Msg::kError) 
       << " no UgliDbiSteelPln entry for " << planeid << endl;
     return;
   }

   Float_t dzbox = 0.5 * steelRow->GetTotalZ() *bombz; // box z half size
   MinosOutline *box_outline = 
      new MinosOutline(boxname,boxname,"void",planeid,hasEars,dzbox,xyscale_box);

   // additional shift due to near detector weirdness
//no!   Float_t x0shift = xyscale_box * box_outline->GetGlobalXOffset();

   Float_t x0pln = steelRow->GetX0(); // no! +x0shift;
   Float_t y0pln = steelRow->GetY0();
   Float_t zback = steelRow->GetZBack();
   Float_t z0box = zback*bombz - dzbox;
         
   TRotMatrix *box_rotm =
      new TRotMatrix(boxname,boxname,
                  steelRow->GetThetaDeg(0),steelRow->GetPhiDeg(0),
                  steelRow->GetThetaDeg(1),steelRow->GetPhiDeg(1),
                  steelRow->GetThetaDeg(2),steelRow->GetPhiDeg(2));

   // the current working node should already be the hall
   TNode* hall_node = fUgliGeometry->GetTGeometryX()->GetCurrentNode();
   if ( !hall_node || strcmp("hall",hall_node->GetName()) ) {
      MSG("Ugli",Msg::kWarning) 
         << "UgliSteelPlnNode " << planeid
         << " ctor didn't start in the \"hall\" node: " 
         << hall_node->GetName()
         << endl;
      hall_node = fUgliGeometry->GetTNodeX("hall");
      if (!hall_node) {
         MSG("Ugli",Msg::kError) 
            << "UgliSteelPlnNode ctor found the \"hall\" node wasn't a TNodeX"
            << endl;
         return;
      }
      hall_node->cd();
   }

   // go inside the hall and place the containing box
   Float_t x0hall = hall_node->GetX();
   Float_t y0hall = hall_node->GetY();
   Float_t z0hall = hall_node->GetZ();
   TNodeX* box_node =
      new TNodeX(boxname,boxname,box_outline,
                 x0pln-x0hall,y0pln-y0hall,z0box-z0hall,box_rotm);

   box_node->SetLineColor(41); // a ghostly beige

   MSG("Ugli",Msg::kVerbose) << " create specific steel outline" << endl;

   // the actual steel plane gets put in the box
   // with no additional shifts or rotations
   // except that it gets shoved to the back (+z) of the box
   Float_t hthick = 0.5 * steelRow->GetThickness() *bombz;
   Float_t zshift_stl = dzbox - hthick;
   // build and attach the appropriate shape
   fShape = new MinosOutline(stlname,stlname,"steel",planeid,
                             hasEars,hthick,xyscale_stl);

   // parent was initialized by ctor ... we need to set it into the box
   SetParent(box_node);    // modified version in TNodeX needed
   SetPosition(0,0,zshift_stl);
   // by default,if no name supplied, it's built with the Identity matrix 
   // SetMatrix(fUgliGeometry->GetRotMatrix("Identity"))
   SetLineColor(50);   // kind of rusty color

   int box_vis = 1; // ?? 0 ??
   int stl_vis = 1; // ?? 0 ??
   box_node->SetVisibility(box_vis); 
   this->SetVisibility(stl_vis);

   // map "local" (steel) [0,0,zback] to global position
   TVector3 current = LocalToGlobal(TVector3(0,0,hthick)); 
   // adjust box position to make (x0,y0,zback) where it should be
   // this was easy when there were only U,V planes
   box_node->SetPosition(box_node->GetX()+x0pln-current.X(),
                         box_node->GetY()+y0pln-current.Y(),
                         box_node->GetZ()+zback-current.Z());

}

//_____________________________________________________________________________

void UgliSteelPlnNode::IncrementRef()
{
   fRef++; 
   fUgliGeometry->IncrementRef();
   SetVisibility(1);
}

void UgliSteelPlnNode::DecrementRef()
{ 
   fRef--; 
   fUgliGeometry->DecrementRef();
   if (!fRef) SetVisibility(0);
}

//_____________________________________________________________________________
void UgliSteelPlnNode::TransformLocal2Global(Double_t *lxyz, Double_t *gxyz) const
{
   // deal with fact that TNode::Master2Local isn't declared const
   UgliSteelPlnNode* self = const_cast<UgliSteelPlnNode*>(this);
   self->cd();
   self->UpdateMatrix();
   self->Local2Master(lxyz,gxyz);
}

//_____________________________________________________________________________
Float_t UgliSteelPlnNode::GetHalfThickness() const
{

   TBRIK *brik = dynamic_cast<TBRIK*>(fShape);
   if (brik) return brik->GetDz();

   TXTRU *xtru = dynamic_cast<TXTRU*>(fShape);
   if (xtru) {
      Int_t    nz = xtru->GetNz();
      Float_t* fz = xtru->GetZ();
      return 0.5*TMath::Abs(fz[0]-fz[nz-1]);
   }

   MSG("Ugli",Msg::kError) <<
      "UgliSteelPlnNode::GetHalfThickness: not a BRIK or TXTRU" << endl;

   return 0;
}

//_____________________________________________________________________________
TVector3 UgliSteelPlnNode::GetCenter() const
{
   Double_t lxyz[3] = {0., 0., 0.};
   Double_t gxyz[3];

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

//_____________________________________________________________________________
Float_t UgliSteelPlnNode::GetX0() const
{
   Double_t lxyz[3] = {0., 0., 0.};
   Double_t gxyz[3];

   TransformLocal2Global(lxyz,gxyz);
   return gxyz[0];
}

//_____________________________________________________________________________
Float_t UgliSteelPlnNode::GetY0() const
{
   Double_t lxyz[3] = {0., 0., 0.};
   Double_t gxyz[3];

   TransformLocal2Global(lxyz,gxyz);
   return gxyz[1];
}

//_____________________________________________________________________________
Float_t UgliSteelPlnNode::GetZ0() const
{
   Double_t lxyz[3] = {0., 0., 0.};
   Double_t gxyz[3];

   TransformLocal2Global(lxyz,gxyz);
   return gxyz[2];
}

//_____________________________________________________________________________
TVector3 UgliSteelPlnNode::GlobalToLocal(const TVector3& global) const
{ 
   // get the local position based on global position

   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
   UgliSteelPlnNode* self = const_cast<UgliSteelPlnNode*>(this);
   self->cd();
   self->UpdateMatrix();
   self->Master2Local(gxyz,lxyz);

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

//_____________________________________________________________________________
TVector3 UgliSteelPlnNode::LocalToGlobal(const TVector3& local) const
{ 
   // get the global position based on local position

   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
   UgliSteelPlnNode* self = const_cast<UgliSteelPlnNode*>(this);
   self->cd();
   self->UpdateMatrix();
   self->Local2Master(lxyz,gxyz);

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

//_____________________________________________________________________________
TVector3 UgliSteelPlnNode::GlobalToLocalVect(const TVector3& global) const
{ 
   // get the local direction based on global direction

   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
   UgliSteelPlnNode* self = const_cast<UgliSteelPlnNode*>(this);
   self->cd();
   self->UpdateMatrixVect();
   self->Master2LocalVect(gxyz,lxyz);

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

//_____________________________________________________________________________
TVector3 UgliSteelPlnNode::LocalToGlobalVect(const TVector3& local) const
{ 
   // get the global direction based on local direction

   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
   UgliSteelPlnNode* self = const_cast<UgliSteelPlnNode*>(this);
   self->cd();
   self->UpdateMatrixVect();
   self->Local2MasterVect(lxyz,gxyz);

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

//_____________________________________________________________________________

---