PlexScintMdlId.cxx

Go to the documentation of this file.

// $Id: PlexScintMdlId.cxx,v 1.13 2005/08/26 18:47:04 rhatcher Exp $
//
// PlexScintMdlId
//
// PlexScintMdlId encapsulates scint module encoding
//
// Author:  R. Hatcher 2002.06.26
//

#include "Plex/PlexScintMdlId.h"

#include <iostream>
#include <iomanip>
#include <string>

#ifndef CASSERT
#include <cassert>
#define CASSERT
#endif

#include "MessageService/MsgService.h"
CVSID("$Id: PlexScintMdlId.cxx,v 1.13 2005/08/26 18:47:04 rhatcher Exp $");

ClassImp(PlexScintMdlId)

//_____________________________________________________________________________
//
// This (private) code deals with describing the configuration
// of strips in modules on various plane types.   In particular
// for the near detector there are 4 plane types {full,partial}x{U,V}
// are are quite distinct.  We need this for describing the module
// type (or "shape") and how many strips there are in a module --
// these help us in AsString() and StripToScintMdl().
//

class ModulesInPlnInfo {
public:
  ModulesInPlnInfo(Detector::Detector_t detector, 
                   PlaneCoverage::PlaneCoverage_t coverage,
                   PlaneView::PlaneView_t view, 
                   UChar_t nmdl, const UChar_t* mdltype);
  ~ModulesInPlnInfo();

  UChar_t GetNumStripsInPln()    { return fNumStrips; }
  UChar_t GetNumScintMdlsInPln() { return fNumMdls; }
  UChar_t MdlType(UChar_t mdl);
  UChar_t StripToMdl(UChar_t strip);
  UChar_t StripToStripInMdl(UChar_t strip);
  UChar_t StripToMapperStrip(UChar_t strip);

  void    BoundsErrorMsg(UChar_t asked, UChar_t last, const char* what="?");

  static UChar_t NumStripsInType(UChar_t mdltype);
  
  Detector::Detector_t        fDetector;
  PlaneCoverage::PlaneCoverage_t  fCoverage;
  PlaneView::PlaneView_t          fView;
  
  UChar_t                         fNumMdls;
  UChar_t                         fNumStrips;
  
  UChar_t*                        fMdlType;            //[fNumMdls]
  UChar_t*                        fStripsPerMdl;       //[fNumMdls]
  UChar_t*                        fFirstStripInMdl;    //[fNumMdls]
  UChar_t*                        fLastStripInMdl;     //[fNumMdls]
  UChar_t*                        fStripToMdl;         //[fNumStrips]
  UChar_t*                        fStripToStripInMdl;  //[fNumStrips]
  UChar_t*                        fStripToMapperStrip; //[fNumStrips]
};

ModulesInPlnInfo::ModulesInPlnInfo(Detector::Detector_t detector, 
                                   PlaneCoverage::PlaneCoverage_t coverage,
                                   PlaneView::PlaneView_t view, 
                                   UChar_t nmdl, const UChar_t* mdltype) 
  : fDetector(detector), fCoverage(coverage), fView(view), 
    fNumMdls(nmdl), fNumStrips(0), fMdlType(0),
    fStripsPerMdl(0), fFirstStripInMdl(0), fLastStripInMdl(0), 
    fStripToMdl(0), fStripToStripInMdl(0), fStripToMapperStrip(0)
{
  // if no modules just return
  if (fNumMdls==0) return; 
  
  fMdlType         = new UChar_t [fNumMdls];
  fStripsPerMdl    = new UChar_t [fNumMdls];
  fFirstStripInMdl = new UChar_t [fNumMdls];
  fLastStripInMdl  = new UChar_t [fNumMdls];
  // copy types to owned array, translate type to strip count
  // calculate total # of strips, last strip in each module
  for (UChar_t imdl=0; imdl<fNumMdls; ++imdl) {
    UChar_t nstripsInMdl   = NumStripsInType(mdltype[imdl]);
    fNumStrips            += nstripsInMdl;
    fMdlType[imdl]         = mdltype[imdl];
    fStripsPerMdl[imdl]    = nstripsInMdl;
    fFirstStripInMdl[imdl] = fNumStrips-nstripsInMdl;
    fLastStripInMdl[imdl]  = fNumStrips-1;
  }
  
  fStripToMdl         = new UChar_t [fNumStrips];
  fStripToStripInMdl  = new UChar_t [fNumStrips];
  fStripToMapperStrip = new UChar_t [fNumStrips];
  // calculate mapping from strip to module
  for (UChar_t istrip=0; istrip<fNumStrips; ++istrip) {
    // find the right module
    UChar_t mdl = 0;
    while (istrip > fLastStripInMdl[mdl]) ++mdl;

    fStripToMdl[istrip] = mdl;
    UChar_t stripinmdl = istrip - fFirstStripInMdl[mdl];
    UChar_t nstrips    = fStripsPerMdl[mdl];
    fStripToStripInMdl[istrip]  = stripinmdl;
    // upper/lower case tells us about mapper convention
    // upper case ordering is same, but starts with 1
    // lower case ordering is reversed and ends with 1
    fStripToMapperStrip[istrip] = 
      ( (isupper(fMdlType[mdl]) ) ? stripinmdl+1 : nstrips-stripinmdl );
  }
}

ModulesInPlnInfo::~ModulesInPlnInfo() { 
  // delete any and all owned arrays
  if (fMdlType)            delete [] fMdlType;
  if (fStripsPerMdl)       delete [] fStripsPerMdl;
  if (fFirstStripInMdl)    delete [] fFirstStripInMdl;
  if (fLastStripInMdl)     delete [] fLastStripInMdl;
  if (fStripToMdl)         delete [] fStripToMdl;
  if (fStripToStripInMdl)  delete [] fStripToStripInMdl;
  if (fStripToMapperStrip) delete [] fStripToMapperStrip;
}

UChar_t ModulesInPlnInfo::MdlType(UChar_t mdl) 
{
  if (mdl<fNumMdls) return fMdlType[mdl];
  static int nmsg = 10;
  if (--nmsg >= 0) BoundsErrorMsg(mdl,fNumMdls-1,"module");
  return '?';
}

UChar_t ModulesInPlnInfo::StripToMdl(UChar_t strip) 
{
  if (strip<fNumStrips) return fStripToMdl[strip];
  static int nmsg = 10;
  if (--nmsg >= 0) BoundsErrorMsg(strip,fNumStrips-1,"strip");
  return 0xff;
}

UChar_t ModulesInPlnInfo::StripToStripInMdl(UChar_t strip) 
{
  if (strip<fNumStrips) return fStripToStripInMdl[strip];
  static int nmsg = 10;
  if (--nmsg >= 0) BoundsErrorMsg(strip,fNumStrips-1,"strip");
  return 0xff;
}

UChar_t ModulesInPlnInfo::StripToMapperStrip(UChar_t strip) 
{
  if (strip<fNumStrips) return fStripToMapperStrip[strip];
  static int nmsg = 10;
  if (--nmsg >= 0) BoundsErrorMsg(strip,fNumStrips-1,"strip");
  return 0xff;
}

void ModulesInPlnInfo::BoundsErrorMsg(UChar_t asked, UChar_t last, const char* what)
{
  MSG("Plex",Msg::kWarning)
    << what << " " << (int)asked << " in {"
    << " " << Detector::AsString(fDetector)
    << " " << PlaneCoverage::AsString(fCoverage)
    << " " << PlaneView::AsString(fView)
    << "} is beyond last " << what << ": "
    << (int)last << endl;
}

UChar_t ModulesInPlnInfo::NumStripsInType(UChar_t mdltype)
{
  // module types are characterized by a single char
  // though actual shapes may also depend on plane view
  // (esp. in the case of the near detector).  For the
  // far detector case distinguishes between those installed
  // one way or rotated 180deg in the z plane.

  UChar_t mdltypeUpper = toupper(mdltype);

  switch (mdltypeUpper) {
    // far detector types
  case 'A': return 28;
  case 'B': return 28;
  case 'C': return 20;
  case 'D': return 20;
  case 'E': return 20;
  case 'F': return 20;
    // near detector partial types
  case 'G': return 28;
  case 'H': return 20;
  case 'I': return 20;
    // near detector full types
  case 'J': return 28;
  case 'K': return 20;
  case 'L': return 16;
  case 'M': return 16;
  case 'N': return 16;
    // caldet types
  case 'X': return 24;
  default:
    MSG("Plex",Msg::kWarning)
      << " no module type '" << mdltype 
      << "' (0x" << hex << setw(2) << (int)mdltype << dec 
      << ") defined" << endl;
  }
  return 0;
}

// this is the description of the module type in each kind of plane
// case convention tells us which way this is installed relative to
// what the mapper calls strip 1: lower case means mapper strip "1" 
// is actually at the larger 'tpos' position.
const UChar_t farU[]      = { 'a','b','e','f','F','E','B','A' };
const UChar_t farV[]      = { 'a','b','c','d','D','C','B','A' };
const UChar_t nearfullU[] = { 'n','m','l','K','J'};
const UChar_t nearfullV[] = { 'j','k','L','M','N'};
const UChar_t nearpartU[] = { 'i','H','G'};
const UChar_t nearpartV[] = { 'g','h','I'};
const UChar_t caldetU[] = { 'X' };  // this is unchecked
const UChar_t caldetV[] = { 'X' };  // this is unchecked
const UChar_t caldetB[] = { 'X' };  // this is unchecked

const UChar_t veto_c[] = { 'c' };
const UChar_t veto_C[] = { 'C' };
const UChar_t veto_e[] = { 'e' };
const UChar_t veto_E[] = { 'E' };


// some shorthand notations
const Detector::Detector_t isfar            = Detector::kFar;
const Detector::Detector_t isnear           = Detector::kNear;
const Detector::Detector_t iscaldet         = Detector::kCalDet;
const PlaneCoverage::PlaneCoverage_t iscomplete = PlaneCoverage::kComplete;
const PlaneCoverage::PlaneCoverage_t isnearfull = PlaneCoverage::kNearFull;
const PlaneCoverage::PlaneCoverage_t isnearpart = PlaneCoverage::kNearPartial;
const PlaneView::PlaneView_t isU                = PlaneView::kU;
const PlaneView::PlaneView_t isV                = PlaneView::kV;
const PlaneView::PlaneView_t isB                = PlaneView::kB;

const PlaneCoverage::PlaneCoverage_t isVScN = PlaneCoverage::kVScN;
const PlaneCoverage::PlaneCoverage_t isVSCN = PlaneCoverage::kVSCN;
const PlaneCoverage::PlaneCoverage_t isVSeS = PlaneCoverage::kVSeS;
const PlaneCoverage::PlaneCoverage_t isVSES = PlaneCoverage::kVSES;
const PlaneCoverage::PlaneCoverage_t isVScS = PlaneCoverage::kVScS;
const PlaneCoverage::PlaneCoverage_t isVSCS = PlaneCoverage::kVSCS;
const PlaneCoverage::PlaneCoverage_t isVSeN = PlaneCoverage::kVSeN;
const PlaneCoverage::PlaneCoverage_t isVSEN = PlaneCoverage::kVSEN;

const PlaneView::PlaneView_t isTopFlat       = PlaneView::kVSTopFlat;
const PlaneView::PlaneView_t isTopEastSlant  = PlaneView::kVSTopEastSlant;
const PlaneView::PlaneView_t isTopWestSlant  = PlaneView::kVSTopWestSlant;
const PlaneView::PlaneView_t isWallOnEdge    = PlaneView::kVSWallOnEdge;
const PlaneView::PlaneView_t isWallEastSlant = PlaneView::kVSWallEastSlant;
const PlaneView::PlaneView_t isWallWestSlant = PlaneView::kVSWallWestSlant;


// This structure serves as a mini-database of the configurations

static ModulesInPlnInfo gModulesInPlnInfoList[] = {
  ModulesInPlnInfo(isfar,iscomplete,isU,sizeof(farU),farU),
  ModulesInPlnInfo(isfar,iscomplete,isV,sizeof(farV),farV),
  ModulesInPlnInfo(isnear,isnearfull,isU,sizeof(nearfullU),nearfullU),
  ModulesInPlnInfo(isnear,isnearfull,isV,sizeof(nearfullV),nearfullV),
  ModulesInPlnInfo(isnear,isnearpart,isU,sizeof(nearpartU),nearpartU),
  ModulesInPlnInfo(isnear,isnearpart,isV,sizeof(nearpartV),nearpartV),
  ModulesInPlnInfo(iscaldet,iscomplete,isU,sizeof(caldetU),caldetU),
  ModulesInPlnInfo(iscaldet,iscomplete,isV,sizeof(caldetV),caldetV),
  ModulesInPlnInfo(iscaldet,iscomplete,isB,sizeof(caldetB),caldetB),
  // veto shield (only those truly expressed in placement)
  ModulesInPlnInfo(isfar,isVScN,isTopFlat      ,1,veto_c),
  ModulesInPlnInfo(isfar,isVSCN,isTopFlat      ,1,veto_C),
  ModulesInPlnInfo(isfar,isVSeS,isTopFlat      ,1,veto_e),
  ModulesInPlnInfo(isfar,isVSES,isTopFlat      ,1,veto_E),
  ModulesInPlnInfo(isfar,isVSCN,isTopEastSlant ,1,veto_C),
  ModulesInPlnInfo(isfar,isVSeS,isTopWestSlant ,1,veto_e),
  // veto shield (speculative until installed)
  ModulesInPlnInfo(isfar,isVSeS,isWallOnEdge   ,1,veto_e),
  ModulesInPlnInfo(isfar,isVSES,isWallOnEdge   ,1,veto_E), //??
  ModulesInPlnInfo(isfar,isVSeS,isWallEastSlant,1,veto_e),
  ModulesInPlnInfo(isfar,isVSeS,isWallWestSlant,1,veto_e),
  ModulesInPlnInfo(isfar,isVSCN,isWallOnEdge   ,1,veto_C),
  // veto shield all possible alternatives (some redundant w/ above)
  ModulesInPlnInfo(isfar,isVScN,isTopFlat      ,1,veto_c),
  ModulesInPlnInfo(isfar,isVSCN,isTopFlat      ,1,veto_C),
  ModulesInPlnInfo(isfar,isVSeS,isTopFlat      ,1,veto_e),
  ModulesInPlnInfo(isfar,isVSES,isTopFlat      ,1,veto_E),
  ModulesInPlnInfo(isfar,isVScS,isTopFlat      ,1,veto_c),
  ModulesInPlnInfo(isfar,isVSCS,isTopFlat      ,1,veto_C),
  ModulesInPlnInfo(isfar,isVSeN,isTopFlat      ,1,veto_e),
  ModulesInPlnInfo(isfar,isVSEN,isTopFlat      ,1,veto_E),

  ModulesInPlnInfo(isfar,isVScN,isTopEastSlant      ,1,veto_c),
  ModulesInPlnInfo(isfar,isVSCN,isTopEastSlant      ,1,veto_C),
  ModulesInPlnInfo(isfar,isVSeS,isTopEastSlant      ,1,veto_e),
  ModulesInPlnInfo(isfar,isVSES,isTopEastSlant      ,1,veto_E),
  ModulesInPlnInfo(isfar,isVScS,isTopEastSlant      ,1,veto_c),
  ModulesInPlnInfo(isfar,isVSCS,isTopEastSlant      ,1,veto_C),
  ModulesInPlnInfo(isfar,isVSeN,isTopEastSlant      ,1,veto_e),
  ModulesInPlnInfo(isfar,isVSEN,isTopEastSlant      ,1,veto_E),

  ModulesInPlnInfo(isfar,isVScN,isTopWestSlant      ,1,veto_c),
  ModulesInPlnInfo(isfar,isVSCN,isTopWestSlant      ,1,veto_C),
  ModulesInPlnInfo(isfar,isVSeS,isTopWestSlant      ,1,veto_e),
  ModulesInPlnInfo(isfar,isVSES,isTopWestSlant      ,1,veto_E),
  ModulesInPlnInfo(isfar,isVScS,isTopWestSlant      ,1,veto_c),
  ModulesInPlnInfo(isfar,isVSCS,isTopWestSlant      ,1,veto_C),
  ModulesInPlnInfo(isfar,isVSeN,isTopWestSlant      ,1,veto_e),
  ModulesInPlnInfo(isfar,isVSEN,isTopWestSlant      ,1,veto_E),

  ModulesInPlnInfo(isfar,isVScN,isWallOnEdge      ,1,veto_c),
  ModulesInPlnInfo(isfar,isVSCN,isWallOnEdge      ,1,veto_C),
  ModulesInPlnInfo(isfar,isVSeS,isWallOnEdge      ,1,veto_e),
  ModulesInPlnInfo(isfar,isVSES,isWallOnEdge      ,1,veto_E),
  ModulesInPlnInfo(isfar,isVScS,isWallOnEdge      ,1,veto_c),
  ModulesInPlnInfo(isfar,isVSCS,isWallOnEdge      ,1,veto_C),
  ModulesInPlnInfo(isfar,isVSeN,isWallOnEdge      ,1,veto_e),
  ModulesInPlnInfo(isfar,isVSEN,isWallOnEdge      ,1,veto_E),

  ModulesInPlnInfo(isfar,isVScN,isWallEastSlant      ,1,veto_c),
  ModulesInPlnInfo(isfar,isVSCN,isWallEastSlant      ,1,veto_C),
  ModulesInPlnInfo(isfar,isVSeS,isWallEastSlant      ,1,veto_e),
  ModulesInPlnInfo(isfar,isVSES,isWallEastSlant      ,1,veto_E),
  ModulesInPlnInfo(isfar,isVScS,isWallEastSlant      ,1,veto_c),
  ModulesInPlnInfo(isfar,isVSCS,isWallEastSlant      ,1,veto_C),
  ModulesInPlnInfo(isfar,isVSeN,isWallEastSlant      ,1,veto_e),
  ModulesInPlnInfo(isfar,isVSEN,isWallEastSlant      ,1,veto_E),

  ModulesInPlnInfo(isfar,isVScN,isWallWestSlant      ,1,veto_c),
  ModulesInPlnInfo(isfar,isVSCN,isWallWestSlant      ,1,veto_C),
  ModulesInPlnInfo(isfar,isVSeS,isWallWestSlant      ,1,veto_e),
  ModulesInPlnInfo(isfar,isVSES,isWallWestSlant      ,1,veto_E),
  ModulesInPlnInfo(isfar,isVScS,isWallWestSlant      ,1,veto_c),
  ModulesInPlnInfo(isfar,isVSCS,isWallWestSlant      ,1,veto_C),
  ModulesInPlnInfo(isfar,isVSeN,isWallWestSlant      ,1,veto_e),
  ModulesInPlnInfo(isfar,isVSEN,isWallWestSlant      ,1,veto_E)

};

static int gNumModulesInPlnInfoList = 
               sizeof(gModulesInPlnInfoList)/sizeof(ModulesInPlnInfo);

// a utility function for picking the right entry based on
// detector, coverage, and view
ModulesInPlnInfo* getModulesInPlnInfo(const PlexPlaneId& plnid,
                                      const char* whence = "") 
{
  Detector::Detector_t       detector = plnid.GetDetector();
  PlaneCoverage::PlaneCoverage_t coverage = plnid.GetPlaneCoverage();
  PlaneView::PlaneView_t         view     = plnid.GetPlaneView();

  for (int indx=0; indx<gNumModulesInPlnInfoList; ++indx) {
    ModulesInPlnInfo *oneModulesInPlnInfo = gModulesInPlnInfoList+indx;
    if (oneModulesInPlnInfo->fDetector == detector &&
        oneModulesInPlnInfo->fCoverage == coverage &&
        oneModulesInPlnInfo->fView     == view        ) 
      // this one matches
      return oneModulesInPlnInfo;
  }
  // no matches
  if (!whence) whence = "unknown callee";
  MSG("Plex",Msg::kError)
    << "no match for pln="
    << plnid.GetPlane() << " {" 
    << " " << Detector::AsString(detector)
    << " " << PlaneCoverage::AsString(coverage)
    << " " << PlaneView::AsString(view)
    <<  "} used by " << whence
    << endl;
  return 0;

}

//_____________________________________________________________________________
std::ostream& operator<<(std::ostream& os, const PlexScintMdlId& p)
{
   os << p.AsString();

  return os;
}

//_____________________________________________________________________________
PlexScintMdlId::PlexScintMdlId(PlexPlaneId plnid, Int_t module)
   : PlexPlaneId(plnid)
{
   // Normal ctor from PlaneId + extras

   // ensure that it isn't tagged as "steel" even if plnid was
   SetIsSteel(kFALSE);

   // because the "PlexPlaneId" passed in could actually be
   // a PlexStripEndId we might have subpart & end bits set
   // which we need to reset to the default that PlexPlaneId
   // would set them to

   const UInt_t maskLower = 
     defaultPlexScintMdlId & (maskPlexIdSubPart|maskPlexIdEnd);
   fEncoded |= maskLower;

   SetModule(module);

}

//_____________________________________________________________________________
PlexScintMdlId::PlexScintMdlId(Detector::Detector_t detector,
                               Int_t plane, Int_t module,
                               PlaneView::PlaneView_t view,
                               PlaneCoverage::PlaneCoverage_t coverage)

   : PlexPlaneId(detector,plane,kFALSE,view,coverage)
{
   // Normal ctor from all components

   SetModule(module);
}

//==========================================================================
// Implementation details 
//==========================================================================

//inline 
Bool_t operator< (const PlexScintMdlId &lhs, const PlexScintMdlId &rhs)
{ return lhs.fEncoded <  rhs.fEncoded; }

Bool_t operator<=(const PlexScintMdlId &lhs, const PlexScintMdlId &rhs)
{ return lhs.fEncoded <= rhs.fEncoded; }

//inline 
Bool_t operator==(const PlexScintMdlId &lhs, const PlexScintMdlId &rhs)
{ return lhs.fEncoded == rhs.fEncoded; }

//inline 
Bool_t operator!=(const PlexScintMdlId &lhs, const PlexScintMdlId &rhs)
{ return lhs.fEncoded != rhs.fEncoded; }

Bool_t operator> (const PlexScintMdlId &lhs, const PlexScintMdlId &rhs)
{ return lhs.fEncoded >  rhs.fEncoded; }

Bool_t operator>=(const PlexScintMdlId &lhs, const PlexScintMdlId &rhs)
{ return lhs.fEncoded >= rhs.fEncoded; }

//inline 
UShort_t PlexScintMdlId::GetModule() const
{
   return ( fEncoded & maskPlexIdScintMdl ) >> shftPlexIdScintMdl;
}

//inline 
void PlexScintMdlId::SetModule(UInt_t module)
{
   fEncoded = ( fEncoded & ~maskPlexIdScintMdl ) | 
      ( ( module << shftPlexIdScintMdl ) & maskPlexIdScintMdl );
}

//____________________________________________________________________________
const char * PlexScintMdlId::AsString(Option_t *option) const
{
   // Return unpacked StripEndId as a string
   // User should copy result because it points to a 
   // statically allocated string.
   // Internally uses a circular list of buffers to avoid problems
   // using AsString multiple times in a cout-like situation.

   const int nbuffers = 8;   // use a circular list of strings
   static char newstring[nbuffers][27]; // = "|123456789|1234 VX|123|SE|";
      //                                      12345678901234567890123456
   static int  ibuffer = nbuffers;
   ibuffer = (ibuffer+1)%nbuffers;  // each time move to next buffer

   int mdl = GetModule();
   
   Detector::Detector_t det = GetDetector();
   PlaneCoverage::PlaneCoverage_t cover = GetPlaneCoverage();
   PlaneView::PlaneView_t view = GetPlaneView();

   ModulesInPlnInfo* plninfo = getModulesInPlnInfo(*this,"AsString");
   UChar_t mdltype = ((plninfo) ? plninfo->MdlType(mdl) : '?');
   
   switch (option[0]) {
   case 's':
      // only the part the defines the "shape"
      sprintf(newstring[ibuffer],"%c%c-%c%c(%1d)",
              Detector::AsString(det)[0],
              PlaneCoverage::AsString(cover)[0],
              mdltype,
              PlaneView::AsString(view)[0],
              mdl);
      break;
   default:
      // compact rendering identifying whole module (including plane)
      sprintf(newstring[ibuffer],"%c%4.4d-%1.1d-%c%c%c",
              Detector::AsString(det)[0],
              GetPlane(),
              mdl,
              PlaneCoverage::AsString(cover)[0],
              PlaneView::AsString(view)[0],
              mdltype);

      break;
   }
   
   return newstring[ibuffer];
}

//_____________________________________________________________________________
UChar_t PlexScintMdlId::GetModuleType() const
{
   ModulesInPlnInfo* plninfo = getModulesInPlnInfo(*this,"GetModuleType");
   int mdl = GetModule();
   UChar_t mdltype = ((plninfo) ? plninfo->MdlType(mdl) : '?');
   return mdltype;
}

//_____________________________________________________________________________
Int_t PlexScintMdlId::BuildPlnMdlKey() const
{
   // compactified plane,module
   // packed tightly, not simple bit shifts

   // this isn't quite as tight as it could possibly be for the
   // near detector as it doesn't worry about partial vs. full planes
   // and has gaps for empty spectrometer planes 

   Int_t plane = GetPlane();
   Int_t mdl   = GetModule();
   Detector::Detector_t det = GetDetector();

   Int_t nMdls = 8;  // need some default
   switch (det) {
   case Detector::kNear:   nMdls =  8; break;
   case Detector::kFar:    nMdls =  8; break;
   case Detector::kCalDet: nMdls =  8; break;
   default:
      MSG("Plex",Msg::kWarning)
         << "PlexScintMdlId " << *this << " is not Near/Far/CalDet" << endl;
   }

   if (mdl>=nMdls) 
      MSG("Plex",Msg::kWarning)
         << "PlexScintMdlId " << *this 
         << " exceeds expected nMdls " << nMdls << endl;

   Int_t hvalue = plane*nMdls + mdl;

   return hvalue;
}

//_____________________________________________________________________________
PlexScintMdlId PlexScintMdlId::UnbuildPlnMdlKey(Detector::Detector_t det, 
                                                Int_t key)
{
   // recover true id object from hashed down version
   // needs detector info that was lost in compactification

   Int_t nMdls = 8;  // need some default
   switch (det) {
   case Detector::kNear:   nMdls =  8; break;
   case Detector::kFar:    nMdls =  8; break;
   case Detector::kCalDet: nMdls =  8; break;
   default:
      MSG("Plex",Msg::kWarning)
        << "PlexScintMdlId " << Detector::AsString(det) 
        << "(" << (int)det << ")"
        << " is not Near/Far/CalDet" << endl;
   }
   Int_t plane = key / nMdls;
   Int_t mdl   = key - (plane*nMdls);
   PlexPlaneId plnid(det,plane);
   return PlexScintMdlId(plnid,mdl);
}

//_____________________________________________________________________________
void PlexScintMdlId::Print(Option_t *option) const
{
   // Print the (decoded) value

   printf("%s\n",AsString(option));
}

//_____________________________________________________________________________
PlexScintMdlId PlexScintMdlId::StripToScintMdl(const PlexPlaneId& plnid, 
                                               Int_t strip)
{
   // given a plane and a strip figure out which module it is in

   ModulesInPlnInfo* plninfo = getModulesInPlnInfo(plnid,"StripToScintMdl");
   if (plninfo) return PlexScintMdlId(plnid,plninfo->StripToMdl(strip));

   // should this return a completely bogus scint module id
   // or just one with a bogus mdl # set within it?
   return PlexScintMdlId();
}

//_____________________________________________________________________________
Short_t PlexScintMdlId::GetStripInMdl(const PlexPlaneId& plnid, UInt_t strip)
{
   // given a plane and a strip figure out which strip in module it is 

   ModulesInPlnInfo* plninfo = getModulesInPlnInfo(plnid,"GetStripInMdl");
   if (plninfo) return plninfo->StripToStripInMdl(strip);

   // bogus return if nonsensical
   return -1;
}

//_____________________________________________________________________________
Short_t PlexScintMdlId::GetMapperStripInMdl(const PlexPlaneId& plnid,
                                             UInt_t strip){
   // Return an strip # within a module using construction based notation
   // starts w/ 1 .. flip flops w/ increasing 'tpos' depending on
   // installation orientation
 
   ModulesInPlnInfo* plninfo = getModulesInPlnInfo(plnid,"GetMapperStripInMdl");   if (plninfo) return plninfo->StripToMapperStrip(strip);
 
   // bogus return if nonsensical
   return -1;
}

//_____________________________________________________________________________
UShort_t PlexScintMdlId::GetNumStripsInPln(const PlexPlaneId& plnid)
{
   // use pseudo-database to determine # of strips in plane

   ModulesInPlnInfo* plninfo = getModulesInPlnInfo(plnid,"GetNumStripsInPln");
   if (plninfo) return plninfo->GetNumStripsInPln();

   // bogus return if nonsensical
   return 0;
}

//_____________________________________________________________________________
UShort_t PlexScintMdlId::GetNumScintMdlsInPln(const PlexPlaneId& plnid)
{
   // use pseudo-database to determine # of strips in plane

   ModulesInPlnInfo* plninfo = getModulesInPlnInfo(plnid,"GetNumStripsInPln");
   if (plninfo) return plninfo->GetNumScintMdlsInPln();

   // bogus return if nonsensical
   return 0;
}

//_____________________________________________________________________________

---