File indexing completed on 2022-03-09 00:50:55
0001 #ifndef EgammaCandidates_Photon_h
0002 #define EgammaCandidates_Photon_h
0003
0004
0005
0006
0007
0008
0009
0010
0011
0012 #include "DataFormats/RecoCandidate/interface/RecoCandidate.h"
0013 #include "DataFormats/EgammaCandidates/interface/Conversion.h"
0014 #include "DataFormats/EgammaCandidates/interface/ConversionFwd.h"
0015 #include "DataFormats/EgammaCandidates/interface/PhotonCore.h"
0016 #include "DataFormats/EgammaReco/interface/ElectronSeed.h"
0017 #include "DataFormats/EgammaReco/interface/SuperCluster.h"
0018 #include <numeric>
0019
0020 namespace reco {
0021
0022 class Photon : public RecoCandidate {
0023 public:
0024
0025 struct FiducialFlags;
0026 struct IsolationVariables;
0027 struct ShowerShape;
0028 struct MIPVariables;
0029 struct SaturationInfo;
0030
0031
0032 Photon() : RecoCandidate() {
0033 pixelSeed_ = false;
0034 haloTaggerMVAVal_ = 99;
0035 }
0036
0037
0038 Photon(const Photon&);
0039
0040
0041 Photon(const LorentzVector& p4, const Point& caloPos, const PhotonCoreRef& core, const Point& vtx = Point(0, 0, 0));
0042
0043
0044 ~Photon() override;
0045
0046
0047 Photon* clone() const override;
0048
0049
0050 reco::PhotonCoreRef photonCore() const { return photonCore_; }
0051 void setPhotonCore(const reco::PhotonCoreRef& photonCore) { photonCore_ = photonCore; }
0052
0053
0054
0055
0056
0057 bool isPFlowPhoton() const { return this->photonCore()->isPFlowPhoton(); }
0058 bool isStandardPhoton() const { return this->photonCore()->isStandardPhoton(); }
0059
0060 reco::SuperClusterRef superCluster() const override;
0061
0062 reco::SuperClusterRef parentSuperCluster() const { return this->photonCore()->parentSuperCluster(); }
0063
0064 reco::ConversionRefVector conversions() const { return this->photonCore()->conversions(); }
0065 enum ConversionProvenance { egamma = 0, pflow = 1, both = 2 };
0066
0067
0068 reco::ConversionRefVector conversionsOneLeg() const { return this->photonCore()->conversionsOneLeg(); }
0069
0070 bool hasConversionTracks() const {
0071 if (!this->photonCore()->conversions().empty() || !this->photonCore()->conversionsOneLeg().empty())
0072 return true;
0073 else
0074 return false;
0075 }
0076
0077 reco::ElectronSeedRefVector electronPixelSeeds() const { return this->photonCore()->electronPixelSeeds(); }
0078
0079 bool hasPixelSeed() const {
0080 if (!(this->photonCore()->electronPixelSeeds()).empty())
0081 return true;
0082 else
0083 return false;
0084 }
0085 int conversionTrackProvenance(const edm::RefToBase<reco::Track>& convTrack) const;
0086
0087
0088 math::XYZPointF caloPosition() const { return caloPosition_; }
0089
0090 void setVertex(const Point& vertex) override;
0091
0092 bool isPhoton() const override { return true; }
0093
0094
0095
0096
0097 struct FiducialFlags {
0098
0099 bool isEB;
0100 bool isEE;
0101 bool isEBEtaGap;
0102 bool isEBPhiGap;
0103 bool isEERingGap;
0104 bool isEEDeeGap;
0105 bool isEBEEGap;
0106
0107 FiducialFlags()
0108 : isEB(false),
0109 isEE(false),
0110 isEBEtaGap(false),
0111 isEBPhiGap(false),
0112 isEERingGap(false),
0113 isEEDeeGap(false),
0114 isEBEEGap(false)
0115
0116 {}
0117 };
0118
0119
0120 void setFiducialVolumeFlags(const FiducialFlags& a) { fiducialFlagBlock_ = a; }
0121
0122
0123 bool isEB() const { return fiducialFlagBlock_.isEB; }
0124
0125 bool isEE() const { return fiducialFlagBlock_.isEE; }
0126
0127 bool isEBGap() const { return (isEBEtaGap() || isEBPhiGap()); }
0128 bool isEBEtaGap() const { return fiducialFlagBlock_.isEBEtaGap; }
0129 bool isEBPhiGap() const { return fiducialFlagBlock_.isEBPhiGap; }
0130
0131 bool isEEGap() const { return (isEERingGap() || isEEDeeGap()); }
0132 bool isEERingGap() const { return fiducialFlagBlock_.isEERingGap; }
0133 bool isEEDeeGap() const { return fiducialFlagBlock_.isEEDeeGap; }
0134
0135 bool isEBEEGap() const { return fiducialFlagBlock_.isEBEEGap; }
0136
0137
0138
0139
0140
0141 struct ShowerShape {
0142 float sigmaEtaEta;
0143 float sigmaIetaIeta;
0144 float e1x5;
0145 float e2x5;
0146 float e3x3;
0147 float e5x5;
0148 float maxEnergyXtal;
0149 float hcalDepth1OverEcal;
0150 float hcalDepth2OverEcal;
0151 float hcalDepth1OverEcalBc;
0152 float hcalDepth2OverEcalBc;
0153 std::array<float, 7> hcalOverEcal;
0154 std::array<float, 7>
0155 hcalOverEcalBc;
0156 std::vector<CaloTowerDetId> hcalTowersBehindClusters;
0157 bool invalidHcal;
0158 bool pre7DepthHcal;
0159 float effSigmaRR;
0160 float sigmaIetaIphi;
0161 float sigmaIphiIphi;
0162 float e2nd;
0163 float eTop;
0164 float eLeft;
0165 float eRight;
0166 float eBottom;
0167 float e1x3;
0168 float e2x2;
0169 float e2x5Max;
0170 float e2x5Left;
0171 float e2x5Right;
0172 float e2x5Top;
0173 float e2x5Bottom;
0174 float smMajor;
0175 float smMinor;
0176 float smAlpha;
0177 ShowerShape()
0178 : sigmaEtaEta(std::numeric_limits<float>::max()),
0179 sigmaIetaIeta(std::numeric_limits<float>::max()),
0180 e1x5(0.f),
0181 e2x5(0.f),
0182 e3x3(0.f),
0183 e5x5(0.f),
0184 maxEnergyXtal(0.f),
0185 hcalDepth1OverEcal(0.f),
0186 hcalDepth2OverEcal(0.f),
0187 hcalDepth1OverEcalBc(0.f),
0188 hcalDepth2OverEcalBc(0.f),
0189 hcalOverEcal{{0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f}},
0190 hcalOverEcalBc{{0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f}},
0191 invalidHcal(false),
0192 pre7DepthHcal(true),
0193 effSigmaRR(std::numeric_limits<float>::max()),
0194 sigmaIetaIphi(std::numeric_limits<float>::max()),
0195 sigmaIphiIphi(std::numeric_limits<float>::max()),
0196 e2nd(0.f),
0197 eTop(0.f),
0198 eLeft(0.f),
0199 eRight(0.f),
0200 eBottom(0.f),
0201 e1x3(0.f),
0202 e2x2(0.f),
0203 e2x5Max(0.f),
0204 e2x5Left(0.f),
0205 e2x5Right(0.f),
0206 e2x5Top(0.f),
0207 e2x5Bottom(0.f),
0208 smMajor(0.f),
0209 smMinor(0.f),
0210 smAlpha(0.f) {}
0211 };
0212 const ShowerShape& showerShapeVariables() const { return showerShapeBlock_; }
0213 const ShowerShape& full5x5_showerShapeVariables() const { return full5x5_showerShapeBlock_; }
0214
0215 void setShowerShapeVariables(const ShowerShape& a) { showerShapeBlock_ = a; }
0216 void full5x5_setShowerShapeVariables(const ShowerShape& a) { full5x5_showerShapeBlock_ = a; }
0217
0218
0219 float hcalOverEcal(const ShowerShape& ss, int depth) const {
0220 if (ss.pre7DepthHcal) {
0221 if (depth == 0)
0222 return ss.hcalDepth1OverEcal + ss.hcalDepth2OverEcal;
0223 else if (depth == 1)
0224 return ss.hcalDepth1OverEcal;
0225 else if (depth == 2)
0226 return ss.hcalDepth2OverEcal;
0227
0228 return 0.f;
0229 } else {
0230 const auto& hovere = ss.hcalOverEcal;
0231 return (!(depth > 0 and depth < 8)) ? std::accumulate(std::begin(hovere), std::end(hovere), 0.f)
0232 : hovere[depth - 1];
0233 }
0234 }
0235 float hcalOverEcal(int depth = 0) const { return hcalOverEcal(showerShapeBlock_, depth); }
0236 float hadronicOverEm(int depth = 0) const { return hcalOverEcal(depth); }
0237
0238
0239 float hcalOverEcalBc(const ShowerShape& ss, int depth) const {
0240 if (ss.pre7DepthHcal) {
0241 if (depth == 0)
0242 return ss.hcalDepth1OverEcalBc + ss.hcalDepth2OverEcalBc;
0243 else if (depth == 1)
0244 return ss.hcalDepth1OverEcalBc;
0245 else if (depth == 2)
0246 return ss.hcalDepth2OverEcalBc;
0247
0248 return 0.f;
0249 } else {
0250 const auto& hovere = ss.hcalOverEcalBc;
0251 return (!(depth > 0 and depth < 8)) ? std::accumulate(std::begin(hovere), std::end(hovere), 0.f)
0252 : hovere[depth - 1];
0253 }
0254 }
0255 float hcalOverEcalBc(int depth = 0) const { return hcalOverEcalBc(showerShapeBlock_, depth); }
0256 float hadTowOverEm(int depth = 0) const { return hcalOverEcalBc(depth); }
0257
0258 const std::vector<CaloTowerDetId>& hcalTowersBehindClusters() const {
0259 return showerShapeBlock_.hcalTowersBehindClusters;
0260 }
0261
0262
0263 bool hadronicOverEmValid() const { return !showerShapeBlock_.invalidHcal; }
0264 bool hadTowOverEmValid() const { return !showerShapeBlock_.invalidHcal; }
0265
0266
0267 float e1x5() const { return showerShapeBlock_.e1x5; }
0268 float e2x5() const { return showerShapeBlock_.e2x5; }
0269 float e3x3() const { return showerShapeBlock_.e3x3; }
0270 float e5x5() const { return showerShapeBlock_.e5x5; }
0271 float maxEnergyXtal() const { return showerShapeBlock_.maxEnergyXtal; }
0272 float sigmaEtaEta() const { return showerShapeBlock_.sigmaEtaEta; }
0273 float sigmaIetaIeta() const { return showerShapeBlock_.sigmaIetaIeta; }
0274 float r1x5() const { return showerShapeBlock_.e1x5 / showerShapeBlock_.e5x5; }
0275 float r2x5() const { return showerShapeBlock_.e2x5 / showerShapeBlock_.e5x5; }
0276 float r9() const { return showerShapeBlock_.e3x3 / this->superCluster()->rawEnergy(); }
0277
0278
0279 float full5x5_e1x5() const { return full5x5_showerShapeBlock_.e1x5; }
0280 float full5x5_e2x5() const { return full5x5_showerShapeBlock_.e2x5; }
0281 float full5x5_e3x3() const { return full5x5_showerShapeBlock_.e3x3; }
0282 float full5x5_e5x5() const { return full5x5_showerShapeBlock_.e5x5; }
0283 float full5x5_maxEnergyXtal() const { return full5x5_showerShapeBlock_.maxEnergyXtal; }
0284 float full5x5_sigmaEtaEta() const { return full5x5_showerShapeBlock_.sigmaEtaEta; }
0285 float full5x5_sigmaIetaIeta() const { return full5x5_showerShapeBlock_.sigmaIetaIeta; }
0286 float full5x5_r1x5() const { return full5x5_showerShapeBlock_.e1x5 / full5x5_showerShapeBlock_.e5x5; }
0287 float full5x5_r2x5() const { return full5x5_showerShapeBlock_.e2x5 / full5x5_showerShapeBlock_.e5x5; }
0288 float full5x5_r9() const { return full5x5_showerShapeBlock_.e3x3 / this->superCluster()->rawEnergy(); }
0289
0290
0291 float full5x5_hcalOverEcal(int depth = 0) const { return hcalOverEcal(full5x5_showerShapeBlock_, depth); }
0292 float full5x5_hadronicOverEm(int depth = 0) const { return full5x5_hcalOverEcal(depth); }
0293
0294
0295 float full5x5_hcalOverEcalBc(int depth = 0) const { return hcalOverEcalBc(full5x5_showerShapeBlock_, depth); }
0296 float full5x5_hadTowOverEm(int depth = 0) const { return full5x5_hcalOverEcalBc(depth); }
0297
0298
0299
0300
0301
0302 struct SaturationInfo {
0303 int nSaturatedXtals;
0304 bool isSeedSaturated;
0305 SaturationInfo() : nSaturatedXtals(0), isSeedSaturated(false){};
0306 };
0307
0308
0309 float nSaturatedXtals() const { return saturationInfo_.nSaturatedXtals; }
0310 float isSeedSaturated() const { return saturationInfo_.isSeedSaturated; }
0311 const SaturationInfo& saturationInfo() const { return saturationInfo_; }
0312 void setSaturationInfo(const SaturationInfo& s) { saturationInfo_ = s; }
0313
0314
0315
0316
0317 enum P4type { undefined = -1, ecal_standard = 0, ecal_photons = 1, regression1 = 2, regression2 = 3 };
0318
0319 struct EnergyCorrections {
0320 float scEcalEnergy;
0321 float scEcalEnergyError;
0322 LorentzVector scEcalP4;
0323 float phoEcalEnergy;
0324 float phoEcalEnergyError;
0325 LorentzVector phoEcalP4;
0326 float regression1Energy;
0327 float regression1EnergyError;
0328 LorentzVector regression1P4;
0329 float regression2Energy;
0330 float regression2EnergyError;
0331 LorentzVector regression2P4;
0332 P4type candidateP4type;
0333 EnergyCorrections()
0334 : scEcalEnergy(0.),
0335 scEcalEnergyError(999.),
0336 scEcalP4(0., 0., 0., 0.),
0337 phoEcalEnergy(0.),
0338 phoEcalEnergyError(999.),
0339 phoEcalP4(0., 0., 0., 0.),
0340 regression1Energy(0.),
0341 regression1EnergyError(999.),
0342 regression1P4(0., 0., 0., 0.),
0343 regression2Energy(0.),
0344 regression2EnergyError(999.),
0345 regression2P4(0., 0., 0., 0.),
0346 candidateP4type(undefined) {}
0347 };
0348
0349 using RecoCandidate::p4;
0350 using RecoCandidate::setP4;
0351
0352
0353 void setCorrectedEnergy(P4type type, float E, float dE, bool toCand = true);
0354 void setP4(P4type type, const LorentzVector& p4, float p4Error, bool setToRecoCandidate);
0355 void setEnergyCorrections(const EnergyCorrections& e) { eCorrections_ = e; }
0356 void setCandidateP4type(const P4type type) { eCorrections_.candidateP4type = type; }
0357
0358 float getCorrectedEnergy(P4type type) const;
0359 float getCorrectedEnergyError(P4type type) const;
0360 P4type getCandidateP4type() const { return eCorrections_.candidateP4type; }
0361 const LorentzVector& p4(P4type type) const;
0362 const EnergyCorrections& energyCorrections() const { return eCorrections_; }
0363
0364
0365
0366
0367
0368 struct MIPVariables {
0369 float mipChi2;
0370 float mipTotEnergy;
0371 float mipSlope;
0372 float mipIntercept;
0373 int mipNhitCone;
0374 bool mipIsHalo;
0375
0376 MIPVariables()
0377 :
0378
0379 mipChi2(0),
0380 mipTotEnergy(0),
0381 mipSlope(0),
0382 mipIntercept(0),
0383 mipNhitCone(0),
0384 mipIsHalo(false) {}
0385 };
0386
0387
0388 float mipChi2() const { return mipVariableBlock_.mipChi2; }
0389 float mipTotEnergy() const { return mipVariableBlock_.mipTotEnergy; }
0390 float mipSlope() const { return mipVariableBlock_.mipSlope; }
0391 float mipIntercept() const { return mipVariableBlock_.mipIntercept; }
0392 int mipNhitCone() const { return mipVariableBlock_.mipNhitCone; }
0393 bool mipIsHalo() const { return mipVariableBlock_.mipIsHalo; }
0394
0395
0396 void setMIPVariables(const MIPVariables& mipVar) { mipVariableBlock_ = mipVar; }
0397
0398
0399
0400
0401
0402 struct IsolationVariables {
0403
0404
0405
0406 float ecalRecHitSumEt;
0407
0408 float hcalTowerSumEt;
0409
0410 float hcalDepth1TowerSumEt;
0411
0412 float hcalDepth2TowerSumEt;
0413
0414 float hcalTowerSumEtBc;
0415
0416 float hcalDepth1TowerSumEtBc;
0417
0418 float hcalDepth2TowerSumEtBc;
0419 std::array<float, 7> hcalRecHitSumEt;
0420 std::array<float, 7> hcalRecHitSumEtBc;
0421 bool pre7DepthHcal;
0422
0423 float trkSumPtSolidCone;
0424
0425 float trkSumPtHollowCone;
0426
0427 int nTrkSolidCone;
0428
0429 int nTrkHollowCone;
0430 IsolationVariables()
0431 :
0432
0433 ecalRecHitSumEt(0.f),
0434 hcalTowerSumEt(0.f),
0435 hcalDepth1TowerSumEt(0.f),
0436 hcalDepth2TowerSumEt(0.f),
0437 hcalTowerSumEtBc(0.f),
0438 hcalDepth1TowerSumEtBc(0.f),
0439 hcalDepth2TowerSumEtBc(0.f),
0440 hcalRecHitSumEt{{0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f}},
0441 hcalRecHitSumEtBc{{0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f}},
0442 pre7DepthHcal(true),
0443 trkSumPtSolidCone(0.f),
0444 trkSumPtHollowCone(0.f),
0445 nTrkSolidCone(0),
0446 nTrkHollowCone(0) {}
0447 };
0448
0449
0450 void setIsolationVariables(const IsolationVariables& isolInDr04, const IsolationVariables& isolInDr03) {
0451 isolationR04_ = isolInDr04;
0452 isolationR03_ = isolInDr03;
0453 }
0454
0455
0456
0457 float ecalRecHitSumEtConeDR04() const { return isolationR04_.ecalRecHitSumEt; }
0458
0459 float hcalTowerSumEt(const IsolationVariables& iv, int depth) const {
0460 if (iv.pre7DepthHcal) {
0461 if (depth == 0)
0462 return iv.hcalTowerSumEt;
0463 else if (depth == 1)
0464 return iv.hcalDepth1TowerSumEt;
0465 else if (depth == 2)
0466 return iv.hcalDepth2TowerSumEt;
0467
0468 return 0.f;
0469 } else {
0470 const auto& hcaliso = iv.hcalRecHitSumEt;
0471 return (!(depth > 0 and depth < 8)) ? std::accumulate(std::begin(hcaliso), std::end(hcaliso), 0.f)
0472 : hcaliso[depth - 1];
0473 }
0474 }
0475 float hcalTowerSumEtConeDR04(int depth = 0) const { return hcalTowerSumEt(isolationR04_, depth); }
0476
0477 float hcalTowerSumEtBc(const IsolationVariables& iv, int depth) const {
0478 if (iv.pre7DepthHcal) {
0479 if (depth == 0)
0480 return iv.hcalTowerSumEtBc;
0481 else if (depth == 1)
0482 return iv.hcalDepth1TowerSumEtBc;
0483 else if (depth == 2)
0484 return iv.hcalDepth2TowerSumEtBc;
0485
0486 return 0.f;
0487 } else {
0488 const auto& hcaliso = iv.hcalRecHitSumEtBc;
0489 return (!(depth > 0 and depth < 8)) ? std::accumulate(std::begin(hcaliso), std::end(hcaliso), 0.f)
0490 : hcaliso[depth - 1];
0491 }
0492 }
0493 float hcalTowerSumEtBcConeDR04(int depth = 0) const { return hcalTowerSumEtBc(isolationR04_, depth); }
0494
0495 float trkSumPtSolidConeDR04() const { return isolationR04_.trkSumPtSolidCone; }
0496
0497 float trkSumPtHollowConeDR04() const { return isolationR04_.trkSumPtHollowCone; }
0498
0499 int nTrkSolidConeDR04() const { return isolationR04_.nTrkSolidCone; }
0500
0501 int nTrkHollowConeDR04() const { return isolationR04_.nTrkHollowCone; }
0502
0503
0504 float ecalRecHitSumEtConeDR03() const { return isolationR03_.ecalRecHitSumEt; }
0505
0506 float hcalTowerSumEtConeDR03(int depth = 0) const { return hcalTowerSumEt(isolationR03_, depth); }
0507
0508 float hcalTowerSumEtBcConeDR03(int depth = 0) const { return hcalTowerSumEtBc(isolationR03_, depth); }
0509
0510 float trkSumPtSolidConeDR03() const { return isolationR03_.trkSumPtSolidCone; }
0511
0512 float trkSumPtHollowConeDR03() const { return isolationR03_.trkSumPtHollowCone; }
0513
0514 int nTrkSolidConeDR03() const { return isolationR03_.nTrkSolidCone; }
0515
0516 int nTrkHollowConeDR03() const { return isolationR03_.nTrkHollowCone; }
0517
0518
0519
0520
0521
0522 struct PflowIsolationVariables {
0523 float chargedHadronIso;
0524 float chargedHadronWorstVtxIso;
0525 float chargedHadronWorstVtxGeomVetoIso;
0526 float chargedHadronPFPVIso;
0527 float neutralHadronIso;
0528 float photonIso;
0529 float sumEcalClusterEt;
0530 float sumHcalClusterEt;
0531 PflowIsolationVariables()
0532 :
0533
0534 chargedHadronIso(0.),
0535 chargedHadronWorstVtxIso(0.),
0536 chargedHadronWorstVtxGeomVetoIso(0.),
0537 chargedHadronPFPVIso(0.),
0538 neutralHadronIso(0.),
0539 photonIso(0.),
0540 sumEcalClusterEt(0.),
0541 sumHcalClusterEt(0.) {}
0542 };
0543
0544
0545 float chargedHadronIso() const { return pfIsolation_.chargedHadronIso; }
0546 float chargedHadronWorstVtxIso() const { return pfIsolation_.chargedHadronWorstVtxIso; }
0547 float chargedHadronWorstVtxGeomVetoIso() const { return pfIsolation_.chargedHadronWorstVtxGeomVetoIso; }
0548 float chargedHadronPFPVIso() const { return pfIsolation_.chargedHadronPFPVIso; }
0549 float neutralHadronIso() const { return pfIsolation_.neutralHadronIso; }
0550 float photonIso() const { return pfIsolation_.photonIso; }
0551
0552
0553 float ecalPFClusterIso() const { return pfIsolation_.sumEcalClusterEt; };
0554 float hcalPFClusterIso() const { return pfIsolation_.sumHcalClusterEt; };
0555
0556
0557 const PflowIsolationVariables& getPflowIsolationVariables() const { return pfIsolation_; }
0558
0559
0560 void setPflowIsolationVariables(const PflowIsolationVariables& pfisol) { pfIsolation_ = pfisol; }
0561
0562 static constexpr float mvaPlaceholder = -999999999.;
0563
0564 struct PflowIDVariables {
0565 int nClusterOutsideMustache;
0566 float etOutsideMustache;
0567 float mva;
0568 float dnn;
0569
0570 PflowIDVariables()
0571 : nClusterOutsideMustache(-1), etOutsideMustache(mvaPlaceholder), mva(mvaPlaceholder), dnn(mvaPlaceholder) {}
0572 };
0573
0574
0575 int nClusterOutsideMustache() const { return pfID_.nClusterOutsideMustache; }
0576 float etOutsideMustache() const { return pfID_.etOutsideMustache; }
0577 float pfMVA() const { return pfID_.mva; }
0578 float pfDNN() const { return pfID_.dnn; }
0579
0580 void setPflowIDVariables(const PflowIDVariables& pfid) { pfID_ = pfid; }
0581
0582
0583 void hcalToRun2EffDepth();
0584
0585
0586 float haloTaggerMVAVal() const { return haloTaggerMVAVal_; }
0587
0588
0589 void setHaloTaggerMVAVal(float x) { haloTaggerMVAVal_ = x; }
0590
0591 private:
0592
0593 bool overlap(const Candidate&) const override;
0594
0595 math::XYZPointF caloPosition_;
0596
0597 reco::PhotonCoreRef photonCore_;
0598
0599 bool pixelSeed_;
0600
0601 FiducialFlags fiducialFlagBlock_;
0602 IsolationVariables isolationR04_;
0603 IsolationVariables isolationR03_;
0604 ShowerShape showerShapeBlock_;
0605 ShowerShape full5x5_showerShapeBlock_;
0606 SaturationInfo saturationInfo_;
0607 EnergyCorrections eCorrections_;
0608 MIPVariables mipVariableBlock_;
0609 PflowIsolationVariables pfIsolation_;
0610 PflowIDVariables pfID_;
0611 float haloTaggerMVAVal_;
0612 };
0613
0614 }
0615
0616 #endif