L1MuRegionalCand.h

Go to the documentation of this file.

//-------------------------------------------------
//
//
//   $Date: 2007/10/18 12:19:14 $
//   $Revision: 1.3 $
//
//   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