SimpleL1MuGMTCand.h

Go to the documentation of this file.

#ifndef SIMPLEL1MU_GMT_CAND_H
#define SIMPLEL1MU_GMT_CAND_H

#include <DataFormats/L1GlobalMuonTrigger/interface/L1MuGMTExtendedCand.h>

#include "DataFormats/Math/interface/LorentzVector.h"

class SimTrack;

namespace HepMC { 
  class GenParticle;
}

class SimpleL1MuGMTCand : public L1MuGMTExtendedCand {

  public:

  typedef math::XYZTLorentzVector LorentzVector;

    SimpleL1MuGMTCand();
   
    SimpleL1MuGMTCand(const SimpleL1MuGMTCand&);
    
    SimpleL1MuGMTCand(const SimpleL1MuGMTCand*);
    
    SimpleL1MuGMTCand(const SimTrack*);

    SimpleL1MuGMTCand(const SimTrack* p,
              unsigned etaIndex, 
              unsigned phiIndex,
              unsigned pTIndex,
              float etaValue,
              float phiValue,
              float pTValue);    

    virtual ~SimpleL1MuGMTCand();

    void reset();

    inline std::string name() const { return m_name; }

    inline unsigned int phi() const { return m_phi; }
    
    inline unsigned int eta() const { return m_eta; }
    
    inline unsigned int pt() const { return m_pt; }
    
    inline int charge() const { return m_charge; }
    
    inline unsigned int rank() const { return m_rank; }
     
    inline bool empty() const { return m_empty; }

    inline void enable() { m_empty = false; }

    inline void disable() { m_empty = true; }
    
    void setPhi(float phi);
    
    void setEta(float eta);
    
    void setPt(float pt);
    
    void setCharge(int charge);
    
    inline void setRank(unsigned int rank) { m_rank = rank; }
    
    float smearedPt() const { return m_smearedPt; }
    
    inline unsigned int linearizedPt(float lsbValue, unsigned maxScale) const { return 0; }

    inline unsigned int quality() const { return m_quality; }

    unsigned int etaRegionIndex() const { return eta(); }

    unsigned int phiRegionIndex() const { return phi(); }

    // set and get the 4-momentum of the original (generator) particle
    void setMomentum(LorentzVector m) { myMomentum = m; }
    const LorentzVector getMomentum() const { return myMomentum; }

    SimpleL1MuGMTCand& operator=(const SimpleL1MuGMTCand&);

    SimpleL1MuGMTCand* operator=(const SimTrack*);

    bool operator==(const SimpleL1MuGMTCand&) const;
    
    bool operator!=(const SimpleL1MuGMTCand&) const;

    void print() const;
  
    friend std::ostream& operator<<(std::ostream&, const SimpleL1MuGMTCand&);

    class Rank : std::binary_function< const SimpleL1MuGMTCand*, const SimpleL1MuGMTCand*, bool> {
      public :
        bool operator()( const SimpleL1MuGMTCand* first, const SimpleL1MuGMTCand* second ) const {
          unsigned int rank_f = (first) ? first->rank(): 0;
          unsigned int rank_s = (second) ? second->rank() : 0;
          return rank_f > rank_s;
        }
    };

    static const float ptScale[32];
    static const float etaScale[63];
    static const float phiScale[144];

  private:

    std::string  m_name;
    bool     m_empty;

    unsigned int m_phi;
    unsigned int m_eta;
    unsigned int m_pt;
    int          m_charge;
    unsigned int m_quality;
    unsigned int m_rank;
    float        m_smearedPt;

    LorentzVector myMomentum ;

};
  
#endif