PlexStripEndId.cxx

Go to the documentation of this file.

// $Id: PlexStripEndId.cxx,v 1.35 2005/08/26 18:47:04 rhatcher Exp $
//
// PlexStripEndId
//
// PlexStripEndId encapsulates strip end encoding
//
// Author:  R. Hatcher 2000.05.03
//

#include "Plex/PlexStripEndId.h"

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

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

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

ClassImp(PlexStripEndId)

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

  return os;
}

//_____________________________________________________________________________
PlexStripEndId::PlexStripEndId(PlexPlaneId plnid,
                               UInt_t strip,
                               StripEnd::StripEnd_t end,
                               StripEnd::StripEnd_t subpart)
   : PlexPlaneId(plnid)
{
   // Normal ctor from PlaneId + extras

   // ensure that it isn't tagged as "steel" even if plnid was
   // but don't do this for veto shield as we use steel bit
   // in that case for additional PlaneCoverage enums
   if (!IsVetoShield()) SetIsSteel(kFALSE);

   SetStrip(strip);
   SetEnd(end);
   SetSubPart(subpart);

}

//_____________________________________________________________________________
PlexStripEndId::PlexStripEndId(Detector::Detector_t detector,
                               UInt_t plane, UInt_t strip,
                               StripEnd::StripEnd_t end,
                               StripEnd::StripEnd_t subpart,
                               PlaneView::PlaneView_t view,
                               PlaneCoverage::PlaneCoverage_t coverage)

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

   SetStrip(strip);
   SetEnd(end);
   SetSubPart(subpart);
}

//____________________________________________________________________________
const char * PlexStripEndId::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

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

   switch (option[0]) {
   case 's':
      // only the part the defines the "shape"
      sprintf(newstring[ibuffer],"%c%c%c%3.3d",
              Detector::AsString(det)[0],
              PlaneView::AsString(view)[0],
              PlaneCoverage::AsString(cover)[0],
              GetStrip());
      break;
   case 'c':
      // compact rendering identifying whole strip info (but not end info)
      sprintf(newstring[ibuffer],"%c%4.4d%c%c%3.3d",
              Detector::AsString(det)[0],
              GetPlane(),
              PlaneView::AsString(view)[0],
              PlaneCoverage::AsString(cover)[0],
              GetStrip());
      break;
   case 'C':
      // compact rendering identifying whole strip info & end info
     sprintf(newstring[ibuffer],"%c%4.4d%c%c%3.3d%c",
             Detector::AsString(det)[0],
             GetPlane(),
             PlaneView::AsString(view)[0],
             PlaneCoverage::AsString(cover)[0],
             GetStrip(),
             StripEnd::AsString(GetEnd(),det,view)[0]);
     break;
   case 'p':
   case 'b':
      // compact rendering identifying only the plane info
      // p is for plane including one char {P,A} := {passive, active}
      // b is for "box" containing steel+scint (or steel alone if no active)
      return PlexPlaneId::AsString(option);
      break;
   default:
      // full and complete info
      sprintf(newstring[ibuffer],"[%6.6s|%4d %c%c|%3d|%c%c]",
              Detector::AsString(det),
              GetPlane(),
              PlaneView::AsString(view)[0],
              PlaneCoverage::AsString(cover)[0],
              GetStrip(),
              StripEnd::AsString(GetSubPart())[0],
              StripEnd::AsString(GetEnd(),det,view)[0]);
      break;
   }
   
   return newstring[ibuffer];
}

//_____________________________________________________________________________
PlexStripEndId PlexStripEndId::GetOppositeSEId() const
{
   // Return an Id for the opposite end

   PlexStripEndId other(fEncoded);
   StripEnd::StripEnd_t end = GetEnd();
   switch (end) {
   case StripEnd::kNegative: end = StripEnd::kPositive; break;
   case StripEnd::kPositive: end = StripEnd::kNegative; break;
   default: break;
   }
   other.SetEnd(end);
   return other;
   
}

//_____________________________________________________________________________
PlexScintMdlId PlexStripEndId::GetScintMdlId() const
{
   // Return an Id for the scint module this strip is in

   return PlexScintMdlId::StripToScintMdl(*this,this->GetStrip());
}

//_____________________________________________________________________________
UShort_t PlexStripEndId::GetStripInMdl() const
{
   // Return an strip # within a module 
   // using offline convention of [0,nstripInMdl)

   return PlexScintMdlId::GetStripInMdl(*this,this->GetStrip());
}

//_____________________________________________________________________________
UShort_t PlexStripEndId::GetMapperStripInMdl() const
{
   // Return an strip # within a module using construction based notation
   // starts w/ 1 .. flip flops w/ increasing 'tpos' depending on
   // installation orientation

   return PlexScintMdlId::GetMapperStripInMdl(*this,this->GetStrip());
}

//_____________________________________________________________________________
StripEnd::StripEnd_t PlexStripEndId::GetManifoldF1() const
{
   // Return the side with the "F1" manifold (construction notation)

   switch (GetDetector()) {
   case Detector::kFar:
     // lower half has F1 on West side, upper on the East
     return ((GetStrip()<96) ? StripEnd::kWest : StripEnd::kEast );
     break;
   case Detector::kCalDet:
     {
       // ???? this might not be right!!!
       MAXMSG("Plex",Msg::kWarning,10)
         << "GetManifoldF1 not verified for CalDet!!" << endl;
       return ((GetPlaneView()==PlaneView::kU) ? 
               StripEnd::kDown : StripEnd::kWest );
     }
     break;
   default:
     // near detector only has west side
     return StripEnd::kWest;
   }
}

//_____________________________________________________________________________
//inline
Int_t PlexStripEndId::Build18BitPlnStripKey() const
{
   return ( GetPlane() << bitsPlexIdStrip ) | GetStrip();
}

//_____________________________________________________________________________
PlexStripEndId PlexStripEndId::Unbuild18BitPlnStripKey(Detector::Detector_t det, Int_t key)
{
   // recover true id object from hashed down version
   // needs detector info that was lost in compactification
   // obviously can't recover end info that was lost

   const UInt_t maskLower = ( maskPlexIdStrip >> shftPlexIdStrip );
   UInt_t strip = key & maskLower;
   UInt_t plane = key >> bitsPlexIdStrip;
   return PlexStripEndId(det,plane,strip);
}

//_____________________________________________________________________________
Int_t PlexStripEndId::BuildPlnStripEndKey() const
{
   // compactified plane,strip,end (assuming only east/west ends)
   // 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 strip = GetStrip();
   Detector::Detector_t det = GetDetector();
   StripEnd::StripEnd_t end = GetEnd();

   Int_t nStrips = 192;  // need some default
   switch (det) {
   case Detector::kNear:   nStrips =  96; break;
   case Detector::kFar:    nStrips = 192; break;
   case Detector::kCalDet: nStrips =  24; break;
   default:
      MAXMSG("Plex",Msg::kWarning,10)
         << "PlexStripEndId " << *this << " is not Near/Far/CalDet" << endl;
   }

   if (strip>=nStrips) {
     MAXMSG("Plex",Msg::kWarning,10)
       << "PlexStripEndId " << *this 
       << " exceeds expected nStrips " << nStrips << endl;
   }

   Int_t hvalue = plane*nStrips + strip;

   if (det == Detector::kNear) {
      // near detector only has west readout
     if (end != StripEnd::kWest) {
       MAXMSG("Plex",Msg::kWarning,10)
         << "PlexStripEndId " << *this << " has non-West readout" << endl;
     // but do nothing
     }
   }
   else {
      // make room for end bit
      hvalue <<= 1;
      switch (GetEnd()) {
      case StripEnd::kEast: hvalue += 0; break;
      case StripEnd::kWest: hvalue += 1; break;
      default:
         MAXMSG("Plex",Msg::kWarning,10)
            << "PlexStripEndId " << *this << " is not East/West" << endl;
      }
   }

   return hvalue;
}

//_____________________________________________________________________________
PlexStripEndId PlexStripEndId::UnbuildPlnStripEndKey(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 nStrips = 192;  // need some default
   switch (det) {
   case Detector::kNear:   nStrips =  96; break;
   case Detector::kFar:    nStrips = 192; break;
   case Detector::kCalDet: nStrips =  24; break;
   default:
      MAXMSG("Plex",Msg::kWarning,10)
         << "PlexStripEndId " << Detector::AsString(det) 
         << "(" << (int)det << ")"
         << " is not Near/Far/CalDet" << endl;
   }
   
   StripEnd::StripEnd_t end = StripEnd::kWest;
   if ( Detector::kNear != det ) {
     // NearDet has only west readout so it isn't part of the hash
     if ( key & 1 ) end = StripEnd::kWest;
     else           end = StripEnd::kEast;
     key >>= 1;  // for non-NearDet we can now remove bit
   }
   Int_t plane = key / nStrips;
   Int_t strip = key - (plane*nStrips);

   return PlexStripEndId(det,plane,strip,end);
}

//_____________________________________________________________________________
Bool_t PlexStripEndId::IsSameStrip(const PlexStripEndId &other) const
{
   // Determine if "this" and "other" are the same strip

   return (GetDetector() == other.GetDetector() &&
           GetPlane()    == other.GetPlane()    &&
           GetStrip()    == other.GetStrip()       );
   
}

//_____________________________________________________________________________
Bool_t PlexStripEndId::IsSameStripEnd(const PlexStripEndId &other) const
{
   // Determine if "this" and "other" are the same strip and end

   return (GetEnd() == other.GetEnd() && IsSameStrip(other) );
   
}

//_____________________________________________________________________________
Bool_t PlexStripEndId::IsOppositeStripEnd(const PlexStripEndId &other) const
{
   // Determine if "this" and "other" are the same strip
   // but opposite ends.
   // !!!! Assumes one can test this by != on ends

   return (GetEnd() != other.GetEnd() && IsSameStrip(other) );
   
}

//_____________________________________________________________________________
Bool_t PlexStripEndId::IsValid() const
{ 
  // test if plane is valid
  //   ie. # = all bits on as signal of invalid value
  //       also fail if IsSteel=false but PlaneCoverage=NoActive
  //  then test if the strip # makes sense (hard code some #'s in)
  if ( ! PlexPlaneId::IsValid() ) return false;
  return ( GetStrip() < NumberOfStrips() );
}

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

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

//_____________________________________________________________________________

---