Back to home page

Project CMSSW displayed by LXR

 
 

    


File indexing completed on 2025-02-05 23:51:09

0001 #ifndef CommonTools_ParticleFlow_IsolatedPFCandidateSelectorDefinition
0002 #define CommonTools_ParticleFlow_IsolatedPFCandidateSelectorDefinition
0003 
0004 #include "FWCore/Framework/interface/Event.h"
0005 #include "FWCore/Framework/interface/ConsumesCollector.h"
0006 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0007 #include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
0008 #include "DataFormats/ParticleFlowCandidate/interface/PFCandidateFwd.h"
0009 #include "DataFormats/ParticleFlowCandidate/interface/PFCandidate.h"
0010 #include "CommonTools/ParticleFlow/interface/PFCandidateSelectorDefinition.h"
0011 #include "DataFormats/Common/interface/ValueMap.h"
0012 #include "FWCore/Utilities/interface/Exception.h"
0013 #include "FWCore/Utilities/interface/transform.h"
0014 
0015 namespace pf2pat {
0016 
0017   class IsolatedPFCandidateSelectorDefinition : public PFCandidateSelectorDefinition {
0018   public:
0019     typedef edm::ValueMap<double> IsoMap;
0020 
0021     IsolatedPFCandidateSelectorDefinition(const edm::ParameterSet& cfg, edm::ConsumesCollector&& iC)
0022         : isolationValueMapChargedTokens_(
0023               edm::vector_transform(cfg.getParameter<std::vector<edm::InputTag> >("isolationValueMapsCharged"),
0024                                     [&](edm::InputTag const& tag) { return iC.consumes<IsoMap>(tag); })),
0025           isolationValueMapNeutralTokens_(
0026               edm::vector_transform(cfg.getParameter<std::vector<edm::InputTag> >("isolationValueMapsNeutral"),
0027                                     [&](edm::InputTag const& tag) { return iC.consumes<IsoMap>(tag); })),
0028           doDeltaBetaCorrection_(cfg.getParameter<bool>("doDeltaBetaCorrection")),
0029           deltaBetaIsolationValueMapToken_(
0030               iC.mayConsume<IsoMap>(cfg.getParameter<edm::InputTag>("deltaBetaIsolationValueMap"))),
0031           deltaBetaFactor_(cfg.getParameter<double>("deltaBetaFactor")),
0032           isRelative_(cfg.getParameter<bool>("isRelative")),
0033           isolationCut_(cfg.getParameter<double>("isolationCut")) {}
0034 
0035     void select(const HandleToCollection& hc, const edm::Event& e, const edm::EventSetup& s) {
0036       selected_.clear();
0037 
0038       // read all charged isolation value maps
0039       std::vector<edm::Handle<IsoMap> > isoMapsCharged(isolationValueMapChargedTokens_.size());
0040       for (unsigned iMap = 0; iMap < isolationValueMapChargedTokens_.size(); ++iMap) {
0041         e.getByToken(isolationValueMapChargedTokens_[iMap], isoMapsCharged[iMap]);
0042       }
0043 
0044       // read all neutral isolation value maps
0045       std::vector<edm::Handle<IsoMap> > isoMapsNeutral(isolationValueMapNeutralTokens_.size());
0046       for (unsigned iMap = 0; iMap < isolationValueMapNeutralTokens_.size(); ++iMap) {
0047         e.getByToken(isolationValueMapNeutralTokens_[iMap], isoMapsNeutral[iMap]);
0048       }
0049 
0050       edm::Handle<IsoMap> dBetaH;
0051       if (doDeltaBetaCorrection_) {
0052         e.getByToken(deltaBetaIsolationValueMapToken_, dBetaH);
0053       }
0054 
0055       unsigned key = 0;
0056       for (collection::const_iterator pfc = hc->begin(); pfc != hc->end(); ++pfc, ++key) {
0057         reco::PFCandidateRef candidate(hc, key);
0058 
0059         bool passed = true;
0060         double isoSumCharged = 0.0;
0061         double isoSumNeutral = 0.0;
0062 
0063         for (unsigned iMap = 0; iMap < isoMapsCharged.size(); ++iMap) {
0064           const IsoMap& isoMap = *(isoMapsCharged[iMap]);
0065           double val = isoMap[candidate];
0066           isoSumCharged += val;
0067         }
0068 
0069         for (unsigned iMap = 0; iMap < isoMapsNeutral.size(); ++iMap) {
0070           const IsoMap& isoMap = *(isoMapsNeutral[iMap]);
0071           double val = isoMap[candidate];
0072           isoSumNeutral += val;
0073         }
0074 
0075         if (doDeltaBetaCorrection_) {
0076           const IsoMap& isoMap = *dBetaH;
0077           double dBetaVal = isoMap[candidate];
0078           double dBetaCorIsoSumNeutral = isoSumNeutral + deltaBetaFactor_ * dBetaVal;
0079           isoSumNeutral = dBetaCorIsoSumNeutral > 0 ? dBetaCorIsoSumNeutral : 0;  //follow muon POG definition in 2012
0080         }
0081 
0082         double isoSum = isoSumCharged + isoSumNeutral;
0083 
0084         if (isRelative_) {
0085           isoSum /= candidate->pt();
0086         }
0087 
0088         if (isoSum > isolationCut_) {
0089           passed = false;
0090         }
0091 
0092         if (passed) {
0093           // passed all cuts, selected
0094           selected_.push_back(reco::PFCandidate(*pfc));
0095           reco::PFCandidatePtr ptrToMother(hc, key);
0096           selected_.back().setSourceCandidatePtr(ptrToMother);
0097         }
0098       }
0099     }
0100 
0101     static void fillPSetDescription(edm::ParameterSetDescription& desc) {
0102       desc.add<std::vector<edm::InputTag> >("isolationValueMapsCharged", {});
0103       desc.add<std::vector<edm::InputTag> >("isolationValueMapsNeutral", {});
0104       desc.add<bool>("doDeltaBetaCorrection", false);
0105       desc.add<edm::InputTag>("deltaBetaIsolationValueMap", edm::InputTag(""));
0106       desc.add<double>("deltaBetaFactor", -0.5);
0107       desc.add<bool>("isRelative", true)->setComment("if True isolation is relative to pT");
0108       desc.add<double>("isolationCut", 999);
0109     }
0110 
0111   private:
0112     std::vector<edm::EDGetTokenT<IsoMap> > isolationValueMapChargedTokens_;
0113     std::vector<edm::EDGetTokenT<IsoMap> > isolationValueMapNeutralTokens_;
0114     bool doDeltaBetaCorrection_;
0115     edm::EDGetTokenT<IsoMap> deltaBetaIsolationValueMapToken_;
0116     double deltaBetaFactor_;
0117     bool isRelative_;
0118     double isolationCut_;
0119   };
0120 
0121 }  // namespace pf2pat
0122 
0123 #endif