Back to home page

Project CMSSW displayed by LXR

 
 

    


File indexing completed on 2022-03-09 00:50:55

0001 #include "DataFormats/EgammaCandidates/interface/Photon.h"
0002 #include "DataFormats/EgammaReco/interface/SuperClusterFwd.h"
0003 
0004 using namespace reco;
0005 
0006 Photon::Photon(const LorentzVector& p4, const Point& caloPos, const PhotonCoreRef& core, const Point& vtx)
0007     : RecoCandidate(0, p4, vtx, 22),
0008       caloPosition_(caloPos),
0009       photonCore_(core),
0010       pixelSeed_(false),
0011       haloTaggerMVAVal_(99) {}
0012 
0013 Photon::Photon(const Photon& rhs)
0014     : RecoCandidate(rhs),
0015       caloPosition_(rhs.caloPosition_),
0016       photonCore_(rhs.photonCore_),
0017       pixelSeed_(rhs.pixelSeed_),
0018       fiducialFlagBlock_(rhs.fiducialFlagBlock_),
0019       isolationR04_(rhs.isolationR04_),
0020       isolationR03_(rhs.isolationR03_),
0021       showerShapeBlock_(rhs.showerShapeBlock_),
0022       full5x5_showerShapeBlock_(rhs.full5x5_showerShapeBlock_),
0023       saturationInfo_(rhs.saturationInfo_),
0024       eCorrections_(rhs.eCorrections_),
0025       mipVariableBlock_(rhs.mipVariableBlock_),
0026       pfIsolation_(rhs.pfIsolation_),
0027       haloTaggerMVAVal_(rhs.haloTaggerMVAVal_) {}
0028 
0029 Photon::~Photon() {}
0030 
0031 Photon* Photon::clone() const { return new Photon(*this); }
0032 
0033 bool Photon::overlap(const Candidate& c) const {
0034   const RecoCandidate* o = dynamic_cast<const RecoCandidate*>(&c);
0035   return (o != nullptr && (checkOverlap(superCluster(), o->superCluster())));
0036   return false;
0037 }
0038 
0039 void Photon::setVertex(const Point& vertex) {
0040   math::XYZVectorF direction = caloPosition() - vertex;
0041   double energy = this->energy();
0042   math::XYZVectorF momentum = direction.unit() * energy;
0043   math::XYZTLorentzVector lv(momentum.x(), momentum.y(), momentum.z(), energy);
0044   setP4(lv);
0045   LeafCandidate::setVertex(vertex);
0046 }
0047 
0048 reco::SuperClusterRef Photon::superCluster() const { return this->photonCore()->superCluster(); }
0049 
0050 int Photon::conversionTrackProvenance(const edm::RefToBase<reco::Track>& convTrack) const {
0051   const reco::ConversionRefVector& conv2leg = this->photonCore()->conversions();
0052   const reco::ConversionRefVector& conv1leg = this->photonCore()->conversionsOneLeg();
0053 
0054   int origin = -1;
0055   bool isEg = false, isPf = false;
0056 
0057   for (unsigned iConv = 0; iConv < conv2leg.size(); iConv++) {
0058     std::vector<edm::RefToBase<reco::Track> > convtracks = conv2leg[iConv]->tracks();
0059     for (unsigned itk = 0; itk < convtracks.size(); itk++) {
0060       if (convTrack == convtracks[itk])
0061         isEg = true;
0062     }
0063   }
0064 
0065   for (unsigned iConv = 0; iConv < conv1leg.size(); iConv++) {
0066     std::vector<edm::RefToBase<reco::Track> > convtracks = conv1leg[iConv]->tracks();
0067     for (unsigned itk = 0; itk < convtracks.size(); itk++) {
0068       if (convTrack == convtracks[itk])
0069         isPf = true;
0070     }
0071   }
0072 
0073   if (isEg)
0074     origin = egamma;
0075   if (isPf)
0076     origin = pflow;
0077   if (isEg && isPf)
0078     origin = both;
0079 
0080   return origin;
0081 }
0082 
0083 void Photon::setCorrectedEnergy(P4type type, float newEnergy, float delta_e, bool setToRecoCandidate) {
0084   math::XYZTLorentzVectorD newP4 = p4();
0085   newP4 *= newEnergy / newP4.e();
0086   switch (type) {
0087     case ecal_standard:
0088       eCorrections_.scEcalEnergy = newEnergy;
0089       eCorrections_.scEcalEnergyError = delta_e;
0090       break;
0091     case ecal_photons:
0092       eCorrections_.phoEcalEnergy = newEnergy;
0093       eCorrections_.phoEcalEnergyError = delta_e;
0094       break;
0095     case regression1:
0096       eCorrections_.regression1Energy = newEnergy;
0097       eCorrections_.regression1EnergyError = delta_e;
0098       [[fallthrough]];
0099     case regression2:
0100       eCorrections_.regression2Energy = newEnergy;
0101       eCorrections_.regression2EnergyError = delta_e;
0102       break;
0103     default:
0104       throw cms::Exception("reco::Photon") << "unexpected p4 type: " << type;
0105   }
0106   setP4(type, newP4, delta_e, setToRecoCandidate);
0107 }
0108 
0109 float Photon::getCorrectedEnergy(P4type type) const {
0110   switch (type) {
0111     case ecal_standard:
0112       return eCorrections_.scEcalEnergy;
0113       break;
0114     case ecal_photons:
0115       return eCorrections_.phoEcalEnergy;
0116       break;
0117     case regression1:
0118       return eCorrections_.regression1Energy;
0119     case regression2:
0120       return eCorrections_.regression2Energy;
0121       break;
0122     default:
0123       throw cms::Exception("reco::Photon") << "unexpected p4 type " << type << " cannot return the energy value: ";
0124   }
0125 }
0126 
0127 float Photon::getCorrectedEnergyError(P4type type) const {
0128   switch (type) {
0129     case ecal_standard:
0130       return eCorrections_.scEcalEnergyError;
0131       break;
0132     case ecal_photons:
0133       return eCorrections_.phoEcalEnergyError;
0134       break;
0135     case regression1:
0136       return eCorrections_.regression1EnergyError;
0137     case regression2:
0138       return eCorrections_.regression2EnergyError;
0139       break;
0140     default:
0141       throw cms::Exception("reco::Photon")
0142           << "unexpected p4 type " << type << " cannot return the uncertainty on the energy: ";
0143   }
0144 }
0145 
0146 void Photon::setP4(P4type type, const LorentzVector& p4, float error, bool setToRecoCandidate) {
0147   switch (type) {
0148     case ecal_standard:
0149       eCorrections_.scEcalP4 = p4;
0150       eCorrections_.scEcalEnergyError = error;
0151       break;
0152     case ecal_photons:
0153       eCorrections_.phoEcalP4 = p4;
0154       eCorrections_.phoEcalEnergyError = error;
0155       break;
0156     case regression1:
0157       eCorrections_.regression1P4 = p4;
0158       eCorrections_.regression1EnergyError = error;
0159       [[fallthrough]];
0160     case regression2:
0161       eCorrections_.regression2P4 = p4;
0162       eCorrections_.regression2EnergyError = error;
0163       break;
0164     default:
0165       throw cms::Exception("reco::Photon") << "unexpected p4 type: " << type;
0166   }
0167   if (setToRecoCandidate) {
0168     setP4(p4);
0169     eCorrections_.candidateP4type = type;
0170   }
0171 }
0172 
0173 const Candidate::LorentzVector& Photon::p4(P4type type) const {
0174   switch (type) {
0175     case ecal_standard:
0176       return eCorrections_.scEcalP4;
0177     case ecal_photons:
0178       return eCorrections_.phoEcalP4;
0179     case regression1:
0180       return eCorrections_.regression1P4;
0181     case regression2:
0182       return eCorrections_.regression2P4;
0183     default:
0184       throw cms::Exception("reco::Photon") << "unexpected p4 type: " << type << " cannot return p4 ";
0185   }
0186 }
0187 
0188 void Photon::hcalToRun2EffDepth() {
0189   auto& ss1 = showerShapeBlock_;
0190   auto& ss2 = full5x5_showerShapeBlock_;
0191   auto& iv1 = isolationR03_;
0192   auto& iv2 = isolationR04_;
0193 
0194   for (uint id = 2u; id < ss1.hcalOverEcal.size(); ++id) {
0195     ss1.hcalOverEcal[1] += ss1.hcalOverEcal[id];
0196     ss1.hcalOverEcalBc[1] += ss1.hcalOverEcalBc[id];
0197 
0198     ss1.hcalOverEcal[id] = 0.f;
0199     ss1.hcalOverEcalBc[id] = 0.f;
0200 
0201     ss2.hcalOverEcal[1] += ss2.hcalOverEcal[id];
0202     ss2.hcalOverEcalBc[1] += ss2.hcalOverEcalBc[id];
0203 
0204     ss2.hcalOverEcal[id] = 0.f;
0205     ss2.hcalOverEcalBc[id] = 0.f;
0206 
0207     iv1.hcalRecHitSumEt[1] += iv1.hcalRecHitSumEt[id];
0208     iv1.hcalRecHitSumEtBc[1] += iv1.hcalRecHitSumEtBc[id];
0209 
0210     iv1.hcalRecHitSumEt[id] = 0.f;
0211     iv1.hcalRecHitSumEtBc[id] = 0.f;
0212 
0213     iv2.hcalRecHitSumEt[1] += iv2.hcalRecHitSumEt[id];
0214     iv2.hcalRecHitSumEtBc[1] += iv2.hcalRecHitSumEtBc[id];
0215 
0216     iv2.hcalRecHitSumEt[id] = 0.f;
0217     iv2.hcalRecHitSumEtBc[id] = 0.f;
0218   }
0219 }