L1GctInternHtMiss.h

Go to the documentation of this file.

#ifndef L1GCTINTERNHTMISS_H
#define L1GCTINTERNHTMISS_H
 
// C++ headers
#include <ostream>
#include <cstdint>
 
class L1GctInternHtMiss {
public:
  enum L1GctInternHtMissType { nulltype, miss_htx, miss_hty, miss_htx_and_hty, jf_miss_htx_and_hty };
 
  enum numberOfBits {
    // TODO - tidy up all these enums.
    // These numbers of bits are needed to specify data sizes in the emulator
    // Other masks are below in the private section.
    kJetMissHtNBits = 12,
    kMissHxAndHyNBits = 14,
    kMissHxOrHyNBits = 16
  };
 
  L1GctInternHtMiss();
 
  ~L1GctInternHtMiss();
 
  /* Named Constructors */
 
  static L1GctInternHtMiss unpackerMissHtx(const uint16_t capBlock,
                                           const uint16_t capIndex,
                                           const int16_t bx,
                                           const uint32_t data);
 
  static L1GctInternHtMiss unpackerMissHty(const uint16_t capBlock,
                                           const uint16_t capIndex,
                                           const int16_t bx,
                                           const uint32_t data);
 
  static L1GctInternHtMiss unpackerMissHtxHty(const uint16_t capBlock,
                                              const uint16_t capIndex,
                                              const int16_t bx,
                                              const uint32_t data);
 
  static L1GctInternHtMiss emulatorJetMissHt(const int htx, const int hty, const bool overFlow, const int16_t bx);
 
  static L1GctInternHtMiss emulatorMissHtxHty(const int htx, const int hty, const bool overFlow, const int16_t bx);
 
  static L1GctInternHtMiss emulatorMissHtx(const int htx, const bool overFlow, const int16_t bx);
 
  static L1GctInternHtMiss emulatorMissHty(const int hty, const bool overFlow, const int16_t bx);
 
  /* Metadata */
 
  L1GctInternHtMiss::L1GctInternHtMissType type() const { return type_; }
 
  uint16_t capBlock() const { return capBlock_; }
 
  uint16_t capIndex() const { return capIndex_; }
 
  int16_t bx() const { return bx_; }
 
  bool isThereHtx() const {
    return (type() == miss_htx || type() == miss_htx_and_hty || type() == jf_miss_htx_and_hty);
  }
 
  bool isThereHty() const {
    return (type() == miss_hty || type() == miss_htx_and_hty || type() == jf_miss_htx_and_hty);
  }
 
  /* Access to the actual data */
 
  uint32_t raw() const { return data_; }
 
  int16_t htx() const;
 
  int16_t hty() const;
 
  bool overflow() const;
 
  /* Operators */
 
  bool operator==(const L1GctInternHtMiss& rhs) const { return (type() == rhs.type() && raw() == rhs.raw()); }
 
  bool operator!=(const L1GctInternHtMiss& rhs) const { return !(*this == rhs); }
 
private:
  enum ShiftsAndMasks {
    kDoubleComponentHtyShift = 16,          // Bit shift for Hty in miss_htx_and_hty
    kSingleComponentOflowMask = (1 << 30),  // Overflow bit mask in miss_htx or miss_hty
    kDoubleComponentOflowMask = (1 << 15),  // Overflow bit mask in miss_htx_and_hty
    kSingleComponentHtMask = 0xffff,        // Ht component mask in miss_htx or miss_hty
    kDoubleComponentHtMask = 0x3fff,        // Ht component mask in miss_htx_and_hty
    kJetFinderComponentHtMask = 0x0fff,     // Ht component mask in jf_miss_htx_and_hty
    kSingleComponentRawMask = kSingleComponentOflowMask |
                              kSingleComponentHtMask,  // To mask off all the non-data bits in raw data (e.g. BC0, etc)
    kDoubleComponentRawMask =
        (kDoubleComponentHtMask << kDoubleComponentHtyShift) | kDoubleComponentOflowMask | kDoubleComponentHtMask
  };
 
  /* Private ctors and methods */
 
  L1GctInternHtMiss(const L1GctInternHtMissType type,
                    const uint16_t capBlock,
                    const uint16_t capIndex,
                    const int16_t bx,
                    const uint32_t data);
 
 
  int16_t convert14BitTwosCompTo16Bit(const uint16_t data) const;
 
  /* Private data */
 
  L1GctInternHtMissType type_;
 
  // source of the data
  uint16_t capBlock_;
  uint16_t capIndex_;
  int16_t bx_;
 
  uint32_t data_;
};
 
// Pretty-print operator for L1GctInternHtMiss
std::ostream& operator<<(std::ostream& os, const L1GctInternHtMiss& rhs);
 
#endif