L1MuGMTCand.h

Go to the documentation of this file.

//-------------------------------------------------
//
//
//
//   Author :
//   H. Sakulin               HEPHY Vienna
//   N. Neumeister            CERN EP
//
//   Migrated to CMSSW:
//   I. Mikulec
//
//--------------------------------------------------
#ifndef DataFormatsL1GlobalMuonTrigger_L1MuGMTCand_h
#define DataFormatsL1GlobalMuonTrigger_L1MuGMTCand_h

//---------------
// C++ Headers --
//---------------
#include <string>

//----------------------
// Base Class Headers --
//----------------------

//------------------------------------
// Collaborating Class Declarations --
//------------------------------------

//              ---------------------
//              -- Class Interface --
//              ---------------------

class L1MuGMTCand {
public:
  L1MuGMTCand();

  L1MuGMTCand(unsigned data, int bx = 0);

  L1MuGMTCand(const L1MuGMTCand&);

  L1MuGMTCand& operator=(const L1MuGMTCand&) = default;

  virtual ~L1MuGMTCand();

  void reset();

  //
  // Getters
  //

  bool empty() const { return readDataField(PT_START, PT_LENGTH) == 0; }

  unsigned getDataWord() const { return m_dataWord; }

  std::string name() const { return m_name; }

  unsigned int phiIndex() const { return readDataField(PHI_START, PHI_LENGTH); }

  unsigned int ptIndex() const { return readDataField(PT_START, PT_LENGTH); }


  unsigned int quality() const { return readDataField(QUAL_START, QUAL_LENGTH); }

  bool useInSingleMuonTrigger() const { return quality() >= 4; };

  bool useInDiMuonTrigger() const { return (quality() >= 3) && (quality() != 4); };

  bool isMatchedCand() const { return quality() == 7; }

  bool isHaloCand() const { return quality() == 1; }

  unsigned int etaIndex() const { return readDataField(ETA_START, ETA_LENGTH); }

  unsigned sysign() const { return readDataField(SYSIGN_START, SYSIGN_LENGTH); }

  bool isol() const { return readDataField(ISO_START, ISO_LENGTH) == 1; }

  bool mip() const { return readDataField(MIP_START, MIP_LENGTH) == 1; }

  int bx() const { return m_bx; }

  float phiValue() const;

  float etaValue() const;

  float ptValue() const;

  int charge() const { return (readDataField(SYSIGN_START, SYSIGN_LENGTH) & 1) == 0 ? 1 : -1; }

  bool charge_valid() const {
    unsigned sysign = readDataField(SYSIGN_START, SYSIGN_LENGTH);
    return (sysign == 0 || sysign == 1);
  }

  bool isSyncWord() const { return readDataField(SYSIGN_START, SYSIGN_LENGTH) == 3; }


  void setPhiPacked(unsigned phi) { writeDataField(PHI_START, PHI_LENGTH, phi); }

  void setPtPacked(unsigned pt) { writeDataField(PT_START, PT_LENGTH, pt); }

  void setQuality(unsigned quality) { writeDataField(QUAL_START, QUAL_LENGTH, quality); }

  void setEtaPacked(unsigned eta) { writeDataField(ETA_START, ETA_LENGTH, eta); }

  void setIsolation(bool isol) { writeDataField(ISO_START, ISO_LENGTH, isol ? 1 : 0); }

  void setMIP(bool mip) { writeDataField(MIP_START, MIP_LENGTH, mip ? 1 : 0); }

  void setChargePacked(unsigned ch) { writeDataField(SYSIGN_START, SYSIGN_LENGTH, ch); }

  void setBx(int bx) { m_bx = bx; }


  void setPhiValue(float phiVal) { m_phiValue = phiVal; }

  void setPtValue(float ptVal) { m_ptValue = ptVal; }

  void setEtaValue(float etaVal) { m_etaValue = etaVal; }

  //
  // Other
  //

  unsigned int linearizedPt(float lsbValue, unsigned maxScale) const { return 0; }

  unsigned int etaRegionIndex() const { return etaIndex(); }

  unsigned int phiRegionIndex() const { return phiIndex(); }

  bool operator==(const L1MuGMTCand&) const;

  bool operator!=(const L1MuGMTCand&) const;

  void print() const;

  friend std::ostream& operator<<(std::ostream&, const L1MuGMTCand&);

protected:
protected:
  inline unsigned readDataField(unsigned start, unsigned count) const;
  inline void writeDataField(unsigned start, unsigned count, unsigned value);

  std::string m_name;
  int m_bx;             // in here only for technical reasons in simulation
  unsigned m_dataWord;  // muon data word (26 bits) :

  float m_phiValue;
  float m_etaValue;
  float m_ptValue;
  static const float m_invalidValue;

  // definition of the bit fields
  enum { PHI_START = 0 };
  enum { PHI_LENGTH = 8 };  // Bits 0:7   phi (8 bits)
  enum { PT_START = 8 };
  enum { PT_LENGTH = 5 };  // Bits 8:12  pt  (5 bits)
  enum { QUAL_START = 13 };
  enum { QUAL_LENGTH = 3 };  // Bits 13:15 quality (3 bits)
  enum { ETA_START = 16 };
  enum { ETA_LENGTH = 6 };  // Bits 16:21 eta (6 bits)
  enum { ISO_START = 22 };
  enum { ISO_LENGTH = 1 };  // Bit  22    Isolation
  enum { MIP_START = 23 };
  enum { MIP_LENGTH = 1 };  // Bit  23    MIP
  enum { SYSIGN_START = 24 };
  enum { SYSIGN_LENGTH = 2 };  // Bit  24:25 Charge/Syncword
};

unsigned L1MuGMTCand::readDataField(unsigned start, unsigned count) const {
  unsigned mask = ((1 << count) - 1) << start;
  return (m_dataWord & mask) >> start;
}

void L1MuGMTCand::writeDataField(unsigned start, unsigned count, unsigned value) {
  unsigned mask = ((1 << count) - 1) << start;
  m_dataWord &= ~mask;  // clear
  m_dataWord |= (value << start) & mask;
}

#endif