L1MuRegionalCand.h

Go to the documentation of this file.

//-------------------------------------------------
//
//
//
//   Author :
//   H. Sakulin                    HEPHY Vienna
//
//   Migrated to CMSSW:
//   I. Mikulec
//
//--------------------------------------------------
#ifndef DataFormatsL1GlobalMuonTrigger_L1MuRegionalCand_h
#define DataFormatsL1GlobalMuonTrigger_L1MuRegionalCand_h

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

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

class L1MuRegionalCand {
public:
  L1MuRegionalCand(unsigned dataword = 0, int bx = 0);

  L1MuRegionalCand(unsigned type_idx,
                   unsigned phi,
                   unsigned eta,
                   unsigned pt,
                   unsigned charge,
                   unsigned ch_valid,
                   unsigned finehalo,
                   unsigned quality,
                   int bx);

  virtual ~L1MuRegionalCand() {}


  virtual bool empty() const {
    return (readDataField(PT_START, PT_LENGTH) == 0) || (readDataField(PHI_START, PHI_LENGTH) == 0xff);
  }

  float phiValue() const;

  float etaValue() const;

  float ptValue() const;

  int chargeValue() const { return readDataField(CHARGE_START, CHARGE_LENGTH) == 0 ? 1 : -1; }

  bool chargeValid() const { return charge_valid_packed() == 1; }

  bool isFineHalo() const { return finehalo_packed() == 1; }

  unsigned int quality() const { return quality_packed(); }

  unsigned type_idx() const { return (int)readDataField(TYPE_START, TYPE_LENGTH); };

  int bx() const { return m_bx; }


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

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

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

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

  unsigned finehalo_packed() const { return readDataField(FINEHALO_START, FINEHALO_LENGTH); }

  unsigned charge_packed() const { return readDataField(CHARGE_START, CHARGE_LENGTH); }

  unsigned charge_valid_packed() const { return readDataField(CHVALID_START, CHVALID_LENGTH); }

  unsigned getDataWord() const { return m_dataWord; };


  void setType(unsigned type) { writeDataField(TYPE_START, TYPE_LENGTH, type); }

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

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

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

  void setQualityPacked(unsigned qual) { writeDataField(QUAL_START, QUAL_LENGTH, qual); }

  void setChargePacked(unsigned ch) { writeDataField(CHARGE_START, CHARGE_LENGTH, ch); }

  void setChargeValidPacked(unsigned valid) { writeDataField(CHVALID_START, CHVALID_LENGTH, valid); }

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

  void setFineHaloPacked(unsigned fh) { writeDataField(FINEHALO_START, FINEHALO_LENGTH, fh); }


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

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

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

  void setChargeValue(int charge) { writeDataField(CHARGE_START, CHARGE_LENGTH, charge == 1 ? 0 : 1); }

  void setChargeValid(bool valid) { writeDataField(CHVALID_START, CHVALID_LENGTH, valid ? 1 : 0); }

  void setFineHalo(bool fh) { writeDataField(FINEHALO_START, FINEHALO_LENGTH, fh ? 1 : 0); }

  virtual void reset();

  void setDataWord(unsigned dataword) { m_dataWord = dataword; }

  virtual void print() const;

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

private:
  int m_bx;
  unsigned m_dataWord;  // muon data word (25 bits) :

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

public:
  // 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 { FINEHALO_START = 22 };
  enum { FINEHALO_LENGTH = 1 };  // Bit  22 Eta is fine (DT) / Halo (CSC)
  enum { CHARGE_START = 23 };
  enum { CHARGE_LENGTH = 1 };  // Bit  23 Charge: 0 = positive
  enum { CHVALID_START = 24 };
  enum {
    CHVALID_LENGTH = 1
  };  // Bit  24 Charge is vaild (1=valid)
      // Bits 26 to 29: Synchronization

  enum { TYPE_START = 30 };
  enum {
    TYPE_LENGTH = 2
  };  // Bit  30/31 type DT, bRPC, CSC, fRPC
      // these bits are not sent to the GMT in hardware
};
#endif