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