RegionalMuonCand.h

Go to the documentation of this file.

#ifndef __l1t_regional_muon_candidate_h__
#define __l1t_regional_muon_candidate_h__

#include "RegionalMuonCandFwd.h"
#include <map>

namespace l1t {
  class RegionalMuonCand {
  public:
    enum bmtfAddress {
      kWheelSide = 0,
      kWheelNum = 1,
      kStat1 = 2,
      kStat2 = 3,
      kStat3 = 4,
      kStat4 = 5,
      kSegSelStat1 = 6,
      kSegSelStat2 = 7,
      kSegSelStat3 = 8,
      kSegSelStat4 = 9,
      kNumBmtfSubAddr = 10
    };
    enum omtfAddress { kLayers = 0, kZero = 1, kWeight = 2, kNumOmtfSubAddr = 3 };
    enum emtfAddress {
      kME1Seg = 0,
      kME1Ch = 1,
      kME2Seg = 2,
      kME2Ch = 3,
      kME3Seg = 4,
      kME3Ch = 5,
      kME4Seg = 6,
      kME4Ch = 7,
      kTrkNum = 8,
      kBX = 9,
      kNumEmtfSubAddr = 10
    };

    explicit RegionalMuonCand(uint64_t dataword);

    RegionalMuonCand()
        : m_hwPt(0),
          m_hwPtUnconstrained(0),
          m_hwDXY(0),
          m_hwPhi(0),
          m_hwEta(0),
          m_hwHF(false),
          m_hwSign(0),
          m_hwSignValid(0),
          m_hwQuality(0),
          m_dataword(0) {
      setTFIdentifiers(0, bmtf);
    };

    RegionalMuonCand(int pt, int phi, int eta, int sign, int signvalid, int quality, int processor, tftype trackFinder)
        : m_hwPt(pt),
          m_hwPtUnconstrained(0),
          m_hwDXY(0),
          m_hwPhi(phi),
          m_hwEta(eta),
          m_hwHF(false),
          m_hwSign(sign),
          m_hwSignValid(signvalid),
          m_hwQuality(quality),
          m_dataword(0) {
      setTFIdentifiers(processor, trackFinder);
      // set default track addresses
      if (trackFinder == tftype::bmtf) {
        m_trackAddress = {{kWheelSide, 0},
                          {kWheelNum, 0},
                          {kStat1, 0},
                          {kStat2, 0},
                          {kStat3, 0},
                          {kStat4, 0},
                          {kSegSelStat1, 0},
                          {kSegSelStat2, 0},
                          {kSegSelStat3, 0},
                          {kSegSelStat4, 0}};
      } else if (trackFinder == tftype::omtf_pos || trackFinder == tftype::omtf_neg) {
        m_trackAddress = {{kLayers, 0}, {kZero, 0}, {kWeight, 0}};
      } else if (trackFinder == tftype::emtf_pos || trackFinder == tftype::emtf_neg) {
        m_trackAddress = {{kME1Seg, 0},
                          {kME1Ch, 0},
                          {kME2Seg, 0},
                          {kME2Ch, 0},
                          {kME3Seg, 0},
                          {kME3Ch, 0},
                          {kME4Seg, 0},
                          {kME4Ch, 0},
                          {kTrkNum, 0},
                          {kBX, 0}};
      }
    };

    RegionalMuonCand(int pt,
                     int phi,
                     int eta,
                     int sign,
                     int signvalid,
                     int quality,
                     int processor,
                     tftype trackFinder,
                     std::map<int, int> trackAddress)
        : m_hwPt(pt),
          m_hwPtUnconstrained(0),
          m_hwDXY(0),
          m_hwPhi(phi),
          m_hwEta(eta),
          m_hwHF(false),
          m_hwSign(sign),
          m_hwSignValid(signvalid),
          m_hwQuality(quality),
          m_trackAddress(trackAddress),
          m_dataword(0) {
      setTFIdentifiers(processor, trackFinder);
    };

    virtual ~RegionalMuonCand(){};

    void setHwPt(int bits) { m_hwPt = bits; };
    void setHwPtUnconstrained(int bits) { m_hwPtUnconstrained = bits; };
    void setHwDXY(int bits) { m_hwDXY = bits; };
    void setHwPhi(int bits) { m_hwPhi = bits; };
    void setHwEta(int bits) { m_hwEta = bits; };
    void setHwSign(int bits) { m_hwSign = bits; };
    void setHwSignValid(int bits) { m_hwSignValid = bits; };
    void setHwQual(int bits) { m_hwQuality = bits; };
    void setHwHF(bool bit) { m_hwHF = bit; };
    void setTFIdentifiers(int processor, tftype trackFinder);
    // this is left to still be compatible with OMTF
    void setLink(int link) { m_link = link; };
    // Set the 64 bit word from two 32 words. bits 0-31->lsbs, bits 32-63->msbs
    void setDataword(uint32_t msbs, uint32_t lsbs) { m_dataword = (((uint64_t)msbs) << 32) + lsbs; };
    // Set the 64 bit word coming from HW directly
    void setDataword(uint64_t bits) { m_dataword = bits; };
    void setTrackSubAddress(bmtfAddress subAddress, int value) { m_trackAddress[subAddress] = value; }
    void setTrackSubAddress(omtfAddress subAddress, int value) { m_trackAddress[subAddress] = value; }
    void setTrackSubAddress(emtfAddress subAddress, int value) { m_trackAddress[subAddress] = value; }
    void setTrackAddress(const std::map<int, int>& address) { m_trackAddress = address; }

    const int hwPt() const { return m_hwPt; };
    const int hwPtUnconstrained() const { return m_hwPtUnconstrained; };
    const int hwDXY() const { return m_hwDXY; };
    const int hwPhi() const { return m_hwPhi; };
    const int hwEta() const { return m_hwEta; };
    const int hwSign() const { return m_hwSign; };
    const int hwSignValid() const { return m_hwSignValid; };
    const int hwQual() const { return m_hwQuality; };
    const int link() const { return m_link; };
    const int processor() const { return m_processor; };
    const tftype trackFinderType() const { return m_trackFinder; };
    const int hwHF() const { return m_hwHF; };
    const uint64_t dataword() const { return m_dataword; };
    const uint32_t dataword32Msb() const { return (uint32_t)((m_dataword >> 32) & 0xFFFFFFFF); };
    const uint32_t dataword32Lsb() const { return (uint32_t)(m_dataword & 0xFFFFFFFF); };
    const std::map<int, int>& trackAddress() const { return m_trackAddress; }
    int trackSubAddress(bmtfAddress subAddress) const { return m_trackAddress.at(subAddress); }
    int trackSubAddress(omtfAddress subAddress) const { return m_trackAddress.at(subAddress); }
    int trackSubAddress(emtfAddress subAddress) const { return m_trackAddress.at(subAddress); }

    bool operator==(const RegionalMuonCand& rhs) const;
    inline bool operator!=(const RegionalMuonCand& rhs) const { return !(operator==(rhs)); };

  private:
    int m_hwPt;
    int m_hwPtUnconstrained;
    int m_hwDXY;
    int m_hwPhi;
    int m_hwEta;
    bool m_hwHF;
    int m_hwSign;
    int m_hwSignValid;
    int m_hwQuality;
    int m_link;
    int m_processor;
    tftype m_trackFinder;
    std::map<int, int> m_trackAddress;

    uint64_t m_dataword;
  };

}  // namespace l1t

#endif /* define __l1t_regional_muon_candidate_h__ */