PlexPixelSpotId.cxx

Go to the documentation of this file.

// $Id: PlexPixelSpotId.cxx,v 1.21 2011/01/03 20:39:33 rhatcher Exp $
//
// PlexPixelSpotId encapsulates mux/tube/pixel/spot number encoding
//
// Author:  R. Hatcher 2001.06.26
//

#include "Plex/PlexPixelSpotId.h"

#include "TBuffer.h"
#include "TClass.h"

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

#include "MessageService/MsgService.h"
//CVSID("$Id: PlexPixelSpotId.cxx,v 1.21 2011/01/03 20:39:33 rhatcher Exp $");

ClassImp(PlexPixelSpotId)

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

  return os;
}

//_____________________________________________________________________________
PlexPixelSpotId::PlexPixelSpotId()
   : PlexMuxBoxId()
{
   // Default ctor constructs meaningless value
}

//_____________________________________________________________________________
PlexPixelSpotId::PlexPixelSpotId(Detector::Detector_t detector,
                                 ElecType::Elec_t elec,
                                 Char_t eastwest, Char_t racklevel, 
                                 UInt_t rackbay, UInt_t inrack,
                                 UInt_t tube, UInt_t pixel, UInt_t spot)
  : PlexMuxBoxId(detector,elec,eastwest,racklevel,rackbay,inrack)
{
   // Normal ctor

   SetTube(tube);
   SetPixel(pixel);
   SetSpot(spot);
}

//_____________________________________________________________________________
PlexPixelSpotId::PlexPixelSpotId(PlexMuxBoxId muxbox,
                                 UInt_t tube, UInt_t pixel, UInt_t spot)
  : PlexMuxBoxId(muxbox)
{
   // Normal ctor

   SetTube(tube);
   SetPixel(pixel);
   SetSpot(spot);
}

//_____________________________________________________________________________
PlexPixelSpotId::PlexPixelSpotId(const UInt_t encoded)
   : PlexMuxBoxId(encoded)
{
   // constructor from pre-encoded value
}

//_____________________________________________________________________________
PlexPixelSpotId::~PlexPixelSpotId()
{
   // delete all the owned sub-objects
}

//_____________________________________________________________________________
const char * PlexPixelSpotId::AsString(Option_t *option) const
{
   // Return unpacked PlexPixelSpotId 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][64];
   static int ibuffer = nbuffers;
   ibuffer = (ibuffer+1)%nbuffers;  // each time move to next buffer

   string opt = option;
   bool extended   = (opt.find("e") != string::npos);
   bool pixel_only = (opt.find("p") != string::npos);
   bool tube_only =  (opt.find("t") != string::npos);

   const char*   pfmt = "%s-PIXEL-%1.1d-%2.2d";
   const char*   tfmt = "%s-TUBE-%1.1d";
   const char*   efmt = "%s-SPOT-%1.1d-%2.2d-%2.2d";
   if (extended) efmt = "%s-SPOT-tube %1.1d pixel %2.2d spot %2.2d";

   const char* muxAsString = PlexMuxBoxId::AsString(option);

   if (pixel_only)    sprintf(newstring[ibuffer],pfmt,
                              muxAsString,GetTube(),GetPixel());
   else if(tube_only) sprintf(newstring[ibuffer],tfmt,
                              muxAsString,GetTube());
   else               sprintf(newstring[ibuffer],efmt,
                              muxAsString,GetTube(),GetPixel(),GetSpot());
   
   return newstring[ibuffer];
}

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

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

#ifdef ENABLE_PIXELSPOTID_ISNULL
//_____________________________________________________________________________
Bool_t PlexPixelSpotId::IsNull() const
{
   MSG("Plex",Msg::kWarning) 
     << "PlexPinDidoeId::IsNull() is obsolete -- use !IsValid()" << endl;
   return !IsValid();
}
#endif

#ifdef ENABLE_PIXELSPOTID_ENCODEMUXBOX
//_____________________________________________________________________________
Int_t PlexPixelSpotId::EncodeMuxBox(Char_t eastwest, Char_t racklevel,
                                    Int_t rackbay, Int_t inrack)
{
   // !!! PlexPixelSpotId::EncodeMuxBox and PlexPinDiodeId::EncodeMuxBox
   // !!! must be kept in synch.
   //
   // encode logical muxbox id into 12 bits
   // eastwest  := side on which rack is located
   //              east: 'e', 'E'
   //              west: 'w', 'W'
   // racklevel := level on which rack is located
   //              top/upper:     't', 'T', 'u', 'U'
   //              bottom/lower:  'b', 'B', 'l', 'L'
   // rackbay   := rack within eastwest/racklevel
   //              far:   1 - 16
   //              near:  1 - 14
   // inrack    := placement within the rack  0:7

   //    MSB                          LSB
   //     3         2         1         0
   //    10987654321098765432109876543210
   //                        wellbbbbbiii
   //                  ddddeemmmmmmmmmmmm
   //
   //    we : 01b=east,  10b=west
   //    ll : 00b=lower, 01b=middle, 10b=upper, 11b=??
   // bbbbb : bay
   //   iii : in rack

   int ew = 0;
   switch (eastwest) {
   case 'e':
   case 'E':
      ew = 1;
      break;
   case 'w':
   case 'W':
      ew = 2;
      break;
   }

   int level = 3;
   switch (racklevel) {
   case 'l':
   case 'L':
   case 'b':
   case 'B':
      level = 0;
      break;
   case 'm':
   case 'M':
      level = 1;
      break;
   case 't':
   case 'T':
   case 'u':
   case 'U':
      level = 2;
      break;
   }

   inrack  &= 0x00000007;
   rackbay &= 0x0000001f;

   const int shiftEW     = 10;
   const int shiftLevel  =  8;
   const int shiftBay    =  3;

   return (      ew << shiftEW    ) | 
          (   level << shiftLevel ) | 
          ( rackbay << shiftBay   ) | 
             inrack;
}

//_____________________________________________________________________________
void PlexPixelSpotId::DecodeMuxBox(Int_t muxbox, 
                                   Char_t& eastwest, Char_t& racklevel,
                                   Int_t& rackbay, Int_t& inrack)
{
   // reverse EncodeMuxBox

   const int shiftEW     = 10;
   const int shiftLevel  =  8;
   const int shiftBay    =  3;

   inrack   = muxbox & 0x0007;
   rackbay  = (muxbox >> shiftBay) & 0x001f;
   Int_t level = (muxbox >> shiftLevel ) & 0x0003;
   Int_t ew    = (muxbox >> shiftEW ) & 0x0003;

   switch (level) {
   case 0:  racklevel = 'L'; break;
   case 1:  racklevel = 'M'; break;
   case 2:  racklevel = 'U'; break;
   default: racklevel = '?'; break;
   }

   switch (ew) {
   case 1:  eastwest = 'E'; break;
   case 2:  eastwest = 'W'; break;
   default: eastwest = '?'; break;
   }
}
#endif

//_____________________________________________________________________________
void PlexPixelSpotId::Streamer(TBuffer &R__b)
{
  // Stream a PlexPixelSpotId
  if (R__b.IsReading()) {
    UInt_t R__s, R__c;
    Version_t R__v = R__b.ReadVersion(&R__s, &R__c);
    if ( R__v > 2 ) {
      PlexPixelSpotId::Class()->ReadBuffer(R__b, this, R__v, R__s, R__c);
      return;
    }
    // Process versions pre-automatic schema evolution
    R__b >> fEncoded;
    if (R__v == 1) ConvertToVersion2();
    // Check byte count may not work for version 2 because base class
    // streamer was bypassed
    // R__b.CheckByteCount(R__s, R__c, PlexPixelSpotId::IsA());
  }
  else {
    // versions 3 & up will enjoy automatic schema evolution
    PlexPixelSpotId::Class()->WriteBuffer(R__b, this);
  }
}

//_____________________________________________________________________________

---