|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
|
#ifndef JetReco_PFJet_h
#define JetReco_PFJet_h
/** \class reco::PFJet
*
* \short Jets made from PFObjects
*
* PFJet represents Jets made from Particle Flow objects
* Provide energy contributions from different PF types
* in addition to generic Jet parameters
*
* \author Fedor Ratnikov, UMd, Apr 24, 2007
************************************************************/
#include "DataFormats/JetReco/interface/Jet.h"
#include "DataFormats/ParticleFlowCandidate/interface/PFCandidateFwd.h"
#include "DataFormats/TrackReco/interface/TrackFwd.h"
namespace reco {
class PFJet : public Jet {
public:
typedef reco::PFCandidatePtr ConstituentTypePtr;
typedef reco::PFCandidateFwdPtr ConstituentTypeFwdPtr;
struct Specific {
Specific()
: mChargedHadronEnergy(0),
mNeutralHadronEnergy(0),
mPhotonEnergy(0),
mElectronEnergy(0),
mMuonEnergy(0),
mHFHadronEnergy(0),
mHFEMEnergy(0),
mChargedHadronMultiplicity(0),
mNeutralHadronMultiplicity(0),
mPhotonMultiplicity(0),
mElectronMultiplicity(0),
mMuonMultiplicity(0),
mHFHadronMultiplicity(0),
mHFEMMultiplicity(0),
mChargedEmEnergy(0),
mChargedMuEnergy(0),
mNeutralEmEnergy(0),
mChargedMultiplicity(0),
mNeutralMultiplicity(0),
mHOEnergy(0) {}
float mChargedHadronEnergy;
float mNeutralHadronEnergy;
float mPhotonEnergy;
float mElectronEnergy;
float mMuonEnergy;
float mHFHadronEnergy;
float mHFEMEnergy;
int mChargedHadronMultiplicity;
int mNeutralHadronMultiplicity;
int mPhotonMultiplicity;
int mElectronMultiplicity;
int mMuonMultiplicity;
int mHFHadronMultiplicity;
int mHFEMMultiplicity;
//old (deprecated) data members
//kept only for backwards compatibility:
float mChargedEmEnergy;
float mChargedMuEnergy;
float mNeutralEmEnergy;
int mChargedMultiplicity;
int mNeutralMultiplicity;
float mHOEnergy;
};
/** Default constructor*/
PFJet() {}
/** Constructor from values*/
PFJet(const LorentzVector& fP4,
const Point& fVertex,
const Specific& fSpecific,
const Jet::Constituents& fConstituents);
PFJet(const LorentzVector& fP4, const Point& fVertex, const Specific& fSpecific);
/** backward compatible, vertex=(0,0,0) */
PFJet(const LorentzVector& fP4, const Specific& fSpecific, const Jet::Constituents& fConstituents);
~PFJet() override {}
/// chargedHadronEnergy
float chargedHadronEnergy() const { return m_specific.mChargedHadronEnergy; }
/// chargedHadronEnergyFraction
float chargedHadronEnergyFraction() const { return chargedHadronEnergy() / energy(); }
/// neutralHadronEnergy
float neutralHadronEnergy() const { return m_specific.mNeutralHadronEnergy; }
/// neutralHadronEnergyFraction
float neutralHadronEnergyFraction() const { return neutralHadronEnergy() / energy(); }
/// photonEnergy
float photonEnergy() const { return m_specific.mPhotonEnergy; }
/// photonEnergyFraction
float photonEnergyFraction() const { return photonEnergy() / energy(); }
/// electronEnergy
float electronEnergy() const { return m_specific.mElectronEnergy; }
/// electronEnergyFraction
float electronEnergyFraction() const { return electronEnergy() / energy(); }
/// muonEnergy
float muonEnergy() const { return m_specific.mMuonEnergy; }
/// muonEnergyFraction
float muonEnergyFraction() const { return muonEnergy() / energy(); }
/// HFHadronEnergy
float HFHadronEnergy() const { return m_specific.mHFHadronEnergy; }
/// HFHadronEnergyFraction
float HFHadronEnergyFraction() const { return HFHadronEnergy() / energy(); }
/// HFEMEnergy
float HFEMEnergy() const { return m_specific.mHFEMEnergy; }
/// HFEMEnergyFraction
float HFEMEnergyFraction() const { return HFEMEnergy() / energy(); }
/// chargedHadronMultiplicity
int chargedHadronMultiplicity() const { return m_specific.mChargedHadronMultiplicity; }
/// neutralHadronMultiplicity
int neutralHadronMultiplicity() const { return m_specific.mNeutralHadronMultiplicity; }
/// photonMultiplicity
int photonMultiplicity() const { return m_specific.mPhotonMultiplicity; }
/// electronMultiplicity
int electronMultiplicity() const { return m_specific.mElectronMultiplicity; }
/// muonMultiplicity
int muonMultiplicity() const { return m_specific.mMuonMultiplicity; }
/// HFHadronMultiplicity
int HFHadronMultiplicity() const { return m_specific.mHFHadronMultiplicity; }
/// HFEMMultiplicity
int HFEMMultiplicity() const { return m_specific.mHFEMMultiplicity; }
/// chargedEmEnergy
float chargedEmEnergy() const { return m_specific.mChargedEmEnergy; }
/// chargedEmEnergyFraction
float chargedEmEnergyFraction() const { return chargedEmEnergy() / energy(); }
/// chargedMuEnergy
float chargedMuEnergy() const { return m_specific.mChargedMuEnergy; }
/// chargedMuEnergyFraction
float chargedMuEnergyFraction() const { return chargedMuEnergy() / energy(); }
/// neutralEmEnergy
float neutralEmEnergy() const { return m_specific.mNeutralEmEnergy; }
/// neutralEmEnergyFraction
float neutralEmEnergyFraction() const { return neutralEmEnergy() / energy(); }
/// chargedMultiplicity
int chargedMultiplicity() const { return m_specific.mChargedMultiplicity; }
/// neutralMultiplicity
int neutralMultiplicity() const { return m_specific.mNeutralMultiplicity; }
/// hoEnergy
float hoEnergy() const { return m_specific.mHOEnergy; }
/// hoEnergyFraction
float hoEnergyFraction() const { return hoEnergy() / energy(); }
/// get specific constituent
virtual reco::PFCandidatePtr getPFConstituent(unsigned fIndex) const;
/// get all constituents
virtual std::vector<reco::PFCandidatePtr> getPFConstituents() const;
/// \ brief get all tracks in the jets
/// All PFCandidates hold a reference to a track. All the non-null
/// references are added to the returned TrackRefVector
reco::TrackRefVector getTrackRefs() const;
// block accessors
const Specific& getSpecific() const { return m_specific; }
/// Polymorphic clone
PFJet* clone() const override;
/// Print object in details
std::string print() const override;
private:
/// Polymorphic overlap
bool overlap(const Candidate&) const override;
//Variables specific to to the PFJet class
Specific m_specific;
};
// streamer
std::ostream& operator<<(std::ostream& out, const reco::PFJet& jet);
} // namespace reco
// temporary fix before include_checcker runs globally
#include "DataFormats/JetReco/interface/PFJetCollection.h" //INCLUDECHECKER:SKIP
#endif
|