PlexPinDiodeId.h

Go to the documentation of this file.

// $Id: PlexPinDiodeId.h,v 1.15 2005/08/26 18:47:03 rhatcher Exp $
//
// PlexPinDiodeId
//
// PlexPinDiodeId encapsulates mux/inbox/gain number encoding
//
// Author:  R. Hatcher 2001.06.26
//

#ifndef PLEXPINDIODEID_H
#define PLEXPINDIODEID_H

#include "PlexMuxBoxId.h"

// for now include obsolete methods
//#define ENABLE_PINDIODEID_ISNULL
//#define ENABLE_PINDIODEID_ENCODEMUXBOX

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

class PlexPinDiodeId : public PlexMuxBoxId {

 public:

   PlexPinDiodeId();                        // necessary for streamer io
   PlexPinDiodeId(Detector::Detector_t detector,
                  ElecType::Elec_t electronics,
                  Char_t eastwest, Char_t racklevel, 
                  UInt_t rackbay, UInt_t inrack,
                  UInt_t inbox, UInt_t gain);
   PlexPinDiodeId(PlexMuxBoxId muxbox,
                  UInt_t inbox, UInt_t gain);

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

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

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

   UShort_t                 GetInBox() const;
   UShort_t                 GetGain() const;
   // the assignment of High/Low is plain weird, but that's how it is
   Bool_t                   IsHighGain() const { return GetGain()==0; }
   Bool_t                   IsLowGain() const { return GetGain()==1; }

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

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

   void SetInBox(UInt_t inbox);
   void SetGain(UInt_t gain);

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

#ifdef ENABLE_PINDIODEID_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(PlexPinDiodeId,3)
};

#ifndef __CINT__
//==========================================================================
// Implementation details 
//==========================================================================
//
// The details of the encoding of PlexPinDiodeId are here in 
// PlexPinDiodeId.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
//    ddddeemmmmmmmmmmmm-----iiiiiiiig  old pin diode id
//    vdddeeWELLBBBBBIIII----iiiiiiiig  new pin diode id
//    77776666555544443333222211110000

const UInt_t maskPlexPinGain         = 0x00000001; // 0=low, 1=high
const UInt_t shftPlexPinGain         = 0;
const UInt_t maskPlexPinInBox        = 0x000001FE; // 0:255
const UInt_t shftPlexPinInBox        = 1;

const UInt_t zeroPlexPinGain = ~maskPlexPinGain;
const UInt_t zeroPlexPinInBoxGain = ~(maskPlexPinInBox|maskPlexPinGain);
           
//==========================================================================

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

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

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

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

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

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

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

inline UShort_t PlexPinDiodeId::GetInBox() const
{
  ConvertToVersion2();
  return (fEncoded & maskPlexPinInBox ) >> shftPlexPinInBox;
}

inline UShort_t PlexPinDiodeId::GetGain() const
{
  ConvertToVersion2();
  return (fEncoded & maskPlexPinGain ) >> shftPlexPinGain;
}

inline void PlexPinDiodeId::SetInBox(UInt_t inbox)
{
  ConvertToVersion2();
  fEncoded = (fEncoded & ~maskPlexPinInBox) |
      ( ( inbox << shftPlexPinInBox ) & maskPlexPinInBox );
}

inline void PlexPinDiodeId::SetGain(UInt_t gain)
{
  ConvertToVersion2();
  fEncoded = (fEncoded & ~maskPlexPinGain) |
      ( ( gain << shftPlexPinGain ) & maskPlexPinGain );
}

inline Bool_t PlexPinDiodeId::IsValid() const
{ 
   // test whether this is the nonsensical default value
   return  ( fEncoded & zeroPlexMuxVersion ) != defaultMuxBoxId;
   // (fEncoded&~(maskPlexMuxVersion|maskPlexPinInBox|maskPlexPinGain)) != defaultMuxBoxId;
}

#endif /* __CINT__ */
#endif // PLEXPINDIODEID_H

---