Puppi isolation miniAOD electrons & photons v2

DataFormats/PatCandidates/interface/Electron.h

@@ -159,7 +159,30 @@ namespace pat {
       float hcalPFClusterIso() const { return hcalPFClusIso_; };
       void setEcalPFClusterIso(float ecalPFClus) { ecalPFClusIso_ = ecalPFClus; };
       void setHcalPFClusterIso(float hcalPFClus) { hcalPFClusIso_ = hcalPFClus; };
+      /// returns PUPPI isolations			
+      float puppiChargedHadronIso() const {return puppiChargedHadronIso_; }
+      float puppiNeutralHadronIso() const {return puppiNeutralHadronIso_; }
+      float puppiPhotonIso() const {return puppiPhotonIso_; }
+      /// returns PUPPINoLeptons isolations
+      float puppiNoLeptonsChargedHadronIso() const {return puppiNoLeptonsChargedHadronIso_; }
+      float puppiNoLeptonsNeutralHadronIso() const {return puppiNoLeptonsNeutralHadronIso_; }
+      float puppiNoLeptonsPhotonIso() const {return puppiNoLeptonsPhotonIso_; }
+      /// sets PUPPI isolations
+      void setIsolationPUPPI(float chargedhadrons_, float neutralhadrons_, float photons_)
+      {  
+         puppiChargedHadronIso_ = chargedhadrons_;
+         puppiNeutralHadronIso_ = neutralhadrons_;
+         puppiPhotonIso_ = photons_;
 
+      }
+      /// sets PUPPINoLeptons isolations
+      void setIsolationPUPPINoLeptons(float chargedhadrons_, float neutralhadrons_, float photons_)
+      {  
+         puppiNoLeptonsChargedHadronIso_ = chargedhadrons_;
+         puppiNoLeptonsNeutralHadronIso_ = neutralhadrons_;
+         puppiNoLeptonsPhotonIso_ = photons_;
+
+      }
       // ---- PF specific methods ----
       bool isPF() const{ return isPF_; }
       void setIsPF(bool hasPFCandidate) { isPF_ = hasPFCandidate ; }
@@ -344,6 +367,16 @@ namespace pat {
       float ecalPFClusIso_;
       float hcalPFClusIso_;
 
+      /// PUPPI isolations
+      float puppiChargedHadronIso_;
+      float puppiNeutralHadronIso_;
+      float puppiPhotonIso_;
+
+      /// PUPPINoLeptons isolations
+      float puppiNoLeptonsChargedHadronIso_;
+      float puppiNoLeptonsNeutralHadronIso_;
+      float puppiNoLeptonsPhotonIso_;
+
       /// conversion veto
       bool passConversionVeto_;
 

DataFormats/PatCandidates/interface/Photon.h

@@ -169,6 +169,11 @@ namespace pat {
 	    //<< key << " was not stored for this particle.";
           }
       }
+
+      float puppiChargedHadronIso() const {return puppiChargedHadronIso_; }
+      float puppiNeutralHadronIso() const {return puppiNeutralHadronIso_; }
+      float puppiPhotonIso() const {return puppiPhotonIso_; }
+
       /// Sets the isolation variable for a specifc key.
       /// Note that you can't set isolation for a pseudo-key like CaloIso
       void setIsolation(IsolationKeys key, float value) {
@@ -191,6 +196,14 @@ namespace pat {
       void setHcalIso(float caloIso)   { setIsolation(HcalIso,  caloIso);  }
       /// Sets user isolation variable #index
       void setUserIso(float value, uint8_t index=0)  { setIsolation(IsolationKeys(UserBaseIso + index), value); }
+      /// Sets PUPPI isolation
+      void setIsolationPUPPI(float chargedhadrons_, float neutralhadrons_, float photons_)
+      {  
+         puppiChargedHadronIso_ = chargedhadrons_;
+         puppiNeutralHadronIso_ = neutralhadrons_;
+         puppiPhotonIso_ = photons_;
+
+      }
 
       // ---- methods for photon isolation deposits ----
       /// Returns the IsoDeposit associated with some key, or a null pointer if it is not available
@@ -392,6 +405,11 @@ namespace pat {
       float ecalPFClusIso_;
       float hcalPFClusIso_;
 
+      //PUPPI isolations
+      float puppiChargedHadronIso_;
+      float puppiNeutralHadronIso_;
+      float puppiPhotonIso_;
+
       // ---- link to PackedPFCandidates
       edm::RefProd<pat::PackedCandidateCollection> packedPFCandidates_;
       std::vector<uint16_t> associatedPackedFCandidateIndices_;

DataFormats/PatCandidates/src/classes_def_objects.xml

@@ -16,7 +16,8 @@
   <class name="pat::Lepton<reco::BaseTau>" />
 
   <!-- PAT Objects, and embedded data  -->
-  <class name="pat::Electron"  ClassVersion="33">
+  <class name="pat::Electron"  ClassVersion="34">
+   <version ClassVersion="34" checksum="3720919820"/>
    <version ClassVersion="33" checksum="459924678"/>
    <version ClassVersion="32" checksum="3508125821"/>
    <version ClassVersion="31" checksum="1881133053"/>
@@ -192,7 +193,8 @@
   </ioread>
 
   <class name="std::vector<pat::tau::TauPFEssential>" />
-  <class name="pat::Photon"  ClassVersion="18">
+  <class name="pat::Photon"  ClassVersion="19">
+   <version ClassVersion="19" checksum="4285818507"/>
    <version ClassVersion="18" checksum="1413598928"/>
    <version ClassVersion="17" checksum="2394457997"/>
    <field name="superClusterRelinked_" transient="true"/>

PhysicsTools/IsolationAlgos/plugins/CITKPFIsolationSumProducerForPUPPI.cc

@@ -34,6 +34,8 @@ namespace citk {
 			      const edm::EventSetup&) override final;
 
     virtual void produce(edm::Event&, const edm::EventSetup&) override final;
+
+    static void fillDescriptions(edm::ConfigurationDescriptions & descriptions);
 
   private:  
     // datamembers
@@ -49,6 +51,7 @@ namespace citk {
     std::array<IsoTypes,kNPFTypes> _isolation_types; 
     std::array<std::vector<std::string>,kNPFTypes> _product_names;
     bool useValueMapForPUPPI = true;
+    bool usePUPPINoLepton = false;// in case puppi weights are taken from packedCandidate can take weights for puppiNoLeptons
   };
 }
 
@@ -153,8 +156,9 @@ namespace citk {
     	   for( unsigned i = 0; i < isolations.size(); ++ i  ) {
     	  if( isolations[i]->isInIsolationCone(cand_to_isolate,isocand) ) {
           double puppiWeight = 0.;
-    	    if (!useValueMapForPUPPI) puppiWeight = aspackedCandidate -> puppiWeight(); // if miniAOD, take puppiWeight directly from the object
-          else  puppiWeight = (*puppiValueMap)[isocand]; // if AOD, take puppiWeight from the valueMap
+    	    if (!useValueMapForPUPPI && !usePUPPINoLepton) puppiWeight = aspackedCandidate -> puppiWeight(); // if miniAOD, take puppiWeight directly from the object
+            else if (!useValueMapForPUPPI && usePUPPINoLepton) puppiWeight = aspackedCandidate -> puppiWeightNoLep(); // if miniAOD, take puppiWeightNoLep directly from the object
+            else  puppiWeight = (*puppiValueMap)[isocand]; // if AOD, take puppiWeight from the valueMap
           if (puppiWeight > 0.)cand_values[isotype][i] += (isocand->pt())*puppiWeight; // this is basically the main change to Lindsey's code: scale pt with puppiWeight for candidates with puppiWeight > 0.
     	  }
     	}
@@ -179,4 +183,38 @@ namespace citk {
       }
     }
   }
+
+
+// ParameterSet description for module
+void PFIsolationSumProducerForPUPPI::fillDescriptions(edm::ConfigurationDescriptions & descriptions)
+{ 
+    edm::ParameterSetDescription iDesc;
+    iDesc.setComment("PUPPI isolation sum producer");
+
+    iDesc.add<edm::InputTag>("srcToIsolate", edm::InputTag("no default"))->setComment("calculate isolation for this collection");
+    iDesc.add<edm::InputTag>("srcForIsolationCone", edm::InputTag("no default"))->setComment("collection for the isolation calculation: like particleFlow ");
+    iDesc.add<edm::InputTag>("puppiValueMap", edm::InputTag("puppi"))->setComment("source for puppi, if left empty weight from packedCandidate is taken");
+
+    edm::ParameterSetDescription descIsoConeDefinitions;
+    descIsoConeDefinitions.add<std::string>("isolationAlgo", "no default");
+    descIsoConeDefinitions.add<double>("coneSize", 0.3);
+    descIsoConeDefinitions.add<std::string>("isolateAgainst", "no default");
+    descIsoConeDefinitions.add<std::vector<unsigned>>("miniAODVertexCodes", {2,3});
+    descIsoConeDefinitions.addOptional<double>("VetoConeSizeBarrel", 0.0);
+    descIsoConeDefinitions.addOptional<double>("VetoConeSizeEndcaps", 0.0);
+    descIsoConeDefinitions.addOptional<int>("vertexIndex",0);
+    descIsoConeDefinitions.addOptional<edm::InputTag>("particleBasedIsolation",edm::InputTag("no default"))->setComment("map for footprint removal that is used for photons");
+
+
+    std::vector<edm::ParameterSet> isolationConeDefinitions;
+    edm::ParameterSet chargedHadrons, neutralHadrons,photons;
+    isolationConeDefinitions.push_back(chargedHadrons);
+    isolationConeDefinitions.push_back(neutralHadrons);
+    isolationConeDefinitions.push_back(photons);
+    iDesc.addVPSet("isolationConeDefinitions", descIsoConeDefinitions, isolationConeDefinitions);
+    iDesc.addOptional<bool>("usePUPPINoLepton",false);
+
+    descriptions.add("CITKPFIsolationSumProducerForPUPPI", iDesc);
+}
+
 }

PhysicsTools/PatAlgos/plugins/PATElectronProducer.cc

@@ -37,6 +37,8 @@
 #include "Geometry/CaloTopology/interface/CaloTopology.h"
 #include "Geometry/Records/interface/CaloGeometryRecord.h"
 
+#include "FWCore/ParameterSet/interface/EmptyGroupDescription.h"
+
 #include "FWCore/Utilities/interface/transform.h"
 
 #include <vector>
@@ -76,6 +78,7 @@ PATElectronProducer::PATElectronProducer(const edm::ParameterSet & iConfig) :
   reducedEndcapRecHitCollectionToken_(mayConsume<EcalRecHitCollection>(reducedEndcapRecHitCollection_)),
   // PFCluster Isolation maps
   addPFClusterIso_(iConfig.getParameter<bool>("addPFClusterIso")),
+  addPuppiIsolation_(iConfig.getParameter<bool>("addPuppiIsolation")),
   ecalPFClusterIsoT_(consumes<edm::ValueMap<float> >(iConfig.getParameter<edm::InputTag>("ecalPFClusterIsoMap"))),
   hcalPFClusterIsoT_(consumes<edm::ValueMap<float> >(iConfig.getParameter<edm::InputTag>("hcalPFClusterIsoMap"))),
   // embed high level selection variables?
@@ -104,6 +107,16 @@ PATElectronProducer::PATElectronProducer(const edm::ParameterSet & iConfig) :
   if (addResolutions_) {
     resolutionLoader_ = pat::helper::KinResolutionsLoader(iConfig.getParameter<edm::ParameterSet>("resolutions"));
   }
+  if(addPuppiIsolation_){
+    //puppi
+    PUPPIIsolation_charged_hadrons_ = consumes<edm::ValueMap<float> >(iConfig.getParameter<edm::InputTag>("puppiIsolationChargedHadrons"));
+    PUPPIIsolation_neutral_hadrons_ = consumes<edm::ValueMap<float> >(iConfig.getParameter<edm::InputTag>("puppiIsolationNeutralHadrons"));
+    PUPPIIsolation_photons_ = consumes<edm::ValueMap<float> >(iConfig.getParameter<edm::InputTag>("puppiIsolationPhotons"));
+    //puppiNoLeptons
+    PUPPINoLeptonsIsolation_charged_hadrons_ = consumes<edm::ValueMap<float> >(iConfig.getParameter<edm::InputTag>("puppiNoLeptonsIsolationChargedHadrons"));
+    PUPPINoLeptonsIsolation_neutral_hadrons_ = consumes<edm::ValueMap<float> >(iConfig.getParameter<edm::InputTag>("puppiNoLeptonsIsolationNeutralHadrons"));
+    PUPPINoLeptonsIsolation_photons_ = consumes<edm::ValueMap<float> >(iConfig.getParameter<edm::InputTag>("puppiNoLeptonsIsolationPhotons"));
+  }
   // electron ID configurables
   if (addElecID_) {
     // it might be a single electron ID
@@ -279,6 +292,25 @@ void PATElectronProducer::produce(edm::Event & iEvent, const edm::EventSetup & i
             << "No primary vertex available from EventSetup, not adding high level selection \n";
     }
   }
+  //value maps for puppi isolation
+  edm::Handle<edm::ValueMap<float>> PUPPIIsolation_charged_hadrons;
+  edm::Handle<edm::ValueMap<float>> PUPPIIsolation_neutral_hadrons;
+  edm::Handle<edm::ValueMap<float>> PUPPIIsolation_photons;
+  //value maps for puppiNoLeptons isolation
+  edm::Handle<edm::ValueMap<float>> PUPPINoLeptonsIsolation_charged_hadrons;
+  edm::Handle<edm::ValueMap<float>> PUPPINoLeptonsIsolation_neutral_hadrons;
+  edm::Handle<edm::ValueMap<float>> PUPPINoLeptonsIsolation_photons;
+  if(addPuppiIsolation_){
+    //puppi
+    iEvent.getByToken(PUPPIIsolation_charged_hadrons_, PUPPIIsolation_charged_hadrons);
+    iEvent.getByToken(PUPPIIsolation_neutral_hadrons_, PUPPIIsolation_neutral_hadrons);
+    iEvent.getByToken(PUPPIIsolation_photons_, PUPPIIsolation_photons);  
+    //puppiNoLeptons
+    iEvent.getByToken(PUPPINoLeptonsIsolation_charged_hadrons_, PUPPINoLeptonsIsolation_charged_hadrons);
+    iEvent.getByToken(PUPPINoLeptonsIsolation_neutral_hadrons_, PUPPINoLeptonsIsolation_neutral_hadrons);
+    iEvent.getByToken(PUPPINoLeptonsIsolation_photons_, PUPPINoLeptonsIsolation_photons);  
+  }
+
 
   std::vector<Electron> * patElectrons = new std::vector<Electron>();
 
@@ -300,6 +332,7 @@ void PATElectronProducer::produce(edm::Event & iEvent, const edm::EventSetup & i
       bool MatchedToAmbiguousGsfTrack=false;
       for (edm::View<reco::GsfElectron>::const_iterator itElectron = electrons->begin(); itElectron != electrons->end(); ++itElectron) {
 	unsigned int idx = itElectron - electrons->begin();
+  	auto elePtr = electrons -> ptrAt(idx);
 	if (Matched || MatchedToAmbiguousGsfTrack) continue;
 
 	reco::GsfTrackRef EgTk= itElectron->gsfTrack();
@@ -323,6 +356,14 @@ void PATElectronProducer::produce(edm::Event & iEvent, const edm::EventSetup & i
 	  const edm::RefToBase<reco::GsfElectron>& elecsRef = electrons->refAt(idx);
 	  Electron anElectron(elecsRef);
 	  anElectron.setPFCandidateRef( pfRef  );
+    	  if (addPuppiIsolation_) {		 
+	    anElectron.setIsolationPUPPI((*PUPPIIsolation_charged_hadrons)[elePtr], (*PUPPIIsolation_neutral_hadrons)[elePtr], (*PUPPIIsolation_photons)[elePtr]);
+      	    anElectron.setIsolationPUPPINoLeptons((*PUPPINoLeptonsIsolation_charged_hadrons)[elePtr], (*PUPPINoLeptonsIsolation_neutral_hadrons)[elePtr], (*PUPPINoLeptonsIsolation_photons)[elePtr]);
+    	  }
+	  else {
+      	    anElectron.setIsolationPUPPI(-999., -999.,-999.);
+	    anElectron.setIsolationPUPPINoLeptons(-999., -999.,-999.);
+          }
 
           //it should be always true when particleFlow electrons are used.
           anElectron.setIsPF( true );
@@ -503,6 +544,7 @@ void PATElectronProducer::produce(edm::Event & iEvent, const edm::EventSetup & i
       edm::RefToBase<reco::GsfElectron> elecsRef = electrons->refAt(idx);
       reco::CandidateBaseRef elecBaseRef(elecsRef);
       Electron anElectron(elecsRef);
+      auto elePtr = electrons -> ptrAt(idx);
 
       // Is this GsfElectron also identified as an e- in the particle flow?
       bool pfId = false;
@@ -605,7 +647,15 @@ void PATElectronProducer::produce(edm::Event & iEvent, const edm::EventSetup & i
 	anElectron.setEcalPFClusterIso(-999.);
 	anElectron.setHcalPFClusterIso(-999.);
       }
-
+      if (addPuppiIsolation_) {
+        anElectron.setIsolationPUPPI((*PUPPIIsolation_charged_hadrons)[elePtr], (*PUPPIIsolation_neutral_hadrons)[elePtr], (*PUPPIIsolation_photons)[elePtr]);
+        anElectron.setIsolationPUPPINoLeptons((*PUPPINoLeptonsIsolation_charged_hadrons)[elePtr], (*PUPPINoLeptonsIsolation_neutral_hadrons)[elePtr], (*PUPPINoLeptonsIsolation_photons)[elePtr]);
+      }
+      else {
+        anElectron.setIsolationPUPPI(-999., -999.,-999.);
+        anElectron.setIsolationPUPPINoLeptons(-999., -999.,-999.);
+      }
+
       std::vector<DetId> selectedCells;
       bool barrel = itElectron->isEB();
       //loop over sub clusters
@@ -892,6 +942,16 @@ void PATElectronProducer::fillDescriptions(edm::ConfigurationDescriptions & desc
 		false >> (edm::ParameterDescription<edm::InputTag>("ecalPFClusterIsoMap", edm::InputTag(""), true) and
 			  edm::ParameterDescription<edm::InputTag>("hcalPFClusterIsoMap", edm::InputTag(""),true)));
 
+  iDesc.ifValue(edm::ParameterDescription<bool>("addPuppiIsolation", false, true),
+    true >> (edm::ParameterDescription<edm::InputTag>("puppiIsolationChargedHadrons", edm::InputTag("egmElectronPUPPIIsolation","h+-DR030-BarVeto000-EndVeto001"), true) and
+       edm::ParameterDescription<edm::InputTag>("puppiIsolationNeutralHadrons", edm::InputTag("egmElectronPUPPIIsolation","h0-DR030-BarVeto000-EndVeto000"), true) and 
+       edm::ParameterDescription<edm::InputTag>("puppiIsolationPhotons", edm::InputTag("egmElectronPUPPIIsolation","gamma-DR030-BarVeto000-EndVeto008"), true) and
+       edm::ParameterDescription<edm::InputTag>("puppiNoLeptonsIsolationChargedHadrons", edm::InputTag("egmElectronPUPPINoLeptonsIsolation","gamma-DR030-BarVeto000-EndVeto008"), true) and 
+       edm::ParameterDescription<edm::InputTag>("puppiNoLeptonsIsolationNeutralHadrons", edm::InputTag("egmElectronPUPPINoLeptonsIsolation","gamma-DR030-BarVeto000-EndVeto008"), true) and 
+       edm::ParameterDescription<edm::InputTag>("puppiNoLeptonsIsolationPhotons", edm::InputTag("egmElectronPUPPINoLeptonsIsolation","gamma-DR030-BarVeto000-EndVeto008"), true))  or
+    false >> edm::EmptyGroupDescription());
+
+
   // embedding
   iDesc.add<bool>("embedGsfElectronCore", true)->setComment("embed external gsf electron core");
   iDesc.add<bool>("embedGsfTrack", true)->setComment("embed external gsf track");
@@ -980,6 +1040,7 @@ void PATElectronProducer::fillDescriptions(edm::ConfigurationDescriptions & desc
   PATUserDataHelper<Electron>::fillDescription(userDataPSet);
   iDesc.addOptional("userData", userDataPSet);
 
+
   // electron shapes
   iDesc.add<bool>("addElectronShapes", true);
   iDesc.add<edm::InputTag>("reducedBarrelRecHitCollection", edm::InputTag("reducedEcalRecHitsEB"));

PhysicsTools/PatAlgos/plugins/PATElectronProducer.h

@@ -98,6 +98,7 @@ namespace pat {
       const edm::EDGetTokenT<EcalRecHitCollection> reducedEndcapRecHitCollectionToken_;
 
       const bool addPFClusterIso_;
+      const bool addPuppiIsolation_;
       const edm::EDGetTokenT<edm::ValueMap<float> > ecalPFClusterIsoT_;
       const edm::EDGetTokenT<edm::ValueMap<float> > hcalPFClusterIsoT_;
 
@@ -173,6 +174,14 @@ namespace pat {
       pat::helper::KinResolutionsLoader resolutionLoader_;
 
       const bool useUserData_;
+      //PUPPI isolation tokens
+      edm::EDGetTokenT<edm::ValueMap<float> > PUPPIIsolation_charged_hadrons_;
+      edm::EDGetTokenT<edm::ValueMap<float> > PUPPIIsolation_neutral_hadrons_;
+      edm::EDGetTokenT<edm::ValueMap<float> > PUPPIIsolation_photons_;
+      //PUPPINoLeptons isolation tokens
+      edm::EDGetTokenT<edm::ValueMap<float> > PUPPINoLeptonsIsolation_charged_hadrons_;
+      edm::EDGetTokenT<edm::ValueMap<float> > PUPPINoLeptonsIsolation_neutral_hadrons_;
+      edm::EDGetTokenT<edm::ValueMap<float> > PUPPINoLeptonsIsolation_photons_;
       pat::PATUserDataHelper<pat::Electron>      userDataHelper_;
 
       const CaloTopology * ecalTopology_;