PlexPixelSpotId.h

Go to the documentation of this file.

// $Id: PlexPixelSpotId.h,v 1.17 2005/08/26 18:47:03 rhatcher Exp $
//
// PlexPixelSpotId
//
// PlexPixelSpotId encapsulates mux/tube/pixel/spot number encoding
//
// Author:  R. Hatcher 2001.06.26
//

#ifndef PLEXPIXELSPOTID_H
#define PLEXPIXELSPOTID_H

#include "PlexMuxBoxId.h"

// for now include obsolete methods
//#define ENABLE_PIXELSPOTID_ISNULL
//#define ENABLE_PIXELSPOTID_ENCODEMUXBOX

class PlexPixelSpotId;
std::ostream& operator<<(std::ostream& os, const PlexPixelSpotId& p);

class PlexPixelSpotId : public PlexMuxBoxId {

 public:

   PlexPixelSpotId();                        // necessary for streamer io
   PlexPixelSpotId(Detector::Detector_t detector, 
                   ElecType::Elec_t electronics,
                   Char_t eastwest, Char_t racklevel, 
                   UInt_t rackbay, UInt_t inrack,
                   UInt_t tube, UInt_t pixel, UInt_t spot);
   PlexPixelSpotId(PlexMuxBoxId muxbox,
                   UInt_t tube, UInt_t pixel, UInt_t spot);

   // non-virtual dtor would be okay, but ClassDef brings in virtualness
   virtual ~PlexPixelSpotId();

   // use these two with caution as they work on the rawest level
   explicit PlexPixelSpotId(const UInt_t encoded);
   UInt_t                   GetEncoded() const;

   const char              *AsString(Option_t *option="") const;

   UShort_t                 GetTube() const;
   UShort_t                 GetPixel() const;
   UShort_t                 GetSpot() const;

   Bool_t                   IsValid() const;
#ifdef ENABLE_PIXELSPOTID_ISNULL
   Bool_t                   IsNull() const;
#endif

   // uncompactified, but unencumbered w/ spot, +pixel 
   // (set unused bits on to avoid spot=0 --> broken fiber convention)
   UInt_t                   GetUniquePmtEncodedValue() const;
   UInt_t                   GetUniquePixelEncodedValue() const;

   void Print(Option_t *option="") const;

   void SetTube(UInt_t tube);
   void SetPixel(UInt_t pixel);
   void SetSpot(UInt_t spot);

   Bool_t  IsSamePixel(const PlexPixelSpotId &other) const;
   Bool_t  IsSameTube(const PlexPixelSpotId &other) const;

   friend Bool_t operator< (const PlexPixelSpotId &lhs, const PlexPixelSpotId &rhs);
   friend Bool_t operator<=(const PlexPixelSpotId &lhs, const PlexPixelSpotId &rhs);
   friend Bool_t operator==(const PlexPixelSpotId &lhs, const PlexPixelSpotId &rhs);
   friend Bool_t operator!=(const PlexPixelSpotId &lhs, const PlexPixelSpotId &rhs);
   friend Bool_t operator> (const PlexPixelSpotId &lhs, const PlexPixelSpotId &rhs);
   friend Bool_t operator>=(const PlexPixelSpotId &lhs, const PlexPixelSpotId &rhs);

#ifdef ENABLE_PIXELSPOTID_ENCODEMUXBOX
   static Int_t EncodeMuxBox(Char_t eastwest, Char_t racklevel,
                             Int_t rackbay, Int_t inrack);

   static void  DecodeMuxBox(Int_t muxbox, Char_t& eastwest, Char_t& racklevel,
                             Int_t& rackbay, Int_t& inrack);
#endif

 private:

   ClassDef(PlexPixelSpotId,3)
};

#ifndef __CINT__
//==========================================================================
// Implementation details 
//==========================================================================
//
// The details of the encoding of PlexPixelSpotId are here in 
// PlexPixelSpotId.h; this is so that the compiler can inline the code
// Users should NOT rely on intimate knowledge of these details.
//
//    MSB                          LSB
//     3         2         1         0
//    10987654321098765432109876543210
//    ddddeemmmmmmmmmmmmttppppppppssss  old pixel spot id
//    vdddeeWELLBBBBBIIIIttpppppppssss  new pixel spot id
//    77776666555544443333222211110000
//

const UInt_t maskPlexSpotSpot        = 0x0000000f;  // 0:15 0=broken
const UInt_t shftPlexSpotSpot        = 0;
const UInt_t maskPlexSpotPixel       = 0x000007f0;  // 0:127
const UInt_t shftPlexSpotPixel       = 4;
const UInt_t maskPlexSpotTube        = 0x00001800;  // 0:3
const UInt_t shftPlexSpotTube        = 11;
  
const UInt_t zeroPlexSpotSpot = ~maskPlexSpotSpot;
const UInt_t zeroPlexSpotPixelSpot = ~(maskPlexSpotPixel|maskPlexSpotSpot);
const UInt_t zeroPlexSpotTubePixelSpot = 
                       ~(maskPlexSpotTube|maskPlexSpotPixel|maskPlexSpotSpot);
         
//==========================================================================

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

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

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

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

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

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

// Determine if "this" and "other" are the same pixel (ignoring "spot" info)
inline Bool_t PlexPixelSpotId::IsSamePixel(const PlexPixelSpotId &other) const
{ ConvertToVersion2(); other.ConvertToVersion2();
  return (fEncoded&zeroPlexSpotSpot) == (other.fEncoded&zeroPlexSpotSpot); }

// Determine if "this" and "other" are the same tube 
// (ignoring "pxiel+spot" info)
inline Bool_t PlexPixelSpotId::IsSameTube(const PlexPixelSpotId &other) const
{ ConvertToVersion2(); other.ConvertToVersion2();
  return (fEncoded&zeroPlexSpotPixelSpot) == 
         (other.fEncoded&zeroPlexSpotPixelSpot); }

inline UInt_t PlexPixelSpotId::GetEncoded() const
{ ConvertToVersion2(); return fEncoded; }

inline UShort_t PlexPixelSpotId::GetTube() const
{
  ConvertToVersion2();
  return (fEncoded & maskPlexSpotTube ) >> shftPlexSpotTube ;
}

inline UShort_t PlexPixelSpotId::GetPixel() const
{
  ConvertToVersion2();
  return (fEncoded & maskPlexSpotPixel ) >> shftPlexSpotPixel ;
}

inline UShort_t PlexPixelSpotId::GetSpot() const
{
  ConvertToVersion2();
  return (fEncoded & maskPlexSpotSpot ) >> shftPlexSpotSpot ;
}

inline void PlexPixelSpotId::SetTube(UInt_t tube)
{
  ConvertToVersion2();
  fEncoded = (fEncoded & ~maskPlexSpotTube) |
      ( ( tube << shftPlexSpotTube ) & maskPlexSpotTube );
}

inline void PlexPixelSpotId::SetPixel(UInt_t pixel)
{
  ConvertToVersion2();
  fEncoded = (fEncoded & ~maskPlexSpotPixel) |
      ( ( pixel << shftPlexSpotPixel ) & maskPlexSpotPixel );
}

inline void PlexPixelSpotId::SetSpot(UInt_t spot)
{
  ConvertToVersion2();
  fEncoded = (fEncoded & ~maskPlexSpotSpot) |
      ( ( spot << shftPlexSpotSpot ) & maskPlexSpotSpot );
}


inline Bool_t PlexPixelSpotId::IsValid() const 
{
  // test whether this is the nonsensical default value
  return ( fEncoded & (zeroPlexMuxVersion&zeroPlexSpotTubePixelSpot) ) != defaultMuxBoxId;
}

inline UInt_t PlexPixelSpotId::GetUniquePmtEncodedValue() const
{
  // uncompatified, but unique for a PMT independent of pixel/spot
  return fEncoded | maskPlexSpotSpot | maskPlexSpotPixel;
}

inline UInt_t PlexPixelSpotId::GetUniquePixelEncodedValue() const
{
  // uncompatified, but unique for a PMT independent of spot
  return fEncoded | maskPlexSpotSpot;
}

#endif /* __CINT__ */
#endif // PLEXPIXELSPOTID_H

---