File indexing completed on 2024-04-06 12:04:53
0001
0002
0003
0004 #ifndef DataFormats_PatCandidates_GenericParticle_h
0005 #define DataFormats_PatCandidates_GenericParticle_h
0006
0007
0008
0009
0010
0011
0012
0013
0014
0015
0016
0017 #include "DataFormats/PatCandidates/interface/PATObject.h"
0018 #include "DataFormats/RecoCandidate/interface/RecoCandidate.h"
0019 #include "DataFormats/EgammaReco/interface/SuperClusterFwd.h"
0020 #include "DataFormats/EgammaReco/interface/SuperCluster.h"
0021 #include "DataFormats/GsfTrackReco/interface/GsfTrackFwd.h"
0022 #include "DataFormats/GsfTrackReco/interface/GsfTrack.h"
0023 #include "DataFormats/PatCandidates/interface/Isolation.h"
0024 #include "DataFormats/PatCandidates/interface/Vertexing.h"
0025 #include "DataFormats/HepMCCandidate/interface/GenParticle.h"
0026
0027
0028 namespace pat {
0029 class GenericParticle;
0030 typedef std::vector<GenericParticle> GenericParticleCollection;
0031 typedef edm::Ref<GenericParticleCollection> GenericParticleRef;
0032 typedef edm::RefVector<GenericParticleCollection> GenericParticleRefVector;
0033 }
0034
0035
0036 namespace pat {
0037
0038 class GenericParticle : public PATObject<reco::RecoCandidate> {
0039 public:
0040
0041 GenericParticle();
0042
0043 GenericParticle(const reco::Candidate &aGenericParticle);
0044
0045 GenericParticle(const edm::RefToBase<reco::Candidate> &aGenericParticleRef);
0046
0047 GenericParticle(const edm::Ptr<reco::Candidate> &aGenericParticleRef);
0048
0049 ~GenericParticle() override;
0050
0051
0052 GenericParticle *clone() const override { return new GenericParticle(*this); }
0053
0054
0055
0056
0057
0058 bool overlap(const Candidate &) const override;
0059
0060
0061
0062 reco::TrackRef track() const override { return track_.empty() ? trackRef_ : reco::TrackRef(&track_, 0); }
0063
0064
0065 reco::TrackRef track(size_t idx) const override {
0066 if (idx >= numberOfTracks())
0067 throw cms::Exception("Index out of bounds")
0068 << "Requested track " << idx << " out of " << numberOfTracks() << ".\n";
0069 return (tracks_.empty() ? trackRefs_[idx] : reco::TrackRef(&tracks_, idx));
0070 }
0071
0072 size_t numberOfTracks() const override { return tracks_.empty() ? trackRefs_.size() : tracks_.size(); }
0073
0074
0075 reco::GsfTrackRef gsfTrack() const override {
0076 return (gsfTrack_.empty() ? gsfTrackRef_ : reco::GsfTrackRef(&gsfTrack_, 0));
0077 }
0078
0079
0080 reco::TrackRef standAloneMuon() const override {
0081 return (standaloneTrack_.empty() ? standaloneTrackRef_ : reco::TrackRef(&standaloneTrack_, 0));
0082 }
0083
0084
0085 reco::TrackRef combinedMuon() const override {
0086 return (combinedTrack_.empty() ? combinedTrackRef_ : reco::TrackRef(&combinedTrack_, 0));
0087 }
0088
0089
0090 reco::SuperClusterRef superCluster() const override {
0091 return superCluster_.empty() ? superClusterRef_ : reco::SuperClusterRef(&superCluster_, 0);
0092 }
0093
0094
0095 CaloTowerRef caloTower() const override {
0096 return caloTower_.empty() ? caloTowerRef_ : CaloTowerRef(&caloTower_, 0);
0097 }
0098
0099
0100 virtual void setTrack(const reco::TrackRef &ref, bool embed = false);
0101
0102 virtual void setTracks(const reco::TrackRefVector &refs, bool embed = false);
0103
0104 virtual void setStandAloneMuon(const reco::TrackRef &ref, bool embed = false);
0105
0106 virtual void setCombinedMuon(const reco::TrackRef &ref, bool embed = false);
0107
0108 virtual void setGsfTrack(const reco::GsfTrackRef &ref, bool embed = false);
0109
0110 virtual void setSuperCluster(const reco::SuperClusterRef &ref, bool embed = false);
0111
0112 virtual void setCaloTower(const CaloTowerRef &ref, bool embed = false);
0113
0114
0115 void embedTrack();
0116
0117 void embedTracks();
0118
0119 void embedStandalone();
0120
0121 void embedCombined();
0122
0123 void embedGsfTrack();
0124
0125 void embedSuperCluster();
0126
0127 void embedCaloTower();
0128
0129
0130 float quality() { return quality_; }
0131
0132 void setQuality(float quality) { quality_ = quality; }
0133
0134
0135
0136
0137 float userIsolation(IsolationKeys key) const {
0138 if (key >= 0) {
0139
0140
0141
0142 if (size_t(key) >= isolations_.size())
0143 return -1.0;
0144 return isolations_[key];
0145 } else
0146 switch (key) {
0147 case pat::CaloIso:
0148
0149
0150 if (isolations_.size() <= pat::HcalIso)
0151 return -1.0;
0152 return isolations_[pat::EcalIso] + isolations_[pat::HcalIso];
0153 default:
0154 return -1.0;
0155
0156
0157 }
0158 }
0159
0160
0161
0162
0163 float userIsolation(const std::string &key) const {
0164
0165 std::string prunedKey = (key.find("pat::") == 0) ? std::string(key, 5) : key;
0166 if (prunedKey == "TrackIso")
0167 return userIsolation(pat::TrackIso);
0168 if (prunedKey == "EcalIso")
0169 return userIsolation(pat::EcalIso);
0170 if (prunedKey == "HcalIso")
0171 return userIsolation(pat::HcalIso);
0172 if (prunedKey == "PfAllParticleIso")
0173 return userIsolation(pat::PfAllParticleIso);
0174 if (prunedKey == "PfChargedHadronIso")
0175 return userIsolation(pat::PfChargedHadronIso);
0176 if (prunedKey == "PfNeutralHadronIso")
0177 return userIsolation(pat::PfNeutralHadronIso);
0178 if (prunedKey == "PfGammaIso")
0179 return userIsolation(pat::PfGammaIso);
0180 if (prunedKey == "User1Iso")
0181 return userIsolation(pat::User1Iso);
0182 if (prunedKey == "User2Iso")
0183 return userIsolation(pat::User2Iso);
0184 if (prunedKey == "User3Iso")
0185 return userIsolation(pat::User3Iso);
0186 if (prunedKey == "User4Iso")
0187 return userIsolation(pat::User4Iso);
0188 if (prunedKey == "User5Iso")
0189 return userIsolation(pat::User5Iso);
0190 if (prunedKey == "UserBaseIso")
0191 return userIsolation(pat::UserBaseIso);
0192 if (prunedKey == "CaloIso")
0193 return userIsolation(pat::CaloIso);
0194
0195
0196
0197 return -1.0;
0198 }
0199
0200
0201 void setIsolation(IsolationKeys key, float value) {
0202 if (key >= 0) {
0203 if (size_t(key) >= isolations_.size())
0204 isolations_.resize(key + 1, -1.0);
0205 isolations_[key] = value;
0206 } else {
0207 throw cms::Exception("Illegal Argument")
0208 << "The key for which you're setting isolation does not correspond "
0209 << "to an individual isolation but to the sum of more independent isolations "
0210 << "(e.g. Calo = Ecal + Hcal), so you can't SET the value, just GET it.\n"
0211 << "Please set up each component independly.\n";
0212 }
0213 }
0214
0215
0216
0217
0218 float trackIso() const { return userIsolation(pat::TrackIso); }
0219
0220
0221
0222 float caloIso() const { return userIsolation(pat::CaloIso); }
0223
0224
0225 float ecalIso() const { return userIsolation(pat::EcalIso); }
0226
0227
0228 float hcalIso() const { return userIsolation(pat::HcalIso); }
0229
0230
0231
0232 void setTrackIso(float trackIso) { setIsolation(pat::TrackIso, trackIso); }
0233
0234 void setEcalIso(float caloIso) { setIsolation(pat::EcalIso, caloIso); }
0235
0236 void setHcalIso(float caloIso) { setIsolation(pat::HcalIso, caloIso); }
0237
0238 void setUserIso(float value, uint8_t index = 0) { setIsolation(IsolationKeys(UserBaseIso + index), value); }
0239
0240
0241
0242 const IsoDeposit *isoDeposit(IsolationKeys key) const {
0243 for (IsoDepositPairs::const_iterator it = isoDeposits_.begin(), ed = isoDeposits_.end(); it != ed; ++it) {
0244 if (it->first == key)
0245 return &it->second;
0246 }
0247 return nullptr;
0248 }
0249
0250
0251 void setIsoDeposit(IsolationKeys key, const IsoDeposit &dep) {
0252 IsoDepositPairs::iterator it = isoDeposits_.begin(), ed = isoDeposits_.end();
0253 for (; it != ed; ++it) {
0254 if (it->first == key) {
0255 it->second = dep;
0256 return;
0257 }
0258 }
0259 isoDeposits_.push_back(std::make_pair(key, dep));
0260 }
0261
0262
0263 const IsoDeposit *trackIsoDeposit() const { return isoDeposit(pat::TrackIso); }
0264 const IsoDeposit *ecalIsoDeposit() const { return isoDeposit(pat::EcalIso); }
0265 const IsoDeposit *hcalIsoDeposit() const { return isoDeposit(pat::HcalIso); }
0266 const IsoDeposit *userIsoDeposit(uint8_t index = 0) const { return isoDeposit(IsolationKeys(UserBaseIso + index)); }
0267
0268
0269 void trackIsoDeposit(const IsoDeposit &dep) { setIsoDeposit(pat::TrackIso, dep); }
0270 void ecalIsoDeposit(const IsoDeposit &dep) { setIsoDeposit(pat::EcalIso, dep); }
0271 void hcalIsoDeposit(const IsoDeposit &dep) { setIsoDeposit(pat::HcalIso, dep); }
0272 void userIsoDeposit(const IsoDeposit &dep, uint8_t index = 0) {
0273 setIsoDeposit(IsolationKeys(UserBaseIso + index), dep);
0274 }
0275
0276
0277 const pat::VertexAssociation *vertexAssociation(size_t index = 0) const {
0278 return vtxAss_.size() > index ? &vtxAss_[index] : nullptr;
0279 }
0280
0281 const std::vector<pat::VertexAssociation> &vertexAssociations() const { return vtxAss_; }
0282
0283 void setVertexAssociation(const pat::VertexAssociation &assoc) {
0284 vtxAss_ = std::vector<pat::VertexAssociation>(1, assoc);
0285 }
0286
0287 void setVertexAssociations(const std::vector<pat::VertexAssociation> &assocs) { vtxAss_ = assocs; }
0288
0289 protected:
0290
0291 reco::TrackRef trackRef_, standaloneTrackRef_, combinedTrackRef_;
0292 reco::TrackCollection track_, standaloneTrack_, combinedTrack_;
0293
0294
0295 reco::GsfTrackRef gsfTrackRef_;
0296 reco::GsfTrackCollection gsfTrack_;
0297
0298
0299 CaloTowerRef caloTowerRef_;
0300 CaloTowerCollection caloTower_;
0301
0302
0303 reco::SuperClusterRef superClusterRef_;
0304 reco::SuperClusterCollection superCluster_;
0305
0306
0307 reco::TrackRefVector trackRefs_;
0308 reco::TrackCollection tracks_;
0309
0310
0311
0312 float quality_;
0313
0314
0315 typedef std::vector<std::pair<IsolationKeys, pat::IsoDeposit> > IsoDepositPairs;
0316 IsoDepositPairs isoDeposits_;
0317 std::vector<float> isolations_;
0318
0319
0320 std::vector<pat::VertexAssociation> vtxAss_;
0321
0322 void fillInFrom(const reco::Candidate &cand);
0323 };
0324
0325 }
0326
0327 #endif