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&);
 
  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