UgliScintMdlNode.cxx

Go to the documentation of this file.

// $Id: UgliScintMdlNode.cxx,v 1.14 2005/02/17 15:27:45 rhatcher Exp $
//
// UgliScintMdlNode
//
// UgliScintMdlNode is a single scint plane
//
// Author:  R. Hatcher 2000.11.15
//

#include "UgliGeometry/UgliScintMdlNode.h"

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

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

#include "Conventions/Munits.h"

#include "TBRIK.h"

#include "MessageService/MsgService.h"
CVSID("$Id: UgliScintMdlNode.cxx,v 1.14 2005/02/17 15:27:45 rhatcher Exp $");

#include <cassert>

ClassImp(UgliScintMdlNode)

//_____________________________________________________________________________
UgliScintMdlNode::UgliScintMdlNode()
  : fUgliGeometry(0)
{
   // Default constructor (for i/o)
}

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

//_____________________________________________________________________________
UgliScintMdlNode::UgliScintMdlNode(const PlexScintMdlId scintmdlid, 
                                   UgliScintPlnNode* plnNode,
                                   const UgliDbiTables& ugliTables)
   : TNodeX(scintmdlid.AsString(),scintmdlid.AsString(),"noshape"),
     fUgliGeometry(plnNode->GetUgliGeometry()),
     fScintMdlId(scintmdlid)
{
   // ctor for DBI driven UgliGeometry

   unsigned int mdlstruct_indx =
     UgliDbiStructHash(fScintMdlId).HashAsScintMdl();
   const UgliDbiScintMdlStruct* mdlStructRow =
      ugliTables.fScintMdlStructTbl.GetRowByIndex(mdlstruct_indx);

   const UgliDbiScintMdl *mdlRow = ugliTables.GetDbiScintMdlById(fScintMdlId);
   if (!mdlRow) {
     MSG("Ugli",Msg::kError)
       << "no UgliDbiScintMdl for " << fScintMdlId << endl;
     return;
   }
   fClearLenEast = mdlRow->GetClearLenEast();
   fClearLenWest = mdlRow->GetClearLenWest();
   fWlsLenEast = mdlRow->GetWlsLenEast();
   fWlsLenWest = mdlRow->GetWlsLenWest();

   // build and attach the shape we should actually have
   // for now just a box ...
   TXTRU* mdlshape = 
      new TXTRU(GetName(),mdlStructRow->GetTypeName().c_str(),
                "void",8,2);
   TXTRU* plnshape = dynamic_cast<TXTRU*>(plnNode->GetShape());
   if (!plnshape) 
     MSG("Ugli",Msg::kWarning) 
       << "UgliScintPlnNode isn't a TXTRU" << endl;
   mdlshape->DefineSection(0,plnshape->GetSectionZ(0));
   mdlshape->DefineSection(1,plnshape->GetSectionZ(1));
   Float_t width = mdlRow->GetWidth();
   SetDefaultModuleOutline(mdlshape,mdlStructRow->GetTypeName(),width);

   SetParent(plnNode);
   fShape = mdlshape;

   // set the position relative to the steel
   Float_t tpos = mdlRow->GetTPosRelPln();
   Float_t lpos = mdlRow->GetLPosRelPln();
   SetLTPosRelPln(lpos,tpos);
//   cout << " Module " << mdlStructRow->GetTypeName() << " at tpos= "
//        << tpos << " lpos = " << lpos << endl;

   // 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 = mdlRow->GetZRotRelPlnDeg();
   fMatrix = new TRotMatrix(GetName(),GetName(),
                            deg90,zrot,deg90,zrot+deg90,0,0);

   SetLineColor(41);   // beige
//   SetLineWidth(5);
   SetVisibility(0);

   // strips are installed by plane

}

//_____________________________________________________________________________
Float_t UgliScintMdlNode::GetClearFiber(const StripEnd::StripEnd_t end) const
{
   if      (end == StripEnd::kEast) return fClearLenEast;
   else if (end == StripEnd::kWest) return fClearLenWest;
   else return 0;
}

Float_t UgliScintMdlNode::GetExtraWlsFiber(const StripEnd::StripEnd_t end) const 
{
   if      (end == StripEnd::kEast) return fWlsLenEast;
   else if (end == StripEnd::kWest) return fWlsLenWest;
   else return 0;
}

//_____________________________________________________________________________

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

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

//_____________________________________________________________________________
Int_t UgliScintMdlNode::NumberOfStrips() const
{
   // return the number of strips in the module
   if (!fNodes) return 0;
   return fNodes->GetSize();
}

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

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

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

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

//_____________________________________________________________________________
void UgliScintMdlNode::SetDefaultModuleOutline(TXTRU* mdlShape,
                                               const string& typeName,
                                               const Float_t width)
{

   typedef struct basic_mdl_shape {
      string mdl_name;
      Int_t n_vtx;
      Float_t xvtx_abs[8];
      Float_t yvtx_rel[8];
   } MdlShape;

   const Float_t half = 0.5;

   const Float_t far = half * 8.000 * Munits::m;
   const Float_t as  = half * 3.464 * Munits::m;
   const Float_t al  = half * 5.738 * Munits::m;
   const Float_t bs  = half * 5.735 * Munits::m;
   const Float_t byfc = 25 * Munits::cm;
   const Float_t byft = 16 * Munits::cm;
   const Float_t byff = 6./20.;

   const Float_t swidth = 4.1 * Munits::cm;
   const Float_t glw = 109.764 * Munits::inch;
   const Float_t gsw = glw - 28*swidth;
   const Float_t g0  = swidth + half*10*swidth; // ??
   const Float_t hw  = 103.307 * Munits::inch;
   const Float_t notch = (103.307-85.551) * Munits::inch;
   const Float_t iff = 11./20.;

   const Float_t caldet = half * 1.0 * Munits::m;

   MdlShape shapelist[] = { 
      // A shapes are the same (except a->A is rotated)
      { "aU", 4, 
        {-as,as,al,-al,0,0,0,0},
        {-half,-half,half,half,0,0,0,0}
      },
      { "aV", 4, 
        {-as,as,al,-al,0,0,0,0},
        {-half,-half,half,half,0,0,0,0}
      },
      { "AU", 4, 
        {-al,al,as,-as,0,0,0,0},
        {-half,-half,half,half,0,0,0,0}
      },
      { "AV", 4, 
        {-al,al,as,-as,0,0,0,0},
        {-half,-half,half,half,0,0,0,0}
      },
      // B shapes are the same (except b->B is rotated)
      { "bU", 4, 
        {-bs,bs,far,-far,0,0,0,0},
        {-half,-half,half,half,0,0,0,0}
      },
      { "bV", 4, 
        {-bs,bs,far,-far,0,0,0,0},
        {-half,-half,half,half,0,0,0,0}
      },
      { "BU", 4, 
        {-far,far,bs,-bs,0,0,0,0},
        {-half,-half,half,half,0,0,0,0}
      },
      { "BV", 4, 
        {-far,far,bs,-bs,0,0,0,0},
        {-half,-half,half,half,0,0,0,0}
      },
      // e,E (U view) and c,C (V view) are all nice and regular
      { "eU", 4, 
        {-far,far,far,-far,0,0,0,0},
        {-half,-half,half,half,0,0,0,0}
      },
      { "EU", 4, 
        {-far,far,far,-far,0,0,0,0},
        {-half,-half,half,half,0,0,0,0}
      },
      { "cV", 4, 
        {-far,far,far,-far,0,0,0,0},
        {-half,-half,half,half,0,0,0,0}
      },
      { "CV", 4, 
        {-far,far,far,-far,0,0,0,0},
        {-half,-half,half,half,0,0,0,0}
      },
      // f,F (U view) has a bypass 
      { "fU", 8, 
        {-far,far,far,byfc,byft,-byft,-byfc,-far},
        {-half,-half,half,half,half-byff,half-byff,half,half}
      },
      { "FU", 8, 
        {-far,-byfc,-byft,byft,byfc,far,far,-far},
        {-half,-half,-half+byff,-half+byff,-half,-half,half,half}
      },
      // d,D (V view) has a bypass 
      { "dV", 8, 
        {-far,far,far,byfc,byft,-byft,-byfc,-far},
        {-half,-half,half,half,half-byff,half-byff,half,half}
      },
      { "DV", 8, 
        {-far,-byfc,-byft,byft,byfc,far,far,-far},
        {-half,-half,-half+byff,-half+byff,-half,-half,half,half}
      },
      // Near U partial (REAL Detector)
      { "GU", 4,
        {glw-g0,-g0,-g0,gsw-g0,0,0,0,0},
        {-half,-half,half,half,0,0,0,0}
      },
      { "HU", 4,
        {hw-g0,-g0,-g0,hw-g0,0,0,0,0},
        {-half,-half,half,half,0,0,0,0}
      },
      { "IU", 6,
        {hw-g0,-g0+notch,-g0+notch,-g0,hw-g0,0,0},
        {-half,-half,-half+iff,-half+iff,half,half,0,0}
      },
      // Near V partial (REAL Detector)
      { "GV", 4,
        {glw-g0,-g0,-g0,gsw-g0,0,0,0,0},
        {half,half,-half,-half,0,0,0,0}
      },
      { "HV", 4,
        {hw-g0,-g0,-g0,hw-g0,0,0,0,0},
        {half,half,-half,-half,0,0,0,0}
      },
      { "IV", 6,
        {hw-g0,-g0+notch,-g0+notch,-g0,hw-g0,0,0},
        {half,half,half-iff,half-iff,-half,-half,0,0}
      },
      // CalDet
      { "XU", 4,
        {-caldet,caldet,caldet,-caldet,0,0,0,0},
        {-half,-half,half,half,0,0,0,0}
      },
      { "XV", 4,
        {-caldet,caldet,caldet,-caldet,0,0,0,0},
        {-half,-half,half,half,0,0,0,0}
      },
      { "XA", 4,
        {-caldet,caldet,caldet,-caldet,0,0,0,0},
        {-half,-half,half,half,0,0,0,0}
      },
      { "XB", 4,
        {-caldet,caldet,caldet,-caldet,0,0,0,0},
        {-half,-half,half,half,0,0,0,0}
      },
#ifdef NOPE
      { "default", 4, 
        {-4,4,4,-4,0,0,0,0}, 
        {-half,-half,half,half,0,0,0,0}
      },
#endif
      // this makes the outline disappear
      { "default",4, {0,0,0,0,0,0,0,0}, {0,0,0,0,0,0,0,0} }
   };
 
   Int_t listsize = sizeof(shapelist)/sizeof(MdlShape);

   Bool_t hitdefault = false;
   for (int indx=0; indx<listsize; indx++) {
      MdlShape* shapeptr = shapelist + indx;
      hitdefault = (shapeptr->mdl_name == "default");
//      if (hitdefault) {
//         cout << " no shape default for modules of type " 
//              << typeName << endl;
//      }
      if (shapeptr->mdl_name == typeName || hitdefault ) {
         // use this one
         mdlShape->TruncateNxy(shapeptr->n_vtx);
         for (int i=0; i<shapeptr->n_vtx; i++) {
            mdlShape->DefineVertex(i,shapeptr->xvtx_abs[i],
                                     shapeptr->yvtx_rel[i]*width);
         }
         break; // out of loop
      }
   } // loop over list of potential shapes

}
//_____________________________________________________________________________
// inlining this causes a circular dependency

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

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

//_____________________________________________________________________________

---