File indexing completed on 2024-04-06 12:04:53
0001
0002
0003
0004 #ifndef DataFormats_PatCandidates_Electron_h
0005 #define DataFormats_PatCandidates_Electron_h
0006
0007
0008
0009
0010
0011
0012
0013
0014
0015
0016
0017
0018
0019
0020 #include "DataFormats/EgammaCandidates/interface/GsfElectron.h"
0021 #include "DataFormats/EgammaCandidates/interface/GsfElectronFwd.h"
0022 #include "DataFormats/EgammaCandidates/interface/GsfElectronCore.h"
0023 #include "DataFormats/EgammaCandidates/interface/GsfElectronCoreFwd.h"
0024 #include "DataFormats/EgammaReco/interface/BasicCluster.h"
0025 #include "DataFormats/GsfTrackReco/interface/GsfTrack.h"
0026 #include "DataFormats/PatCandidates/interface/Lepton.h"
0027
0028 #include "DataFormats/EcalRecHit/interface/EcalRecHitCollections.h"
0029 #include "DataFormats/ParticleFlowCandidate/interface/PFCandidateFwd.h"
0030 #include "DataFormats/ParticleFlowCandidate/interface/PFCandidate.h"
0031 #include "DataFormats/PatCandidates/interface/PackedCandidate.h"
0032 #include "DataFormats/Common/interface/AtomicPtrCache.h"
0033
0034
0035 namespace pat {
0036 class Electron;
0037 typedef std::vector<Electron> ElectronCollection;
0038 typedef edm::Ref<ElectronCollection> ElectronRef;
0039 typedef edm::RefVector<ElectronCollection> ElectronRefVector;
0040 }
0041
0042 namespace reco {
0043
0044 std::ostream& operator<<(std::ostream& out, const pat::Electron& obj);
0045 }
0046
0047
0048 namespace pat {
0049 class PATElectronSlimmer;
0050
0051 class Electron : public Lepton<reco::GsfElectron> {
0052 public:
0053 typedef std::pair<std::string, float> IdPair;
0054
0055
0056 Electron();
0057
0058 Electron(const reco::GsfElectron& anElectron);
0059
0060 Electron(const edm::RefToBase<reco::GsfElectron>& anElectronRef);
0061
0062 Electron(const edm::Ptr<reco::GsfElectron>& anElectronRef);
0063
0064 ~Electron() override;
0065
0066
0067 Electron* clone() const override { return new Electron(*this); }
0068
0069
0070
0071 reco::GsfElectronCoreRef core() const override;
0072
0073 reco::GsfTrackRef gsfTrack() const override;
0074
0075 reco::SuperClusterRef superCluster() const override;
0076
0077 reco::SuperClusterRef parentSuperCluster() const override;
0078
0079 reco::TrackRef track() const override;
0080
0081 reco::TrackRef closestCtfTrackRef() const override;
0082
0083 reco::CaloClusterPtr seed() const;
0084
0085
0086 const std::vector<reco::CaloCluster>& basicClusters() const { return basicClusters_; }
0087
0088 const std::vector<reco::CaloCluster>& preshowerClusters() const { return preshowerClusters_; }
0089
0090 const std::vector<reco::CaloCluster>& pflowBasicClusters() const { return pflowBasicClusters_; }
0091
0092 const std::vector<reco::CaloCluster>& pflowPreshowerClusters() const { return pflowPreshowerClusters_; }
0093
0094 using reco::RecoCandidate::track;
0095
0096 void embedGsfElectronCore();
0097
0098 void embedGsfTrack();
0099
0100 void embedSuperCluster();
0101
0102 void embedPflowSuperCluster();
0103
0104 void embedSeedCluster();
0105
0106 void embedBasicClusters();
0107
0108 void embedPreshowerClusters();
0109
0110 void embedPflowBasicClusters();
0111
0112 void embedPflowPreshowerClusters();
0113
0114 void embedTrack();
0115
0116 void embedRecHits(const EcalRecHitCollection* rechits);
0117
0118
0119
0120
0121
0122
0123
0124
0125
0126
0127
0128
0129
0130
0131
0132
0133 float electronID(const std::string& name) const;
0134 float electronID(const char* name) const { return electronID(std::string(name)); }
0135
0136 bool isElectronIDAvailable(const std::string& name) const;
0137 bool isElectronIDAvailable(const char* name) const { return isElectronIDAvailable(std::string(name)); }
0138
0139 const std::vector<IdPair>& electronIDs() const { return electronIDs_; }
0140
0141 void setElectronIDs(const std::vector<IdPair>& ids) { electronIDs_ = ids; }
0142
0143
0144
0145 float trackIso() const { return dr04TkSumPt(); }
0146
0147 float ecalIso() const { return dr04EcalRecHitSumEt(); }
0148
0149 float hcalIso() const { return dr04HcalTowerSumEt(); }
0150
0151 float caloIso() const { return ecalIso() + hcalIso(); }
0152
0153 float puppiChargedHadronIso() const { return puppiChargedHadronIso_; }
0154 float puppiNeutralHadronIso() const { return puppiNeutralHadronIso_; }
0155 float puppiPhotonIso() const { return puppiPhotonIso_; }
0156
0157 float puppiNoLeptonsChargedHadronIso() const { return puppiNoLeptonsChargedHadronIso_; }
0158 float puppiNoLeptonsNeutralHadronIso() const { return puppiNoLeptonsNeutralHadronIso_; }
0159 float puppiNoLeptonsPhotonIso() const { return puppiNoLeptonsPhotonIso_; }
0160
0161 void setIsolationPUPPI(float chargedhadrons_, float neutralhadrons_, float photons_) {
0162 puppiChargedHadronIso_ = chargedhadrons_;
0163 puppiNeutralHadronIso_ = neutralhadrons_;
0164 puppiPhotonIso_ = photons_;
0165 }
0166
0167 void setIsolationPUPPINoLeptons(float chargedhadrons_, float neutralhadrons_, float photons_) {
0168 puppiNoLeptonsChargedHadronIso_ = chargedhadrons_;
0169 puppiNoLeptonsNeutralHadronIso_ = neutralhadrons_;
0170 puppiNoLeptonsPhotonIso_ = photons_;
0171 }
0172
0173 bool isPF() const { return isPF_; }
0174 void setIsPF(bool hasPFCandidate) { isPF_ = hasPFCandidate; }
0175
0176
0177 reco::PFCandidateRef pfCandidateRef() const;
0178
0179 void setPFCandidateRef(const reco::PFCandidateRef& ref) { pfCandidateRef_ = ref; }
0180
0181 void embedPFCandidate();
0182
0183 size_t numberOfSourceCandidatePtrs() const override {
0184 return (pfCandidateRef_.isNonnull() ? 1 : 0) + associatedPackedFCandidateIndices_.size();
0185 }
0186
0187 reco::CandidatePtr sourceCandidatePtr(size_type i) const override;
0188
0189
0190 typedef enum IPTYPE { PV2D = 0, PV3D = 1, BS2D = 2, BS3D = 3, PVDZ = 4, IpTypeSize = 5 } IpType;
0191
0192 double dB(IPTYPE type) const;
0193
0194 double edB(IPTYPE type) const;
0195
0196 double dB() const { return std::abs(dB(PV2D)); }
0197
0198 double edB() const { return std::abs(edB(PV2D)); }
0199
0200 void setDB(double dB, double edB, IPTYPE type);
0201
0202
0203 const LorentzVector& ecalDrivenMomentum() const { return ecalDrivenMomentum_; }
0204 void setEcalDrivenMomentum(const Candidate::LorentzVector& mom) { ecalDrivenMomentum_ = mom; }
0205
0206
0207 friend std::ostream& reco::operator<<(std::ostream& out, const pat::Electron& obj);
0208
0209
0210
0211 float sigmaIetaIphi() const { return sigmaIetaIphi_; }
0212
0213 float full5x5_sigmaIetaIphi() const { return full5x5_sigmaIetaIphi_; }
0214
0215 double ip3d() const { return ip3d_; }
0216
0217 void setMvaVariables(double sigmaIetaIphi, double ip3d);
0218 void full5x5_setSigmaIetaIphi(float sigmaIetaIphi) { full5x5_sigmaIetaIphi_ = sigmaIetaIphi; }
0219
0220 const EcalRecHitCollection* recHits() const { return &recHits_; }
0221
0222
0223
0224 double ecalRegressionEnergy() const { return ecalRegressionEnergy_; }
0225 double ecalRegressionError() const { return ecalRegressionError_; }
0226
0227 double ecalTrackRegressionEnergy() const { return ecalTrackRegressionEnergy_; }
0228 double ecalTrackRegressionError() const { return ecalTrackRegressionError_; }
0229
0230 void setEcalRegressionEnergy(double val, double err) {
0231 ecalRegressionEnergy_ = val;
0232 ecalRegressionError_ = err;
0233 }
0234
0235 void setEcalTrackRegressionEnergy(double val, double err) {
0236 ecalTrackRegressionEnergy_ = val;
0237 ecalTrackRegressionError_ = err;
0238 }
0239
0240
0241 void setEcalScale(double val) { ecalScale_ = val; }
0242 void setEcalSmear(double val) { ecalSmear_ = val; }
0243 void setEcalRegressionScale(double val) { ecalRegressionScale_ = val; }
0244 void setEcalRegressionSmear(double val) { ecalRegressionSmear_ = val; }
0245 void setEcalTrackRegressionScale(double val) { ecalTrackRegressionScale_ = val; }
0246 void setEcalTrackRegressionSmear(double val) { ecalTrackRegressionSmear_ = val; }
0247
0248
0249 double ecalScale() const { return ecalScale_; }
0250 double ecalSmear() const { return ecalSmear_; }
0251 double ecalRegressionScale() const { return ecalRegressionScale_; }
0252 double ecalRegressionSmear() const { return ecalRegressionSmear_; }
0253 double ecalTrackRegressionScale() const { return ecalTrackRegressionScale_; }
0254 double ecalTrackRegressionSmear() const { return ecalTrackRegressionSmear_; }
0255
0256 bool passConversionVeto() const { return passConversionVeto_; }
0257 void setPassConversionVeto(bool flag) { passConversionVeto_ = flag; }
0258
0259
0260 edm::RefVector<pat::PackedCandidateCollection> associatedPackedPFCandidates() const;
0261
0262 template <typename T>
0263 void setAssociatedPackedPFCandidates(const edm::RefProd<pat::PackedCandidateCollection>& refprod,
0264 T beginIndexItr,
0265 T endIndexItr) {
0266 packedPFCandidates_ = refprod;
0267 associatedPackedFCandidateIndices_.clear();
0268 associatedPackedFCandidateIndices_.insert(associatedPackedFCandidateIndices_.end(), beginIndexItr, endIndexItr);
0269 }
0270
0271 friend class PATElectronSlimmer;
0272
0273 protected:
0274
0275 void initImpactParameters();
0276
0277
0278
0279 bool embeddedGsfElectronCore_;
0280
0281 std::vector<reco::GsfElectronCore> gsfElectronCore_;
0282
0283 bool embeddedGsfTrack_;
0284
0285 std::vector<reco::GsfTrack> gsfTrack_;
0286
0287 bool embeddedSuperCluster_;
0288
0289 bool embeddedPflowSuperCluster_;
0290
0291 std::vector<reco::SuperCluster> superCluster_;
0292
0293 edm::AtomicPtrCache<std::vector<reco::SuperCluster> > superClusterRelinked_;
0294
0295 std::vector<reco::CaloCluster> basicClusters_;
0296
0297 std::vector<reco::CaloCluster> preshowerClusters_;
0298
0299 std::vector<reco::CaloCluster> pflowBasicClusters_;
0300
0301 std::vector<reco::CaloCluster> pflowPreshowerClusters_;
0302
0303 std::vector<reco::SuperCluster> pflowSuperCluster_;
0304
0305 bool embeddedTrack_;
0306
0307 std::vector<reco::Track> track_;
0308
0309 bool embeddedSeedCluster_;
0310
0311 std::vector<reco::CaloCluster> seedCluster_;
0312
0313 bool embeddedRecHits_;
0314
0315 EcalRecHitCollection recHits_;
0316
0317
0318
0319 std::vector<IdPair> electronIDs_;
0320
0321
0322 bool isPF_;
0323
0324 bool embeddedPFCandidate_;
0325
0326 reco::PFCandidateCollection pfCandidate_;
0327
0328 reco::PFCandidateRef pfCandidateRef_;
0329
0330
0331
0332 LorentzVector ecalDrivenMomentum_;
0333
0334
0335 float sigmaIetaIphi_, full5x5_sigmaIetaIphi_;
0336 double ip3d_;
0337
0338
0339 double ecalRegressionEnergy_;
0340 double ecalTrackRegressionEnergy_;
0341 double ecalRegressionError_;
0342 double ecalTrackRegressionError_;
0343
0344
0345 double ecalScale_;
0346 double ecalSmear_;
0347
0348 double ecalRegressionScale_;
0349 double ecalRegressionSmear_;
0350
0351 double ecalTrackRegressionScale_;
0352 double ecalTrackRegressionSmear_;
0353
0354
0355 float puppiChargedHadronIso_;
0356 float puppiNeutralHadronIso_;
0357 float puppiPhotonIso_;
0358
0359
0360 float puppiNoLeptonsChargedHadronIso_;
0361 float puppiNoLeptonsNeutralHadronIso_;
0362 float puppiNoLeptonsPhotonIso_;
0363
0364
0365 bool passConversionVeto_;
0366
0367
0368
0369 uint8_t cachedIP_;
0370
0371 float ip_[IpTypeSize];
0372
0373 float eip_[IpTypeSize];
0374
0375
0376 edm::RefProd<pat::PackedCandidateCollection> packedPFCandidates_;
0377 std::vector<uint16_t> associatedPackedFCandidateIndices_;
0378 };
0379 }
0380
0381 #endif