LHCbID.h

Go to the documentation of this file.

//   **************************************************************************
//   *                                                                        *
//   *                      ! ! ! A T T E N T I O N ! ! !                     *
//   *                                                                        *
//   *  This file was created automatically by GaudiObjDesc, please do not    *
//   *  delete it or edit it by hand.                                         *
//   *                                                                        *
//   *  If you want to change this file, first change the corresponding       *
//   *  xml-file and rerun the tools from GaudiObjDesc (or run make if you    *
//   *  are using it from inside a Gaudi-package).                            *
//   *                                                                        *
//   **************************************************************************

#ifndef LHCbKernel_LHCbID_H
#define LHCbKernel_LHCbID_H 1

// Include files
#include "Kernel/VeloChannelID.h"
#include "Kernel/ITChannelID.h"
#include "Kernel/OTChannelID.h"
#include "Kernel/RichSmartID.h"
#include "Kernel/CaloCellID.h"
#include <ostream>


// Forward declarations
class LHCbID;


class LHCbID
{
public:

  LHCbID(const VeloChannelID& chanID,
         const unsigned int size=0);

  LHCbID(const ITChannelID& chanID,
         const unsigned int size=0);

  LHCbID(const OTChannelID& chanID);

  LHCbID(const RichSmartID& chanID);

  LHCbID(const CaloCellID& chanID);

  LHCbID() : m_lhcbID(0) {}

  virtual ~LHCbID() {}

  friend std::ostream& operator<< (std::ostream& str,
                                   const LHCbID& obj);

  virtual std::ostream& fillStream(std::ostream& s) const;

  bool operator==(const LHCbID& chanID) const;

  bool isVelo() const;

  VeloChannelID veloID() const;

  bool isST() const;

  ITChannelID stID() const;

  bool isOT() const;

  OTChannelID otID() const;

  bool isRich() const;

  RichSmartID richID() const;

  bool isCalo() const;

  CaloCellID caloID() const;

  unsigned int channelID() const;

  void setSpareBits(unsigned int value);

  unsigned int spareBits() const;

  unsigned int lhcbID() const;

  void setID(unsigned int value);

  unsigned int detectorType() const;

  void setDetectorType(unsigned int value);

protected:

  enum SpecificMask{ veloMask= 0x1FFFFFL,
                     stMask=0x3FFFFFFL,
                     otMask=0x3FFFFFFL };
  enum SpecificBits{ veloBits=21,
                     stBits=26,
                     otBits=26 };

private:

  enum channelIDType{ veloType=1,
                      stType,
                      otType,
                      richType,
                      caloType,
                      muonType };

  enum lhcbIDBits{IDBits           = 0,
                  detectorTypeBits = 28};

  enum lhcbIDMasks{IDMask           = 0xFFFFFFFL,
                   detectorTypeMask = 0xF0000000L};


  unsigned int m_lhcbID; 

};

// -----------------------------------------------------------------------------
//   end of class
// -----------------------------------------------------------------------------

// Including forward declarations

inline LHCbID::LHCbID(const VeloChannelID& chanID,
                      const unsigned int size) 
{

m_lhcbID = (veloType << detectorTypeBits) +
           (size     << veloBits ) +
           chanID;
          
}

inline LHCbID::LHCbID(const ITChannelID& chanID,
                      const unsigned int size) 
{

m_lhcbID = (stType << detectorTypeBits) +
          (size   << stBits ) +
          ((chanID.uniqueWafer()-1) >>6) +
          (chanID.strip()-1) ;
        
}

inline LHCbID::LHCbID(const OTChannelID& chanID) 
{

m_lhcbID = (otType << detectorTypeBits) + chanID;
        
}

inline LHCbID::LHCbID(const RichSmartID& chanID) : m_lhcbID(0) 
{

  unsigned int richData = chanID.dataBitsOnly();
  if( chanID.pixelDataAreValid() ) richData += 0x8000000;
  setDetectorType( richType );
  setID( richData );
         
}

inline LHCbID::LHCbID(const CaloCellID& chanID) : m_lhcbID(0) 
{

  setDetectorType( caloType );
  setID( chanID.ccid() );
         
}

inline std::ostream& operator<< (std::ostream& str,
                                 const LHCbID& obj)
{
  return obj.fillStream(str);
}

inline std::ostream& LHCbID::fillStream(std::ostream& s) const
{
  s << "{ " << "lhcbID :        " << m_lhcbID << std::endl << " }";
  return s;
}


inline unsigned int LHCbID::lhcbID() const 
{
  return m_lhcbID;
}

inline void LHCbID::setID(unsigned int value)
{
  unsigned int val = (unsigned int)value;
  m_lhcbID &= ~IDMask;
  m_lhcbID |= ((((unsigned int)val) << IDBits) & IDMask);
}

inline unsigned int LHCbID::detectorType() const
{
  return (unsigned int)((m_lhcbID & detectorTypeMask) >> detectorTypeBits);
}

inline void LHCbID::setDetectorType(unsigned int value)
{
  unsigned int val = (unsigned int)value;
  m_lhcbID &= ~detectorTypeMask;
  m_lhcbID |= ((((unsigned int)val) << detectorTypeBits) & detectorTypeMask);
}

inline bool LHCbID::operator==(const LHCbID& chanID) const 
{

  return (this->lhcbID() == chanID.lhcbID());
         
}

inline bool LHCbID::isVelo() const 
{

  return (veloType == detectorType());
         
}

inline VeloChannelID LHCbID::veloID() const 
{

if ( !isVelo() ) return 0xF0000000;
return ( m_lhcbID & veloMask );
         
}

inline bool LHCbID::isST() const 
{

  return (stType == detectorType());
         
}

inline ITChannelID LHCbID::stID() const 
{

if ( !isST() ) return 0xF0000000;
return ( ( (m_lhcbID & 0x3FFFC00 ) << 6) + ( m_lhcbID & 0x3FF));
         
}

inline bool LHCbID::isOT() const 
{

return (otType == detectorType());
         
}

inline OTChannelID LHCbID::otID() const 
{

if ( !isOT() ) return  0xF0000000;
return m_lhcbID & otMask;
         
}

inline bool LHCbID::isRich() const 
{

  return (richType == detectorType());
         
}

inline RichSmartID LHCbID::richID() const 
{

if ( !isRich() ) return 0x0;
int id = m_lhcbID & IDMask;
if( id && 0x8000000 ) id = id | 0x7E000000;
return id;
         
}

inline bool LHCbID::isCalo() const 
{

  return (caloType == detectorType());
         
}

inline CaloCellID LHCbID::caloID() const 
{

  return isCalo() ? (m_lhcbID & IDMask) : 0xF0000000;
         
}

inline unsigned int LHCbID::channelID() const 
{

return m_lhcbID & IDMask;
        
}

inline void LHCbID::setSpareBits(unsigned int value) 
{

  if ( !( isVelo() || isOT() || isST() ) ) return;
  unsigned int mask = IDMask;
  unsigned int bits = IDBits;
  if (isVelo()) {
    mask &= (~veloMask);
    bits = veloBits;
  } else if (isST()) {
    mask &= (~stMask);
    bits = stBits;
  } else if (isOT()) {
    mask &= (~otMask);
    bits = otBits;
  }
  m_lhcbID &= ~mask;
  m_lhcbID |= ((value << bits) & mask);
        
}

inline unsigned int LHCbID::spareBits() const 
{

  if ( !( isVelo() || isOT() || isST()) ) return 0;
  unsigned int mask = IDMask;
  unsigned int bits = IDBits;
  if (isVelo()) {
     mask &= (~veloMask);         
     bits = veloBits;
  } else if (isST()) {
    mask &= (~stMask);
    bits = stBits;
  } else if (isOT()) {
     mask &= (~otMask);   
     bits = otBits;
  }
  unsigned int val = ((m_lhcbID & mask) >> bits);
  return val;
         
}


#endif 

---