HbbAnalysis/interface/Muon.hh

#ifndef HbbAnalysis_Muon_hh
#define HbbAnalysis_Muon_hh

#include <vector>
#include <string>

#include "UserCode/HbbAnalysis/interface/Objects.hh"

namespace HbbAnalysis {

  class Muon {

  public:

    /** Constructors */

    Muon(){
      //Clear();
    };

    ~Muon(){};

    Muon(const HbbAnalysis::GenVars & aGen,
         const HbbAnalysis::BaseVars & aReco,
         const HbbAnalysis::MuTrkVars & aTrk,
         const HbbAnalysis::MuIsoVars & aIsoR03,
         const HbbAnalysis::MuIsoVars & aIsoR05,
         const HbbAnalysis::MuIDVars & aID
         ){
      Clear();
      genVars(aGen);
      recoVars(aReco);
      trkVars(aTrk);
      isoR03Vars(aIsoR03);
      isoR05Vars(aIsoR05);
      idVars(aID);

    };

    inline const HbbAnalysis::GenVars & genVars() const {
      return gen_;
    };

    inline const HbbAnalysis::BaseVars  & recoVars() const {
      return reco_;
    };

    inline const HbbAnalysis::MuTrkVars  & trkVars() const {
      return trk_;
    };

    inline const HbbAnalysis::MuIsoVars  & isoR03Vars() const {
      return isoR03_;
    };

    inline const HbbAnalysis::MuIsoVars  & isoR05Vars() const {
      return isoR05_;
    };

    inline const HbbAnalysis::MuIDVars  & idVars() const {
      return id_;
    };

    inline void genVars(const HbbAnalysis::GenVars & aGen) {
      gen_ = aGen;
    };

    inline void recoVars(const HbbAnalysis::BaseVars & aReco) {
      reco_ = aReco;
    };

    inline void trkVars(const HbbAnalysis::MuTrkVars & aTrk) {
      trk_ = aTrk;
    };

    inline void isoR03Vars(const HbbAnalysis::MuIsoVars & aIso) {
      isoR03_ = aIso;
    };

    inline void isoR05Vars(const HbbAnalysis::MuIsoVars & aIso) {
      isoR05_ = aIso;
    };

    inline void idVars(const HbbAnalysis::MuIDVars & aID) {
      id_ = aID;
    };
    //id.type == (recoMuon->isCaloMuon()<<3) | (recoMuon->isStandAloneMuon()<<2) | (recoMuon->isTrackerMuon()<<1) | recoMuon->isGlobalMuon()
    inline bool isGlobalMu() {
      return (id_.type & 0x1);
    };

    inline bool isTrackerMu() {
      return (id_.type & 0x2) >> 1;
    };

    inline bool isStandAloneMu(){
      return (id_.type & 0x4) >> 2;
    };

    inline bool isCaloMu(){
      return (id_.type & 0x8) >> 3;
    };

    inline void Clear(){
      gen_.valid = false;
      gen_.E = 0;
      gen_.pT = 0;
      gen_.eta = 0;
      gen_.y = 0;
      gen_.phi = 0;
      gen_.charge = 0;
      gen_.pdgId = 0;
      gen_.status = 0;
      gen_.mass = 0;
      gen_.vx = 0;
      gen_.vy = 0;
      gen_.vz = 0;
 
      reco_.E = 0;
      reco_.pT = 0;
      reco_.y = 0;
      reco_.eta = 0;
      reco_.phi = 0;
      reco_.charge = 0;
      reco_.vx = 0;
      reco_.vy = 0;
      reco_.vz = 0;

      trk_.dxy = 0;
      trk_.dz = 0;
      trk_.normalizedChi2 = 0;
      trk_.muonHits = 0;
      trk_.charge = 0;
      trk_.trackerHits = 0;
      trk_.pixelHits = 0;

      isoR03_.sumPt = 0;
      isoR03_.emEt = 0;
      isoR03_.hadEt = 0;
      isoR03_.nTracks = 0;
      isoR03_.nJets = 0;

      isoR05_.sumPt = 0;
      isoR05_.emEt = 0;
      isoR05_.hadEt = 0;
      isoR05_.nTracks = 0;
      isoR05_.nJets = 0;

      id_.type = 0;
      id_.ids.clear();
      id_.caloCompat = 0;
      id_.segCompat = 0;
      id_.nChambers = 0;
      id_.nMatchesLoose = 0;
      id_.nMatchesMedium = 0;
      id_.nMatchesTight = 0;
    };

  private:

    HbbAnalysis::GenVars gen_;
    HbbAnalysis::BaseVars reco_;
    HbbAnalysis::MuTrkVars trk_;
    HbbAnalysis::MuIsoVars isoR03_;
    HbbAnalysis::MuIsoVars isoR05_;
    HbbAnalysis::MuIDVars id_;

  };

  inline bool operator < (const Muon & one, const Muon & two) 
  {
    return one.recoVars().pT < two.recoVars().pT;
  }
  
  
}//namespace
#endif
Revision:	1.7
Committed:	Mon Sep 27 10:40:53 2010 UTC (14 years, 7 months ago) by amagnan
Content type:	text/plain
Branch:	MAIN
Changes since 1.6:	+16 -0 lines
Log Message:	add muon type decoding variables
#	User	Rev	Content
1	amagnan	1.1	#ifndef HbbAnalysis_Muon_hh
2			#define HbbAnalysis_Muon_hh
3
4			#include <vector>
5			#include <string>
6
7			#include "UserCode/HbbAnalysis/interface/Objects.hh"
8
9			namespace HbbAnalysis {
10
11			class Muon {
12
13			public:
14
15			/** Constructors */
16
17			Muon(){
18			//Clear();
19			};
20
21			~Muon(){};
22
23			Muon(const HbbAnalysis::GenVars & aGen,
24			const HbbAnalysis::BaseVars & aReco,
25	amagnan	1.3	const HbbAnalysis::MuTrkVars & aTrk,
26	amagnan	1.1	const HbbAnalysis::MuIsoVars & aIsoR03,
27			const HbbAnalysis::MuIsoVars & aIsoR05,
28			const HbbAnalysis::MuIDVars & aID
29			){
30			Clear();
31			genVars(aGen);
32			recoVars(aReco);
33	amagnan	1.3	trkVars(aTrk);
34	amagnan	1.1	isoR03Vars(aIsoR03);
35			isoR05Vars(aIsoR05);
36			idVars(aID);
37
38			};
39
40			inline const HbbAnalysis::GenVars & genVars() const {
41			return gen_;
42			};
43
44			inline const HbbAnalysis::BaseVars & recoVars() const {
45			return reco_;
46			};
47
48	amagnan	1.3	inline const HbbAnalysis::MuTrkVars & trkVars() const {
49			return trk_;
50			};
51
52	amagnan	1.1	inline const HbbAnalysis::MuIsoVars & isoR03Vars() const {
53			return isoR03_;
54			};
55
56			inline const HbbAnalysis::MuIsoVars & isoR05Vars() const {
57			return isoR05_;
58			};
59
60			inline const HbbAnalysis::MuIDVars & idVars() const {
61			return id_;
62			};
63
64			inline void genVars(const HbbAnalysis::GenVars & aGen) {
65			gen_ = aGen;
66			};
67
68			inline void recoVars(const HbbAnalysis::BaseVars & aReco) {
69			reco_ = aReco;
70			};
71
72	amagnan	1.3	inline void trkVars(const HbbAnalysis::MuTrkVars & aTrk) {
73			trk_ = aTrk;
74			};
75
76	amagnan	1.1	inline void isoR03Vars(const HbbAnalysis::MuIsoVars & aIso) {
77			isoR03_ = aIso;
78			};
79
80			inline void isoR05Vars(const HbbAnalysis::MuIsoVars & aIso) {
81			isoR05_ = aIso;
82			};
83
84			inline void idVars(const HbbAnalysis::MuIDVars & aID) {
85			id_ = aID;
86			};
87	amagnan	1.7	//id.type == (recoMuon->isCaloMuon()<<3) \| (recoMuon->isStandAloneMuon()<<2) \| (recoMuon->isTrackerMuon()<<1) \| recoMuon->isGlobalMuon()
88			inline bool isGlobalMu() {
89			return (id_.type & 0x1);
90			};
91
92			inline bool isTrackerMu() {
93			return (id_.type & 0x2) >> 1;
94			};
95
96			inline bool isStandAloneMu(){
97			return (id_.type & 0x4) >> 2;
98			};
99
100			inline bool isCaloMu(){
101			return (id_.type & 0x8) >> 3;
102			};
103	amagnan	1.1
104			inline void Clear(){
105			gen_.valid = false;
106	amagnan	1.2	gen_.E = 0;
107	amagnan	1.1	gen_.pT = 0;
108			gen_.eta = 0;
109	amagnan	1.4	gen_.y = 0;
110	amagnan	1.1	gen_.phi = 0;
111			gen_.charge = 0;
112			gen_.pdgId = 0;
113			gen_.status = 0;
114			gen_.mass = 0;
115			gen_.vx = 0;
116			gen_.vy = 0;
117			gen_.vz = 0;
118
119	amagnan	1.2	reco_.E = 0;
120	amagnan	1.1	reco_.pT = 0;
121	amagnan	1.4	reco_.y = 0;
122	amagnan	1.1	reco_.eta = 0;
123			reco_.phi = 0;
124			reco_.charge = 0;
125			reco_.vx = 0;
126			reco_.vy = 0;
127			reco_.vz = 0;
128
129	amagnan	1.5	trk_.dxy = 0;
130			trk_.dz = 0;
131			trk_.normalizedChi2 = 0;
132			trk_.muonHits = 0;
133			trk_.charge = 0;
134			trk_.trackerHits = 0;
135	amagnan	1.6	trk_.pixelHits = 0;
136	amagnan	1.3
137	amagnan	1.1	isoR03_.sumPt = 0;
138			isoR03_.emEt = 0;
139			isoR03_.hadEt = 0;
140			isoR03_.nTracks = 0;
141			isoR03_.nJets = 0;
142
143			isoR05_.sumPt = 0;
144			isoR05_.emEt = 0;
145			isoR05_.hadEt = 0;
146			isoR05_.nTracks = 0;
147			isoR05_.nJets = 0;
148
149			id_.type = 0;
150			id_.ids.clear();
151			id_.caloCompat = 0;
152			id_.segCompat = 0;
153			id_.nChambers = 0;
154			id_.nMatchesLoose = 0;
155			id_.nMatchesMedium = 0;
156			id_.nMatchesTight = 0;
157			};
158
159			private:
160
161			HbbAnalysis::GenVars gen_;
162			HbbAnalysis::BaseVars reco_;
163	amagnan	1.3	HbbAnalysis::MuTrkVars trk_;
164	amagnan	1.1	HbbAnalysis::MuIsoVars isoR03_;
165			HbbAnalysis::MuIsoVars isoR05_;
166			HbbAnalysis::MuIDVars id_;
167
168			};
169
170			inline bool operator < (const Muon & one, const Muon & two)
171			{
172			return one.recoVars().pT < two.recoVars().pT;
173			}
174
175
176			}//namespace
177			#endif