Merge pull request #2345 from cms-analysis-tools/71X-photon

PatAlgos -- 71 x photon

DataFormats/PatCandidates/interface/Photon.h

@@ -100,6 +100,23 @@ namespace pat {
       /// Returns the calorimeter isolation combined from ecal 
       /// and hcal 
       float caloIso()  const { return ecalIso()+hcalIso(); }
+
+      /// PARTICLE FLOW ISOLATION
+      /// Returns the isolation calculated with all the PFCandidates
+      float particleIso() const { return userIsolation(pat::PfAllParticleIso); }
+      /// Returns the isolation calculated with only the charged hadron
+      /// PFCandidates
+      float chargedHadronIso() const { return userIsolation(pat::PfChargedHadronIso); }
+      /// Returns the isolation calculated with only the neutral hadron
+      /// PFCandidates
+      float neutralHadronIso() const { return userIsolation(pat::PfNeutralHadronIso); }        
+      /// Returns the isolation calculated with only the gamma
+      /// PFCandidates
+      float photonIso() const { return userIsolation(pat::PfGammaIso); }
+      /// Returns the isolation calculated with only the pile-up charged hadron
+      /// PFCandidates
+      float puChargedHadronIso() const { return userIsolation(pat::PfPUChargedHadronIso); }        
+
       /// Returns a user defined isolation value
       float userIso(uint8_t index=0)  const { return userIsolation(IsolationKeys(UserBaseIso + index)); }
       /// Returns the isolation variable for a specifc key (or 

PhysicsTools/PatAlgos/plugins/PATElectronProducer.h

@@ -144,7 +144,7 @@ namespace pat {
       template<typename T> void readIsolationLabels( const edm::ParameterSet & iConfig,
 				                     const char* psetName,
 				                     IsolationLabels& labels,
-					             std::vector<edm::EDGetTokenT<edm::ValueMap<T> > > tokens);
+					             std::vector<edm::EDGetTokenT<edm::ValueMap<T> > > & tokens);
 
       bool          addElecID_;
       typedef std::pair<std::string, edm::InputTag> NameTag;
@@ -187,7 +187,7 @@ template<typename T>
 void PATElectronProducer::readIsolationLabels( const edm::ParameterSet & iConfig,
 					       const char* psetName,
 					       IsolationLabels& labels,
-					       std::vector<edm::EDGetTokenT<edm::ValueMap<T> > > tokens) {
+					       std::vector<edm::EDGetTokenT<edm::ValueMap<T> > > & tokens) {
 
   labels.clear();
 

PhysicsTools/PatAlgos/plugins/PATMuonProducer.h

@@ -65,7 +65,7 @@ namespace pat {
     void fillMuon( Muon& aMuon, const MuonBaseRef& muonRef, const reco::CandidateBaseRef& baseRef, const GenAssociations& genMatches, const IsoDepositMaps& deposits, const IsolationValueMaps& isolationValues) const;
     /// fill label vector from the contents of the parameter set,
     /// for the embedding of isoDeposits or userIsolation values
-    template<typename T> void readIsolationLabels( const edm::ParameterSet & iConfig, const char* psetName, IsolationLabels& labels, std::vector<edm::EDGetTokenT<edm::ValueMap<T> > > tokens);
+    template<typename T> void readIsolationLabels( const edm::ParameterSet & iConfig, const char* psetName, IsolationLabels& labels, std::vector<edm::EDGetTokenT<edm::ValueMap<T> > > & tokens);
 
 
     // embed various impact parameters with errors
@@ -160,7 +160,7 @@ using namespace pat;
 
 
 template<typename T>
-void PATMuonProducer::readIsolationLabels( const edm::ParameterSet & iConfig, const char* psetName, IsolationLabels& labels, std::vector<edm::EDGetTokenT<edm::ValueMap<T> > > tokens)
+void PATMuonProducer::readIsolationLabels( const edm::ParameterSet & iConfig, const char* psetName, IsolationLabels& labels, std::vector<edm::EDGetTokenT<edm::ValueMap<T> > > & tokens)
 {
   labels.clear();
 

PhysicsTools/PatAlgos/plugins/PATPhotonProducer.cc

@@ -78,21 +78,11 @@ PATPhotonProducer::PATPhotonProducer(const edm::ParameterSet & iConfig) :
   // produces vector of photons
   produces<std::vector<Photon> >();
 
-  if (iConfig.exists("isoDeposits")) {
-     edm::ParameterSet depconf = iConfig.getParameter<edm::ParameterSet>("isoDeposits");
-     if (depconf.exists("tracker")) isoDepositLabels_.push_back(std::make_pair(pat::TrackIso, depconf.getParameter<edm::InputTag>("tracker")));
-     if (depconf.exists("ecal"))    isoDepositLabels_.push_back(std::make_pair(pat::EcalIso, depconf.getParameter<edm::InputTag>("ecal")));
-     if (depconf.exists("hcal"))    isoDepositLabels_.push_back(std::make_pair(pat::HcalIso, depconf.getParameter<edm::InputTag>("hcal")));
-     if (depconf.exists("user")) {
-        std::vector<edm::InputTag> userdeps = depconf.getParameter<std::vector<edm::InputTag> >("user");
-        std::vector<edm::InputTag>::const_iterator it = userdeps.begin(), ed = userdeps.end();
-        int key = UserBaseIso;
-        for ( ; it != ed; ++it, ++key) {
-            isoDepositLabels_.push_back(std::make_pair(IsolationKeys(key), *it));
-        }
-     }
-  }
-  isoDepositTokens_ = edm::vector_transform(isoDepositLabels_, [this](std::pair<IsolationKeys,edm::InputTag> const & label){return consumes<edm::ValueMap<IsoDeposit> >(label.second);});
+  // read isoDeposit labels, for direct embedding
+  readIsolationLabels(iConfig, "isoDeposits", isoDepositLabels_, isoDepositTokens_);
+  // read isolation value labels, for direct embedding
+  readIsolationLabels(iConfig, "isolationValues", isolationValueLabels_, isolationValueTokens_);
+
 }
 
 PATPhotonProducer::~PATPhotonProducer() {
@@ -123,11 +113,17 @@ void PATPhotonProducer::produce(edm::Event & iEvent, const edm::EventSetup & iSe
   if (efficiencyLoader_.enabled()) efficiencyLoader_.newEvent(iEvent);
   if (resolutionLoader_.enabled()) resolutionLoader_.newEvent(iEvent, iSetup);
 
-  std::vector<edm::Handle<edm::ValueMap<IsoDeposit> > > deposits(isoDepositTokens_.size());
+  IsoDepositMaps deposits(isoDepositTokens_.size());
   for (size_t j = 0, nd = isoDepositTokens_.size(); j < nd; ++j) {
     iEvent.getByToken(isoDepositTokens_[j], deposits[j]);
   }
 
+  IsolationValueMaps isolationValues(isolationValueTokens_.size());
+  for (size_t j = 0; j<isolationValueTokens_.size(); ++j) {
+    iEvent.getByToken(isolationValueTokens_[j], isolationValues[j]);
+  }
+
+
   // prepare ID extraction
   std::vector<edm::Handle<edm::ValueMap<Bool_t> > > idhandles;
   std::vector<pat::Photon::IdPair>               ids;
@@ -180,7 +176,10 @@ void PATPhotonProducer::produce(edm::Event & iEvent, const edm::EventSetup & iSe
     for (size_t j = 0, nd = deposits.size(); j < nd; ++j) {
         aPhoton.setIsoDeposit(isoDepositLabels_[j].first, (*deposits[j])[photonRef]);
     }
-
+
+    for (size_t j = 0; j<isolationValues.size(); ++j) { 
+        aPhoton.setIsolation(isolationValueLabels_[j].first,(*isolationValues[j])[photonRef]);
+    }
 
     // add photon ID info
     if (addPhotonID_) {
@@ -243,8 +242,28 @@ void PATPhotonProducer::fillDescriptions(edm::ConfigurationDescriptions & descri
   isoDepositsPSet.addOptional<edm::InputTag>("tracker");
   isoDepositsPSet.addOptional<edm::InputTag>("ecal");
   isoDepositsPSet.addOptional<edm::InputTag>("hcal");
+  isoDepositsPSet.addOptional<edm::InputTag>("pfAllParticles");
+  isoDepositsPSet.addOptional<edm::InputTag>("pfChargedHadrons");
+  isoDepositsPSet.addOptional<edm::InputTag>("pfChargedAll");
+  isoDepositsPSet.addOptional<edm::InputTag>("pfPUChargedHadrons");
+  isoDepositsPSet.addOptional<edm::InputTag>("pfNeutralHadrons");
+  isoDepositsPSet.addOptional<edm::InputTag>("pfPhotons");
   isoDepositsPSet.addOptional<std::vector<edm::InputTag> >("user");
   iDesc.addOptional("isoDeposits", isoDepositsPSet);
+
+  // isolation values configurables
+  edm::ParameterSetDescription isolationValuesPSet;
+  isolationValuesPSet.addOptional<edm::InputTag>("tracker");
+  isolationValuesPSet.addOptional<edm::InputTag>("ecal");
+  isolationValuesPSet.addOptional<edm::InputTag>("hcal");
+  isolationValuesPSet.addOptional<edm::InputTag>("pfAllParticles");
+  isolationValuesPSet.addOptional<edm::InputTag>("pfChargedHadrons");
+  isolationValuesPSet.addOptional<edm::InputTag>("pfChargedAll");
+  isolationValuesPSet.addOptional<edm::InputTag>("pfPUChargedHadrons");
+  isolationValuesPSet.addOptional<edm::InputTag>("pfNeutralHadrons");
+  isolationValuesPSet.addOptional<edm::InputTag>("pfPhotons");
+  isolationValuesPSet.addOptional<std::vector<edm::InputTag> >("user");
+  iDesc.addOptional("isolationValues", isolationValuesPSet);
 
   // Efficiency configurables
   edm::ParameterSetDescription efficienciesPSet;

PhysicsTools/PatAlgos/plugins/PATPhotonProducer.h

@@ -58,10 +58,25 @@ namespace pat {
       // tools
       GreaterByEt<Photon> eTComparator_;
 
+      typedef std::vector< edm::Handle< edm::ValueMap<IsoDeposit> > > IsoDepositMaps;
+      typedef std::vector< edm::Handle< edm::ValueMap<double> > > IsolationValueMaps;
+      typedef std::pair<pat::IsolationKeys,edm::InputTag> IsolationLabel;
+      typedef std::vector<IsolationLabel> IsolationLabels;
+
       pat::helper::MultiIsolator isolator_;
       pat::helper::MultiIsolator::IsolationValuePairs isolatorTmpStorage_; // better here than recreate at each event
-      std::vector<std::pair<pat::IsolationKeys,edm::InputTag> > isoDepositLabels_;
       std::vector<edm::EDGetTokenT<edm::ValueMap<IsoDeposit> > > isoDepositTokens_;
+      std::vector<edm::EDGetTokenT<edm::ValueMap<double> > > isolationValueTokens_;
+
+      IsolationLabels isoDepositLabels_;
+      IsolationLabels isolationValueLabels_;
+
+      /// fill the labels vector from the contents of the parameter set,
+      /// for the isodeposit or isolation values embedding
+      template<typename T> void readIsolationLabels( const edm::ParameterSet & iConfig,
+                                                     const char* psetName,
+                                                     IsolationLabels& labels,
+                                                     std::vector<edm::EDGetTokenT<edm::ValueMap<T> > >  & tokens);
 
       bool addEfficiencies_;
       pat::helper::EfficiencyLoader efficiencyLoader_;
@@ -79,7 +94,57 @@ namespace pat {
 
   };
 
+}
+
+
+using namespace pat;
+
+template<typename T>
+void PATPhotonProducer::readIsolationLabels( const edm::ParameterSet & iConfig,
+                                               const char* psetName,
+                                               IsolationLabels& labels,
+                                               std::vector<edm::EDGetTokenT<edm::ValueMap<T> > > & tokens) {
+
+  labels.clear();
+
+  if (iConfig.exists( psetName )) {
+    edm::ParameterSet depconf
+      = iConfig.getParameter<edm::ParameterSet>(psetName);
+
+    if (depconf.exists("tracker")) labels.push_back(std::make_pair(pat::TrackIso, depconf.getParameter<edm::InputTag>("tracker")));
+    if (depconf.exists("ecal"))    labels.push_back(std::make_pair(pat::EcalIso, depconf.getParameter<edm::InputTag>("ecal")));
+    if (depconf.exists("hcal"))    labels.push_back(std::make_pair(pat::HcalIso, depconf.getParameter<edm::InputTag>("hcal")));
+    if (depconf.exists("pfAllParticles"))  {
+      labels.push_back(std::make_pair(pat::PfAllParticleIso, depconf.getParameter<edm::InputTag>("pfAllParticles")));
+    }
+    if (depconf.exists("pfChargedHadrons"))  {
+      labels.push_back(std::make_pair(pat::PfChargedHadronIso, depconf.getParameter<edm::InputTag>("pfChargedHadrons")));
+    }
+    if (depconf.exists("pfChargedAll"))  {
+      labels.push_back(std::make_pair(pat::PfChargedAllIso, depconf.getParameter<edm::InputTag>("pfChargedAll")));
+    }
+    if (depconf.exists("pfPUChargedHadrons"))  {
+      labels.push_back(std::make_pair(pat::PfPUChargedHadronIso, depconf.getParameter<edm::InputTag>("pfPUChargedHadrons")));
+    }
+    if (depconf.exists("pfNeutralHadrons"))  {
+      labels.push_back(std::make_pair(pat::PfNeutralHadronIso, depconf.getParameter<edm::InputTag>("pfNeutralHadrons")));
+    }
+    if (depconf.exists("pfPhotons")) {
+      labels.push_back(std::make_pair(pat::PfGammaIso, depconf.getParameter<edm::InputTag>("pfPhotons")));
+    }
+    if (depconf.exists("user")) {
+      std::vector<edm::InputTag> userdeps = depconf.getParameter<std::vector<edm::InputTag> >("user");
+      std::vector<edm::InputTag>::const_iterator it = userdeps.begin(), ed = userdeps.end();
+      int key = UserBaseIso;
+      for ( ; it != ed; ++it, ++key) {
+       labels.push_back(std::make_pair(IsolationKeys(key), *it));
+      }
+    }
+  }
+
+  tokens = edm::vector_transform(labels, [this](IsolationLabel const & label){return consumes<edm::ValueMap<T> >(label.second);});
 
 }
 
+
 #endif

PhysicsTools/PatAlgos/python/producersLayer1/electronProducer_cff.py

@@ -4,8 +4,45 @@
 from TrackingTools.TransientTrack.TransientTrackBuilder_cfi import *
 from PhysicsTools.PatAlgos.producersLayer1.electronProducer_cfi import *
 
+from PhysicsTools.PatAlgos.recoLayer0.pfParticleSelectionForIso_cff import *
+from CommonTools.ParticleFlow.Isolation.pfElectronIsolation_cff import *
+
+sourceElectrons = patElectrons.electronSource
+
+elPFIsoDepositCharged.src = sourceElectrons
+elPFIsoDepositChargedAll.src = sourceElectrons
+elPFIsoDepositNeutral.src = sourceElectrons
+elPFIsoDepositGamma.src = sourceElectrons
+elPFIsoDepositPU.src = sourceElectrons
+
+patElectrons.isoDeposits = cms.PSet(
+    pfChargedHadrons = cms.InputTag("elPFIsoDepositCharged" ),
+    pfChargedAll = cms.InputTag("elPFIsoDepositChargedAll" ),
+    pfPUChargedHadrons = cms.InputTag("elPFIsoDepositPU" ),
+    pfNeutralHadrons = cms.InputTag("elPFIsoDepositNeutral" ),
+    pfPhotons = cms.InputTag("elPFIsoDepositGamma" ),
+    )
+
+patElectrons.isolationValues = cms.PSet(
+    pfChargedHadrons = cms.InputTag("elPFIsoValueCharged04PFId"),
+    pfChargedAll = cms.InputTag("elPFIsoValueChargedAll04PFId"),
+    pfPUChargedHadrons = cms.InputTag("elPFIsoValuePU04PFId" ),
+    pfNeutralHadrons = cms.InputTag("elPFIsoValueNeutral04PFId" ),
+    pfPhotons = cms.InputTag("elPFIsoValueGamma04PFId" ),
+    )
+
+patElectrons.isolationValuesNoPFId = cms.PSet(
+    pfChargedHadrons = cms.InputTag("elPFIsoValueCharged04NoPFId"),
+    pfChargedAll = cms.InputTag("elPFIsoValueChargedAll04NoPFId"),
+    pfPUChargedHadrons = cms.InputTag("elPFIsoValuePU04NoPFId" ),
+    pfNeutralHadrons = cms.InputTag("elPFIsoValueNeutral04NoPFId" ),
+    pfPhotons = cms.InputTag("elPFIsoValueGamma04NoPFId" )
+    )
+
 ## for scheduled mode
 makePatElectrons = cms.Sequence(
+    pfParticleSelectionForIsoSequence *
+    pfElectronIsolationSequence *
     electronMatch *
     patElectrons
     )

PhysicsTools/PatAlgos/python/producersLayer1/muonProducer_cff.py

@@ -4,8 +4,37 @@
 from TrackingTools.TransientTrack.TransientTrackBuilder_cfi import *
 from PhysicsTools.PatAlgos.producersLayer1.muonProducer_cfi import *
 
+from PhysicsTools.PatAlgos.recoLayer0.pfParticleSelectionForIso_cff import *
+from CommonTools.ParticleFlow.Isolation.pfMuonIsolation_cff import *
+
+sourceMuons = patMuons.muonSource
+
+muPFIsoDepositCharged.src = sourceMuons
+muPFIsoDepositChargedAll.src = sourceMuons
+muPFIsoDepositNeutral.src = sourceMuons
+muPFIsoDepositGamma.src = sourceMuons
+muPFIsoDepositPU.src = sourceMuons
+
+patMuons.isoDeposits = cms.PSet(
+    pfChargedHadrons = cms.InputTag("muPFIsoDepositCharged" ),
+    pfChargedAll = cms.InputTag("muPFIsoDepositChargedAll" ),
+    pfPUChargedHadrons = cms.InputTag("muPFIsoDepositPU" ),
+    pfNeutralHadrons = cms.InputTag("muPFIsoDepositNeutral" ),
+    pfPhotons = cms.InputTag("muPFIsoDepositGamma" ),
+    )
+
+patMuons.isolationValues = cms.PSet(
+    pfChargedHadrons = cms.InputTag("muPFIsoValueCharged04"),
+    pfChargedAll = cms.InputTag("muPFIsoValueChargedAll04"),
+    pfPUChargedHadrons = cms.InputTag("muPFIsoValuePU04" ),
+    pfNeutralHadrons = cms.InputTag("muPFIsoValueNeutral04" ),
+    pfPhotons = cms.InputTag("muPFIsoValueGamma04" ),
+    )
+
 ## for scheduled mode
 makePatMuons = cms.Sequence(
+    pfParticleSelectionForIsoSequence *
+    pfMuonIsolationSequence *
     muonMatch *
     patMuons
     )

PhysicsTools/PatAlgos/python/producersLayer1/patCandidates_cff.py

@@ -30,3 +30,4 @@
     makePatMETs      +
     patCandidateSummary
 )
+

PhysicsTools/PatAlgos/python/producersLayer1/photonProducer_cff.py

@@ -3,8 +3,37 @@
 from PhysicsTools.PatAlgos.mcMatchLayer0.photonMatch_cfi import *
 from PhysicsTools.PatAlgos.producersLayer1.photonProducer_cfi import *
 
+from PhysicsTools.PatAlgos.recoLayer0.pfParticleSelectionForIso_cff import *
+from CommonTools.ParticleFlow.Isolation.pfPhotonIsolation_cff import *
+
+sourcePhotons = patPhotons.photonSource
+
+phPFIsoDepositCharged.src = sourcePhotons
+phPFIsoDepositChargedAll.src = sourcePhotons
+phPFIsoDepositNeutral.src = sourcePhotons
+phPFIsoDepositGamma.src = sourcePhotons
+phPFIsoDepositPU.src = sourcePhotons
+
+patPhotons.isoDeposits = cms.PSet(
+    pfChargedHadrons = cms.InputTag("phPFIsoDepositCharged" ),
+    pfChargedAll = cms.InputTag("phPFIsoDepositChargedAll" ),
+    pfPUChargedHadrons = cms.InputTag("phPFIsoDepositPU" ),
+    pfNeutralHadrons = cms.InputTag("phPFIsoDepositNeutral" ),
+    pfPhotons = cms.InputTag("phPFIsoDepositGamma" ),
+    )
+
+patPhotons.isolationValues = cms.PSet(
+    pfChargedHadrons = cms.InputTag("phPFIsoValueCharged04PFId"),
+    pfChargedAll = cms.InputTag("phPFIsoValueChargedAll04PFId"),
+    pfPUChargedHadrons = cms.InputTag("phPFIsoValuePU04PFId" ),
+    pfNeutralHadrons = cms.InputTag("phPFIsoValueNeutral04PFId" ),
+    pfPhotons = cms.InputTag("phPFIsoValueGamma04PFId" ),
+    )
+
 ## for scheduled mode
 makePatPhotons = cms.Sequence(
+    pfParticleSelectionForIsoSequence *
+    pfPhotonIsolationSequence *
     photonMatch *
     patPhotons
     )

PhysicsTools/PatAlgos/python/recoLayer0/pfParticleSelectionForIso_cff.py

@@ -0,0 +1,14 @@
+from RecoParticleFlow.PFProducer.pfLinker_cff import particleFlowPtrs
+from CommonTools.ParticleFlow.pfParticleSelection_cff import *
+pfPileUp.PFCandidates = 'particleFlowPtrs'
+pfNoPileUp.bottomCollection = 'particleFlowPtrs'
+pfPileUpIso.PFCandidates = 'particleFlowPtrs'
+pfNoPileUpIso.bottomCollection='particleFlowPtrs'
+pfPileUpJME.PFCandidates = 'particleFlowPtrs'
+pfNoPileUpJME.bottomCollection='particleFlowPtrs'
+
+pfParticleSelectionForIsoSequence = cms.Sequence(
+    particleFlowPtrs +
+    pfNoPileUpIsoSequence +
+    pfParticleSelectionSequence
+    )