L1GctInternHtMiss.h

Go to the documentation of this file.

#ifndef L1GCTINTERNHTMISS_H
#define L1GCTINTERNHTMISS_H


// C++ headers
#include <ostream>
#include <stdint.h>

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