PlexMuxBoxId.h

Go to the documentation of this file.

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

#ifndef PLEXMUXBOXID_H
#define PLEXMUXBOXID_H

#include <iosfwd>

#include "Conventions/Detector.h"
#include "Conventions/ElecType.h"

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

class PlexMuxBoxId {

 public:

   PlexMuxBoxId();                        // necessary for streamer io
   PlexMuxBoxId(const Detector::Detector_t detector, 
                const ElecType::Elec_t electronics,
                Char_t eastwest, Char_t racklevel,
                UInt_t rackbay, UInt_t inrack);
    // copy and assignment (trim irrelevant bits when rhs isderived class)
    PlexMuxBoxId(const PlexMuxBoxId& muxid);
    PlexMuxBoxId& operator=(const PlexMuxBoxId& muxid);

   // non-virtual dtor would be okay, but ClassDef brings in virtualness
   virtual ~PlexMuxBoxId() { ; } // no owned data members

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

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

   Detector::Detector_t            GetDetector() const;
   ElecType::Elec_t                GetElecType() const;
   Char_t                          GetEastWest() const;
   Char_t                          GetRackLevel() const;
   UShort_t                        GetRackBay() const;
   UShort_t                        GetInRack() const;

   // "Numeric" is doesn't include version, delector or electronics type
   UInt_t                          GetNumericMuxBox() const;

   Bool_t                          IsValid() const;

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

   void SetDetector(Detector::Detector_t detector);
   void SetElecType(ElecType::Elec_t elec);
   void SetEastWest(Char_t eastwest);
   void SetRackLevel(Char_t racklevel);
   void SetRackBay(UInt_t rackbay);
   void SetInRack(UInt_t inrack);

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

   static UInt_t ConvertEncodedToVersion2(UInt_t encoded);
   void  ConvertToVersion2() const;  // logical const

 protected:

   UInt_t   fEncoded;  // encoded value

 private:

   ClassDef(PlexMuxBoxId,2)
};

#ifndef __CINT__
//==========================================================================
// Implementation details 
//==========================================================================
//
// The details of the encoding of PlexMuxBoxId are here in 
// PlexMuxBoxId.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
//    vdddeeWELLbbbbbiiii-------------
//
//    v = new version flag (1 had one fewer inrack bits)
//
//    WE    : 01b=east 10b=west (others are invalid)
//    LL    : 00b=lower, 01b=middle, 10b=upper, 11b=??
//    bbbbb : rack bay #
//    iiii  : placement in rack (from lower to upper)

const UInt_t defaultMuxBoxId = 0;

const UInt_t maskPlexMuxVersion      = 0x80000000;
const UInt_t maskPlexMuxDetector     = 0x70000000;
const UInt_t shftPlexMuxDetector     = 28;
const UInt_t maskPlexMuxElecType     = 0x0C000000;
const UInt_t shftPlexMuxElecType     = 26;
const UInt_t maskPlexMuxEastWest     = 0x03000000;
const UInt_t shftPlexMuxEastWest     = 24;
const UInt_t maskPlexMuxLevel        = 0x00C00000;
const UInt_t shftPlexMuxLevel        = 22;
const UInt_t maskPlexMuxBay          = 0x003E0000;
const UInt_t shftPlexMuxBay          = 17;
const UInt_t maskPlexMuxInRack       = 0x0001E000;
const UInt_t shftPlexMuxInRack       = 13;

// "Numeric" is doesn't include version, delector or electronics type
const UInt_t maskPlexMuxNumeric      = 
  maskPlexMuxEastWest|maskPlexMuxLevel|maskPlexMuxBay|maskPlexMuxInRack;
const UInt_t shftPlexMuxNumeric      = shftPlexMuxInRack;

const UInt_t zeroPlexMuxVersion = ~maskPlexMuxVersion;
const UInt_t maskPlexMuxUsed    = 0xFFFFE000;
const UInt_t zeroPlexMuxUnused  = maskPlexMuxUsed;
           
//==========================================================================

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

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

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

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

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

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

inline UInt_t PlexMuxBoxId::GetEncoded() const
{ ConvertToVersion2(); return fEncoded&zeroPlexMuxUnused; }

inline Detector::Detector_t PlexMuxBoxId::GetDetector() const
{ 
  ConvertToVersion2();
  Int_t bitField = ( fEncoded & maskPlexMuxDetector) >> shftPlexMuxDetector;
  return (Detector::Detector_t) bitField;   
}

inline ElecType::Elec_t PlexMuxBoxId::GetElecType() const
{ 
  ConvertToVersion2();
  Int_t bitField = ( fEncoded & maskPlexMuxElecType ) >> shftPlexMuxElecType;
  return (ElecType::Elec_t) bitField;   
}

inline Char_t PlexMuxBoxId::GetEastWest() const
{
  ConvertToVersion2();
  switch ( ( fEncoded & maskPlexMuxEastWest ) >> shftPlexMuxEastWest ) {
  case 1:  return 'E';
  case 2:  return 'W';
  default: return '?';
  }
}

inline Char_t PlexMuxBoxId::GetRackLevel() const
{
  ConvertToVersion2();
  switch ( ( fEncoded & maskPlexMuxLevel ) >> shftPlexMuxLevel ) {
  case 0:  return 'L';
  case 1:  return 'M';
  case 2:  return 'U';
  default: return '?';
  }
}

inline UShort_t PlexMuxBoxId::GetRackBay() const
{
  ConvertToVersion2();
  return ( fEncoded & maskPlexMuxBay ) >> shftPlexMuxBay;
}

inline UShort_t PlexMuxBoxId::GetInRack() const
{
  ConvertToVersion2();
  return ( fEncoded & maskPlexMuxInRack ) >> shftPlexMuxInRack;
}

inline UInt_t PlexMuxBoxId::GetNumericMuxBox() const
{
  ConvertToVersion2();
  return ( fEncoded & maskPlexMuxNumeric ) >> shftPlexMuxNumeric;
}

inline void PlexMuxBoxId::SetDetector(Detector::Detector_t detector)
{
  ConvertToVersion2();
  fEncoded = ( fEncoded & ~maskPlexMuxDetector ) | 
    ( ( detector << shftPlexMuxDetector ) & maskPlexMuxDetector );
}

inline void PlexMuxBoxId::SetElecType(ElecType::Elec_t elec)
{
  ConvertToVersion2();
  fEncoded = ( fEncoded & ~maskPlexMuxElecType ) | 
    ( ( elec << shftPlexMuxElecType ) & maskPlexMuxElecType );
}

inline void PlexMuxBoxId::SetEastWest(Char_t eastwest)
{
  ConvertToVersion2();
  int iew = 0;
  switch (eastwest) {
  case 'e':
  case 'E':
  case '-':
    iew = 1;
    break;
  case 'w':
  case 'W':
  case '+':
    iew = 2;
    break;
  default:
    iew = 0;
  }
  fEncoded = ( fEncoded & ~maskPlexMuxEastWest ) |
    ( ( iew << shftPlexMuxEastWest ) & maskPlexMuxEastWest );
}

inline void PlexMuxBoxId::SetRackLevel(Char_t racklevel)
{
  ConvertToVersion2();
  int irl = 0;
  switch (racklevel) {
  case 'l':
  case 'L':
  case 'b':
  case 'B':
    irl = 0;
    break;
  case 'm':
  case 'M':
    irl = 1;
    break;
  case 't':
  case 'T':
  case 'u':
  case 'U':
    irl = 2;
    break;
  default:
    irl = 3;
  }
  fEncoded = ( fEncoded & ~maskPlexMuxLevel ) |
    ( ( irl << shftPlexMuxLevel ) & maskPlexMuxLevel );
}

inline void PlexMuxBoxId::SetRackBay(UInt_t rackbay)
{
  ConvertToVersion2();
  fEncoded = ( fEncoded & ~maskPlexMuxBay ) |
    ( ( rackbay << shftPlexMuxBay ) & maskPlexMuxBay );
}

inline void PlexMuxBoxId::SetInRack(UInt_t inrack)
{
  ConvertToVersion2();
  fEncoded = ( fEncoded & ~maskPlexMuxInRack ) |
    ( ( inrack << shftPlexMuxInRack ) & maskPlexMuxInRack );
}

inline Bool_t PlexMuxBoxId::IsValid() const {
  return ( fEncoded & zeroPlexMuxVersion ) != defaultMuxBoxId;
}

#endif /* __CINT__ */
#endif // PLEXMUXBOXID_H

---