plugins/isolation_cones/ElectronPFIsolationWithMapBasedVeto.cc

0001 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0002 #include "FWCore/Framework/interface/Frameworkfwd.h"
0003
0004 #include "FWCore/Framework/interface/Event.h"
0005 #include "FWCore/Framework/interface/EventSetup.h"
0006
0007 #include "DataFormats/Candidate/interface/Candidate.h"
0008 #include "DataFormats/Candidate/interface/CandidateFwd.h"
0009
0010 #include "DataFormats/EgammaCandidates/interface/GsfElectron.h"
0011 #include "DataFormats/EgammaCandidates/interface/GsfElectronFwd.h"
0012
0013 #include "DataFormats/PatCandidates/interface/Electron.h"
0014
0015 #include "DataFormats/PatCandidates/interface/Photon.h"
0016
0017 #include "DataFormats/Common/interface/ValueMap.h"
0018 #include "FWCore/Framework/interface/ConsumesCollector.h"
0019
0020 #include "DataFormats/ParticleFlowCandidate/interface/PFCandidate.h"
0021 #include "DataFormats/PatCandidates/interface/PackedCandidate.h"
0022
0023 #include "PhysicsTools/IsolationAlgos/interface/IsoDepositVetoFactory.h"
0024 #include "DataFormats/RecoCandidate/interface/IsoDepositVetos.h"
0025
0026 #include "PhysicsTools/IsolationAlgos/interface/CITKIsolationConeDefinitionBase.h"
0027 #include "DataFormats/Math/interface/deltaR.h"
0028
0029 #include "DataFormats/EcalDetId/interface/EcalSubdetector.h"
0030
0031 #include <unordered_map>
0032 namespace reco {
0033   typedef edm::Ptr<reco::GsfElectron> GsfElectronPtr;
0034 }
0035
0036 namespace pat {
0037   typedef edm::Ptr<pat::PackedCandidate> PackedCandidatePtr;
0038   typedef edm::Ptr<pat::Electron> patElectronPtr;
0039 }  // namespace pat
0040 namespace {
0041   // This template function finds whether theCandidate is in thefootprint
0042   // // collection. It is templated to be able to handle both reco and pat
0043   // // photons (from AOD and miniAOD, respectively).
0044   //
0045   template <class T, class U>
0046   bool isInFootprint(const T& thefootprint, const U& theCandidate) {
0047     for (auto itr = thefootprint.begin(); itr != thefootprint.end(); ++itr) {
0048       if (itr->key() == theCandidate.key())
0049         return true;
0050     }
0051     return false;
0052   }
0053   //This function is needed because pfNoPileUpCandidates have changed keys,
0054   ////and thus the solution is to use sourceCandidatePtr(0)
0055   // // This function *shouldn't be used for packedCandidate*
0056   template <class T, class U>
0057   bool isInFootprintAlternative(const T& thefootprint, const U& theCandidate) {
0058     for (auto itr = thefootprint.begin(); itr != thefootprint.end(); ++itr) {
0059       if (itr->key() == theCandidate->sourceCandidatePtr(0).key())
0060         return true;
0061     }
0062     return false;
0063   }
0064
0065 }  // namespace
0066 class ElectronPFIsolationWithMapBasedVeto : public citk::IsolationConeDefinitionBase {
0067 public:
0068   ElectronPFIsolationWithMapBasedVeto(const edm::ParameterSet& c)
0069       : citk::IsolationConeDefinitionBase(c),
0070         _isolateAgainst(c.getParameter<std::string>("isolateAgainst")),  //isolate against either h+, h0 or gamma
0071         _miniAODVertexCodes(c.getParameter<std::vector<unsigned> >(
0072             "miniAODVertexCodes")),  //quality flags to be used for association with the vertex configurable, the vertex can be chosen
0073         _particleBasedIsolation(c.getParameter<edm::InputTag>("particleBasedIsolation")) {
0074   }  // particle based isolation map (used for footprint removal)
0075
0076   ElectronPFIsolationWithMapBasedVeto(const ElectronPFIsolationWithMapBasedVeto&) = delete;
0077   ElectronPFIsolationWithMapBasedVeto& operator=(const ElectronPFIsolationWithMapBasedVeto&) = delete;
0078
0079   bool isInIsolationCone(const reco::CandidatePtr& photon, const reco::CandidatePtr& other) const final;
0080
0081   // this object is needed for reco case
0082   edm::Handle<edm::ValueMap<std::vector<reco::PFCandidateRef> > > particleBasedIsolationMap;
0083   edm::EDGetTokenT<edm::ValueMap<std::vector<reco::PFCandidateRef> > > particleBasedIsolationToken_;
0084
0085   void getEventInfo(const edm::Event& iEvent) override {
0086     iEvent.getByToken(particleBasedIsolationToken_, particleBasedIsolationMap);
0087   };
0088
0089   //As far as I understand now, the object particleBasedIsolationMap should be fixed, so we don't configure the name
0090   void setConsumes(edm::ConsumesCollector iC) override {
0091     particleBasedIsolationToken_ =
0092         iC.mayConsume<edm::ValueMap<std::vector<reco::PFCandidateRef> > >(_particleBasedIsolation);
0093   }
0094
0095   //! Destructor
0096   ~ElectronPFIsolationWithMapBasedVeto() override{};
0097
0098 private:
0099   const std::string _isolateAgainst, _vertexCollection;
0100   const std::vector<unsigned> _miniAODVertexCodes;
0101   const edm::InputTag _particleBasedIsolation;
0102 };
0103
0104 DEFINE_EDM_PLUGIN(CITKIsolationConeDefinitionFactory,
0105                   ElectronPFIsolationWithMapBasedVeto,
0106                   "ElectronPFIsolationWithMapBasedVeto");
0107
0108 //This function defines whether particular PFCandidate is inside of isolation cone of photon or not by checking deltaR and whether footprint removal for this candidate should be done. Additionally, for miniAOD charged hadrons from the PV are considered. *** For AOD this should be done by the corresponding sequence beforehand!!! ***
0109
0110 bool ElectronPFIsolationWithMapBasedVeto::isInIsolationCone(const reco::CandidatePtr& electron,
0111                                                             const reco::CandidatePtr& pfCandidate) const {
0112   //convert the electron and candidate objects to the corresponding pat or reco objects. What is used depends on what is user running on: miniAOD or AOD
0113   pat::patElectronPtr aspat_electronptr(electron);
0114
0115   pat::PackedCandidatePtr aspacked(pfCandidate);
0116   reco::PFCandidatePtr aspf(pfCandidate);
0117
0118   bool inFootprint = false;
0119   bool result = true;
0120   const float deltar2 =
0121       reco::deltaR2(*electron, *pfCandidate);  //calculate deltaR2 distance between PFCandidate and photon
0122
0123   // dealing here with patObjects: miniAOD case
0124   if (aspacked.get()) {
0125     inFootprint = isInFootprint(aspat_electronptr->associatedPackedPFCandidates(), aspacked);
0126
0127     //checking if the charged candidates come from the appropriate vertex
0128     if (aspacked->charge() != 0) {
0129       bool is_vertex_allowed = false;
0130       for (const unsigned vtxtype : _miniAODVertexCodes) {
0131         if (vtxtype == aspacked->fromPV()) {
0132           is_vertex_allowed = true;
0133           break;
0134         }
0135       }
0136
0137       result &= (is_vertex_allowed);
0138     }
0139     //return true if the candidate is inside the cone and not in the footprint
0140     result &= deltar2 < _coneSize2 && (!inFootprint);
0141   }
0142
0143   // dealing here with recoObjects: AOD case
0144   else if (aspf.get()) {
0145     inFootprint = isInFootprintAlternative((*particleBasedIsolationMap)[electron], pfCandidate);
0146     //return true if the candidate is inside the cone and not in the footprint
0147     result &= deltar2 < _coneSize2 && (!inFootprint);
0148   }
0149
0150   // throw exception if it is not a patObject or recoObject
0151   else {
0152     throw cms::Exception("InvalidIsolationInput") << "The supplied candidate to be used as isolation "
0153                                                   << "was neither a reco::Photon nor a pat::Photon!";
0154   }
0155
0156   return result;
0157 }