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