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);
 
  ~SimpleL1MuGMTCand() override;
 
  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(const 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&);
 
  bool getRank(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