ParticleFlow/interface/IsolatedPFCandidateSelectorDefinition.h

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