UgliScintPlnNode.cxx

Go to the documentation of this file.

// $Id: UgliScintPlnNode.cxx,v 1.32 2005/09/06 21:41:14 rhatcher Exp $
//
// UgliScintPlnNode
//
// UgliScintPlnNode is a single scint plane
//
// Author:  R. Hatcher 2000.11.15
//

#include "UgliGeometry/UgliScintPlnNode.h"

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

#include "UgliGeometry/MinosOutline.h"
#include "UgliGeometry/UgliDbiTables.h"
#include "UgliGeometry/UgliScintMdlNode.h"
#include "UgliGeometry/UgliStripNode.h"

#include "Conventions/Munits.h"

#include "Plex/PlexVetoShieldHack.h"

#include "TBRIK.h"

#include "MessageService/MsgService.h"
CVSID("$Id: UgliScintPlnNode.cxx,v 1.32 2005/09/06 21:41:14 rhatcher Exp $");

#include <cassert>

ClassImp(UgliScintPlnNode)

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

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

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

   // box to enclose steel + scint has already been built
   char boxname[16], plnname[16];
   sprintf(boxname,"%s",planeid.AsString("b"));  // dNNNBvc
   sprintf(plnname,"%s",planeid.AsString("p"));  // dNNNPvc


   const UgliDbiScintPln* plnRow = 
      ugliTables.GetDbiScintPlnByIndex(planeid.GetPlane());

   if (!plnRow) {
      MSG("Ugli",Msg::kError) 
         << " no UgliDbiScintPln entry for " << planeid.AsString("C")
         << endl;
      return;
   }

   // build and attach the shape we should actually have
   Float_t hthick = 0.5 * plnRow->GetThickness();
   fShape = new MinosOutline(plnname,plnname,"scint",planeid,
                             false,hthick,1.0);

   // the current working node should already be the appropriate box
   TNode* box_node = fUgliGeometry->GetTGeometryX()->GetCurrentNode();
   if ( !box_node || strcmp(boxname,box_node->GetName()) ) {
      // parent was initialized by ctor ... we need to set it into the box
      MSG("Ugli",Msg::kWarning) 
         << "UgliScintPlnNode " << planeid
         << " ctor didn't start in the right box node: " 
         << box_node->GetName()
         << endl;
      box_node = fUgliGeometry->GetTNodeX(boxname);
      if (!box_node) {
         MSG("Ugli",Msg::kError) 
            << "UgliScintPlnNode ctor found " 
            << "the containing box node wasn't a TNodeX"
            << endl;
         return;
      }
   }
   if (GetParent() != box_node) {
      MSG("Ugli",Msg::kWarning) 
         << "UgliScintPlnNode " << planeid 
         << " ctor parent wasn't the right box node" 
         << endl;
      SetParent(box_node);    // modified version in TNodeX needed
   }
   MinosOutline *box_shape = dynamic_cast<MinosOutline*>(box_node->GetShape());
   if (!box_shape) { 
      MSG("Ugli",Msg::kError) 
         << "UgliScintPlnNode ctor found " 
         << "the containing box is not a MinosOutline"
         << endl;
      return;
   }

   // set the position relative to the steel
   Float_t x0 = plnRow->GetX0RelSteel();
   Float_t y0 = plnRow->GetY0RelSteel();
   Float_t zshift_pln = hthick + box_shape->GetZ()[0];
   SetPosition(x0,y0,zshift_pln);

   // needs to build and set the right rotation matrix
   // here we only have a single rotation around z
   const Double_t deg90 = 90;
   Double_t zrot = plnRow->GetZRotRelSteelDeg();
   fMatrix = new TRotMatrix(plnname,plnname,
                            deg90,zrot,deg90,zrot+deg90,0,0);

   SetLineColor(38);   // a nice soothing blue

   // now go ahead an install all the strips
   BuildStrips(ugliTables);

}

//_____________________________________________________________________________
void UgliScintPlnNode::BuildStrips(const UgliDbiTables& ugliTables)
{
   // build all the strips in this plane using DBI

   MSG("Ugli",Msg::kDebug)
      << " BuildStrips " << fPlaneId.AsString("c") << endl;

   unsigned int pln_indx = UgliDbiStructHash(fPlaneId).HashAsPlane();
   const UgliDbiScintPlnStruct* plnStructRow = 
      ugliTables.fScintPlnStructTbl.GetRowByIndex(pln_indx);

   if (!plnStructRow) {
     unsigned int nstructrows = ugliTables.fScintPlnStructTbl.GetNumRows();
     MSG("Ugli",Msg::kError) 
       << " no UgliDbiScintPlnStruct for " << fPlaneId 
       << " hash to indx " << pln_indx 
       << ", table has " << nstructrows << endl;
     for (unsigned int i=0; i<nstructrows; ++i) {
       const UgliDbiScintPlnStruct* aRow = 
         ugliTables.fScintPlnStructTbl.GetRow(i);
       cout << " row " << i << " hash " << aRow->GetIndex(9999)
            << " " << Detector::AsString(aRow->GetDetector())
            << " view " << PlaneView::AsString(aRow->GetPlaneView())
            << " cover " << PlaneCoverage::AsString(aRow->GetPlaneCoverage())
            << endl;
     }
     abort();
   }


   // loop over the modules in the plane
   for (int imdl=0; imdl<plnStructRow->GetNModules(); imdl++) {

      this->cd();
      
      PlexScintMdlId scintmdlid(fPlaneId,imdl);
      unsigned int mdl_indx =  UgliDbiStructHash(scintmdlid).HashAsScintMdl();
      const UgliDbiScintMdlStruct* mdlStructRow =
         ugliTables.fScintMdlStructTbl.GetRowByIndex(mdl_indx);

      int first = mdlStructRow->GetFirstStrip();
      int last  = mdlStructRow->GetLastStrip();

      UgliScintMdlNode* mdlNode = 
         new UgliScintMdlNode(scintmdlid,this,ugliTables);
      mdlNode->cd();

      // loop over the strips in the module, constructing each
      for (int istrip = first; istrip <= last; istrip++) {

         PlexStripEndId seid(fPlaneId,istrip);
         fStripTable[seid] = new UgliStripNode(seid,mdlNode,ugliTables);

      } // loop over strips in module

   } // loop over modules

}
//_____________________________________________________________________________

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

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

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

   TGeometryX* fRootGeom = fUgliGeometry->GetTGeometryX();

   fRootGeom->cd();

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

   UgliScintPlnNode* the_plane = fUgliGeometry->GetScintPlnNode(geom_seid);
   if (the_plane != this) {
      string alt = " ";
      if (seid.IsVetoShield()) {
        alt = " [";
        alt += geom_seid.AsString("p");
        alt += "]";
      }
      MSG("Ugli",Msg::kFatal)
         << "UgliScintPlnNode::GetStripNode called on plane "
         << seid.AsString("p") 
         << " other than itself "
         << seid.AsString("p") << alt << endl;
   }
   the_plane->cd();

   PlexStripEndId seid_clean(geom_seid);
   // strip off any End or SubPart info when doing search
   seid_clean.SetEnd(StripEnd::kUnknown);
   seid_clean.SetSubPart(StripEnd::kWhole);
#ifdef USENODETODEPTH
   UgliStripNode* the_node = 
      dynamic_cast<UgliStripNode*>(the_plane->GetNodeToDepth(seid_clean.AsString("c"),1));
#else
   //rwh: UgliStripNode* the_node = fStripTable[seid_clean];
   UgliStripNode* the_node = 0;
   typedef std::map<PlexStripEndId,UgliStripNode*>::const_iterator stripTableItr_t;
   stripTableItr_t st_itr = fStripTable.find(seid_clean);
   if (st_itr != fStripTable.end()) the_node = st_itr->second;
#endif
   if ( ! the_node ) {
      MSG("Ugli",Msg::kError)
        << "UgliScintPlnNode::GetStripNode not possible for "
        << seid_clean.AsString() << " " << seid << endl;
      std::map<PlexStripEndId,UgliStripNode*>::const_iterator mapitr = 
        fStripTable.begin();
      while (mapitr != fStripTable.end()) {
        std::cerr << "  " << mapitr->first 
                  << " StripNode* " << mapitr->second
                  << std::endl;
        mapitr++;
      }
      assert(0);
   }
   return the_node;
}

//_____________________________________________________________________________
Int_t UgliScintPlnNode::NumberOfStrips() const
{
   // return the number of strips in the plane

   return fStripTable.size();

#ifdef HARDCODED
   // *** bad form *** hard coded value based on PlaneCoverage (and detector)

   switch (fPlaneId.GetPlaneCoverage()) {
   case PlaneCoverage::kComplete:
      switch (fPlaneId.GetDetector()) {
      case Detector::kFar:
         return 192; // 28 + 28 + 20 + 20 + 20 + 20 + 28 + 28
         break;
      case Detector::kCalib:
         return 24;  // 24
         break;
      default:
         break; // handle errors below
      }
      break;
   case PlaneCoverage::kNearFull:
      return  96;    // 28 + 20 + 16 + 16 + 16
      break;
   case PlaneCoverage::kNearPartial:
      return  68;    // 28 + 20 + 20 
      break;
   default:
      break; // handle errors below
   }

   MSG("Ugli",Msg::kError) 
      << "UgliScintPlnNode::NumberOfStrips: unknown case " 
      << fPlaneId.AsString() << endl;
   return 0;
#endif

}

//_____________________________________________________________________________
vector<UgliStripNode*> UgliScintPlnNode::GetStripNodePtrVector() const
{
   // return collection of ptrs for all strip nodes in plane

   vector<UgliStripNode*> allStrips;
   
   typedef map<PlexStripEndId,UgliStripNode*>::const_iterator nodeItr_t;
   nodeItr_t node_itr = fStripTable.begin();
   nodeItr_t node_end = fStripTable.end();
   
   while (node_itr != node_end) {
      pair<PlexStripEndId,UgliStripNode*> map_pair = *node_itr;
      allStrips.push_back(map_pair.second);
      node_itr++;
   }

   return allStrips;
}

//_____________________________________________________________________________
vector<UgliScintMdlNode*> UgliScintPlnNode::GetScintMdlNodePtrVector() const
{
   // return collection of ptrs for all scint module nodes in plane

   vector<UgliScintMdlNode*> allScintMdls;
   
   // walk the TList of nodes
   TObjLink *lnk = fNodes->FirstLink();
   while (lnk) {
      UgliScintMdlNode* mdlnode = 
        dynamic_cast<UgliScintMdlNode*>(lnk->GetObject());
      if (mdlnode) 
        allScintMdls.push_back(mdlnode);
      lnk = lnk->Next();
   }

   return allScintMdls;
}

//_____________________________________________________________________________
TVector3 UgliScintPlnNode::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
   UgliScintPlnNode* self = const_cast<UgliScintPlnNode*>(this);
   self->cd();
   self->UpdateMatrix();
   self->Master2Local(gxyz,lxyz);

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

//_____________________________________________________________________________
TVector3 UgliScintPlnNode::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
   UgliScintPlnNode* self = const_cast<UgliScintPlnNode*>(this);
   self->cd();
   self->UpdateMatrix();
   self->Local2Master(lxyz,gxyz);

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

//_____________________________________________________________________________
void UgliScintPlnNode::SetZRotRelSteelRad(Float_t radians)
{
  // set the rotation around z 
  // this matrix is specific to this scint plane so we can modify it
  Float_t zrotdeg = radians * Ugli::rad2deg;
  fMatrix->SetAngles(90,zrotdeg,90,zrotdeg+90,0,0);
}

//_____________________________________________________________________________

---