Hcal noise filters backport

CommonTools/RecoAlgos/plugins/BooleanFlagFilter.cc

@@ -0,0 +1,153 @@
+// -*- C++ -*-
+//
+// Package:    CommonTools/RecoAlgos
+// Class:      BooleanFlagFilter
+// 
+/**\class BooleanFlagFilter BooleanFlagFilter.cc CommonTools/RecoAlgos/plugins/BooleanFlagFilter.cc
+
+ Description: [one line class summary]
+
+ Implementation:
+     [Notes on implementation]
+*/
+//
+// Original Author:  Igor Volobouev
+//         Created:  Fri, 20 Mar 2015 08:05:20 GMT
+//
+//
+
+
+// system include files
+#include <memory>
+
+// user include files
+#include "FWCore/Framework/interface/Frameworkfwd.h"
+#include "FWCore/Framework/interface/EDFilter.h"
+
+#include "FWCore/Framework/interface/Event.h"
+#include "FWCore/Framework/interface/MakerMacros.h"
+
+#include "FWCore/ParameterSet/interface/ParameterSet.h"
+
+//
+// class declaration
+//
+
+class BooleanFlagFilter : public edm::EDFilter {
+   public:
+      explicit BooleanFlagFilter(const edm::ParameterSet&);
+      ~BooleanFlagFilter();
+
+   private:
+      virtual void beginJob() override;
+      virtual bool filter(edm::Event&, const edm::EventSetup&) override;
+      virtual void endJob() override;
+
+      //virtual void beginRun(edm::Run const&, edm::EventSetup const&) override;
+      //virtual void endRun(edm::Run const&, edm::EventSetup const&) override;
+      //virtual void beginLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&) override;
+      //virtual void endLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&) override;
+
+      // ----------member data ---------------------------
+      edm::EDGetTokenT<bool> inputToken_;
+      bool reverse_;
+};
+
+//
+// constants, enums and typedefs
+//
+
+//
+// static data member definitions
+//
+
+//
+// constructors and destructor
+//
+BooleanFlagFilter::BooleanFlagFilter(const edm::ParameterSet& iConfig)
+{
+   //now do what ever initialization is needed
+   inputToken_ = consumes<bool>(iConfig.getParameter<edm::InputTag>("inputLabel"));
+   reverse_ = iConfig.getParameter<bool>("reverseDecision");
+}
+
+
+BooleanFlagFilter::~BooleanFlagFilter()
+{
+
+   // do anything here that needs to be done at desctruction time
+   // (e.g. close files, deallocate resources etc.)
+
+}
+
+
+//
+// member functions
+//
+
+// ------------ method called on each new Event  ------------
+bool
+BooleanFlagFilter::filter(edm::Event& iEvent, const edm::EventSetup& iSetup)
+{
+   using namespace edm;
+
+   Handle<bool> pIn;
+   iEvent.getByToken(inputToken_, pIn);
+   if (!pIn.isValid())
+   {
+      throw edm::Exception(edm::errors::ProductNotFound) << " could not find requested flag\n";
+      return true;
+   }
+
+   bool result = *pIn;
+   if (reverse_)
+      result = !result;
+
+   return result;
+}
+
+// ------------ method called once each job just before starting event loop  ------------
+void 
+BooleanFlagFilter::beginJob()
+{
+}
+
+// ------------ method called once each job just after ending the event loop  ------------
+void 
+BooleanFlagFilter::endJob() {
+}
+
+// ------------ method called when starting to processes a run  ------------
+/*
+void
+BooleanFlagFilter::beginRun(edm::Run const&, edm::EventSetup const&)
+{ 
+}
+*/
+
+// ------------ method called when ending the processing of a run  ------------
+/*
+void
+BooleanFlagFilter::endRun(edm::Run const&, edm::EventSetup const&)
+{
+}
+*/
+
+// ------------ method called when starting to processes a luminosity block  ------------
+/*
+void
+BooleanFlagFilter::beginLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&)
+{
+}
+*/
+
+// ------------ method called when ending the processing of a luminosity block  ------------
+/*
+void
+BooleanFlagFilter::endLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&)
+{
+}
+*/
+
+//define this as a plug-in
+DEFINE_FWK_MODULE(BooleanFlagFilter);

CommonTools/RecoAlgos/plugins/HBHENoiseFilterResultProducer.cc

@@ -19,13 +19,15 @@
 
 // system include files
 #include <memory>
+#include <map>
 
 // user include files
 #include "FWCore/Framework/interface/Frameworkfwd.h"
 #include "FWCore/Framework/interface/EDProducer.h"
 
 #include "FWCore/Framework/interface/Event.h"
 #include "FWCore/Framework/interface/MakerMacros.h"
+#include "FWCore/Utilities/interface/Exception.h"
 
 #include "FWCore/ParameterSet/interface/ParameterSet.h"
 
@@ -48,23 +50,14 @@ class HBHENoiseFilterResultProducer : public edm::EDProducer {
 
       // parameters
       edm::EDGetTokenT<HcalNoiseSummary> noisetoken_;
-      double minRatio_, maxRatio_;
-      int minHPDHits_, minRBXHits_, minHPDNoOtherHits_;
+      int minHPDHits_;
+      int minHPDNoOtherHits_;
       int minZeros_;
-      double minHighEHitTime_, maxHighEHitTime_;
-      double maxRBXEMF_;
-      int minNumIsolatedNoiseChannels_;
-      double minIsolatedNoiseSumE_, minIsolatedNoiseSumEt_;
-
-      bool useTS4TS5_;
-      bool useRBXRechitR45Loose_;
-      bool useRBXRechitR45Tight_;
 
       bool IgnoreTS4TS5ifJetInLowBVRegion_;
-      edm::InputTag jetlabel_;
-      edm::EDGetTokenT<reco::PFJetCollection> jettoken_;
-      int maxjetindex_;
-      double maxNHF_;
+      std::string defaultDecision_;
+
+      std::map<std::string, bool> decisionMap_;
 };
 
 
@@ -76,29 +69,16 @@ HBHENoiseFilterResultProducer::HBHENoiseFilterResultProducer(const edm::Paramete
 {
   //now do what ever initialization is needed
   noisetoken_ = consumes<HcalNoiseSummary>(iConfig.getParameter<edm::InputTag>("noiselabel"));
-  minRatio_ = iConfig.getParameter<double>("minRatio");
-  maxRatio_ = iConfig.getParameter<double>("maxRatio");
   minHPDHits_ = iConfig.getParameter<int>("minHPDHits");
-  minRBXHits_ = iConfig.getParameter<int>("minRBXHits");
   minHPDNoOtherHits_ = iConfig.getParameter<int>("minHPDNoOtherHits");
   minZeros_ = iConfig.getParameter<int>("minZeros");
-  minHighEHitTime_ = iConfig.getParameter<double>("minHighEHitTime");
-  maxHighEHitTime_ = iConfig.getParameter<double>("maxHighEHitTime");
-  maxRBXEMF_ = iConfig.getParameter<double>("maxRBXEMF");
-  minNumIsolatedNoiseChannels_ = iConfig.getParameter<int>("minNumIsolatedNoiseChannels");
-  minIsolatedNoiseSumE_ = iConfig.getParameter<double>("minIsolatedNoiseSumE");
-  minIsolatedNoiseSumEt_ = iConfig.getParameter<double>("minIsolatedNoiseSumEt");
-  useTS4TS5_ = iConfig.getParameter<bool>("useTS4TS5");
-  useRBXRechitR45Loose_ = iConfig.getParameter<bool>("useRBXRechitR45Loose");
-  useRBXRechitR45Tight_ = iConfig.getParameter<bool>("useRBXRechitR45Tight");
-
   IgnoreTS4TS5ifJetInLowBVRegion_ = iConfig.getParameter<bool>("IgnoreTS4TS5ifJetInLowBVRegion");
-  jetlabel_ =  iConfig.getParameter<edm::InputTag>("jetlabel");
-  jettoken_ = mayConsume<reco::PFJetCollection>(jetlabel_);
-  maxjetindex_ = iConfig.getParameter<int>("maxjetindex");
-  maxNHF_ = iConfig.getParameter<double>("maxNHF");
+  defaultDecision_ = iConfig.getParameter<std::string>("defaultDecision");
 
   produces<bool>("HBHENoiseFilterResult");
+  produces<bool>("HBHENoiseFilterResultRun1");
+  produces<bool>("HBHENoiseFilterResultRun2Loose");
+  produces<bool>("HBHENoiseFilterResultRun2Tight");
 }
 
 
@@ -125,63 +105,44 @@ HBHENoiseFilterResultProducer::produce(edm::Event& iEvent, const edm::EventSetup
     throw edm::Exception(edm::errors::ProductNotFound) << " could not find HcalNoiseSummary.\n";
     return;
   }
-  const HcalNoiseSummary summary = *summary_h;
-
-  bool result=true; // stores overall filter result
-
-  bool goodJetFoundInLowBVRegion=false; // checks whether a jet is in a low BV region, where false noise flagging rate is higher.
-
-  if ( IgnoreTS4TS5ifJetInLowBVRegion_==true)
-    {
-      edm::Handle<reco::PFJetCollection> pfjet_h;
-      iEvent.getByToken(jettoken_, pfjet_h);
-      if(pfjet_h.isValid())  // valid jet collection found
-	{
-	  int jetindex=0;
-	  for( reco::PFJetCollection::const_iterator jet = pfjet_h->begin(); jet != pfjet_h->end(); ++jet)
-	    {
-	      if (jetindex>maxjetindex_) break; // only look at first N jets (N specified by user via maxjetindex_)
-	      // Check whether jet is in low-BV region (0<eta<1.4, -1.8<phi<-1.4)
-	      if (jet->eta()>0 && jet->eta()<1.4 &&
-		  jet->phi()>-1.8 && jet->phi()<-1.4)
-		{
-		  // Look for a good jet in low BV region; if found, we will keep event
-		  if  (maxNHF_<0 ||  jet->neutralHadronEnergyFraction()<maxNHF_)
-		    {
-		      goodJetFoundInLowBVRegion=true;
-		      break;
-		    }
-		}
-	      ++jetindex;
-	    }
-	} // if (pfjet_h.isValid())
-      else // no valid jet collection found
-	{
-	  // If no jet collection found, do we want to throw a fatal exception?  Or just proceed normally, not treating the lowBV region as special?
-	  //throw edm::Exception(edm::errors::ProductNotFound) << " could not find PFJetCollection with label "<<jetlabel_<<".\n";
-	}
-    } // if (IgnoreTS4TS5ifJetInLowBVRegion_==true)
-
-  if(summary.minE2Over10TS()<minRatio_) result=false;
-  if(summary.maxE2Over10TS()>maxRatio_) result=false;
-  if(summary.maxHPDHits()>=minHPDHits_) result=false;
-  if(summary.maxRBXHits()>=minRBXHits_) result=false;
-  if(summary.maxHPDNoOtherHits()>=minHPDNoOtherHits_) result=false;
-  if(summary.maxZeros()>=minZeros_) result=false;
-  if(summary.min25GeVHitTime()<minHighEHitTime_) result=false;
-  if(summary.max25GeVHitTime()>maxHighEHitTime_) result=false;
-  if(summary.minRBXEMF()<maxRBXEMF_) result=false;
-  if(summary.numIsolatedNoiseChannels()>=minNumIsolatedNoiseChannels_) result=false;
-  if(summary.isolatedNoiseSumE()>=minIsolatedNoiseSumE_) result=false;
-  if(summary.isolatedNoiseSumEt()>=minIsolatedNoiseSumEt_) result=false;
-  if(useTS4TS5_ && summary.HasBadRBXTS4TS5() == true && !goodJetFoundInLowBVRegion) result = false;
-  if(useRBXRechitR45Loose_ && summary.HasBadRBXRechitR45Loose() == true && !goodJetFoundInLowBVRegion) result = false;
-  if(useRBXRechitR45Tight_ && summary.HasBadRBXRechitR45Tight() == true && !goodJetFoundInLowBVRegion) result = false;
-
-  std::auto_ptr<bool> pOut(new bool);
-  *pOut=result;
+  const HcalNoiseSummary& summary(*summary_h);
+
+  bool goodJetFoundInLowBVRegion = false;
+  if (IgnoreTS4TS5ifJetInLowBVRegion_)
+      goodJetFoundInLowBVRegion = summary.goodJetFoundInLowBVRegion();
+
+  const bool failCommon = summary.maxHPDHits() >= minHPDHits_ ||
+                          summary.maxHPDNoOtherHits() >= minHPDNoOtherHits_ ||
+                          summary.maxZeros() >= minZeros_;
+
+  const bool failRun1 = failCommon || (summary.HasBadRBXTS4TS5() &&
+                                       !goodJetFoundInLowBVRegion);
+  decisionMap_["HBHENoiseFilterResultRun1"] = failRun1;
+
+  const bool failRun2Loose = failCommon || (summary.HasBadRBXRechitR45Loose() &&
+                                            !goodJetFoundInLowBVRegion);
+  decisionMap_["HBHENoiseFilterResultRun2Loose"] = failRun2Loose;
+
+  const bool failRun2Tight = failCommon || (summary.HasBadRBXRechitR45Tight() &&
+                                            !goodJetFoundInLowBVRegion);
+  decisionMap_["HBHENoiseFilterResultRun2Tight"] = failRun2Tight;
+
+  // Write out the standard flags
+  std::auto_ptr<bool> pOut;
+  for (std::map<std::string, bool>::const_iterator it = decisionMap_.begin();
+       it != decisionMap_.end(); ++it)
+  {
+      pOut = std::auto_ptr<bool>(new bool(!it->second));
+      iEvent.put(pOut, it->first);
+  }
 
+  // Write out the default flag
+  std::map<std::string, bool>::const_iterator it = decisionMap_.find(defaultDecision_);
+  if (it == decisionMap_.end())
+      throw cms::Exception("Invalid HBHENoiseFilterResultProducer parameter \"defaultDecision\"");
+  pOut = std::auto_ptr<bool>(new bool(!it->second));
   iEvent.put(pOut, "HBHENoiseFilterResult");
+
   return;
 }
 

CommonTools/RecoAlgos/python/HBHENoiseFilterResultProducer_cfi.py

@@ -3,23 +3,13 @@
 HBHENoiseFilterResultProducer = cms.EDProducer(
     'HBHENoiseFilterResultProducer',
     noiselabel = cms.InputTag('hcalnoise'),
-    minRatio = cms.double(-999),
-    maxRatio = cms.double(999),
     minHPDHits = cms.int32(17),
-    minRBXHits = cms.int32(999),
     minHPDNoOtherHits = cms.int32(10),
     minZeros = cms.int32(10),
-    minHighEHitTime = cms.double(-9999.0),
-    maxHighEHitTime = cms.double(9999.0),
-    maxRBXEMF = cms.double(-999.0),
-    minNumIsolatedNoiseChannels = cms.int32(10),
-    minIsolatedNoiseSumE = cms.double(50.0),
-    minIsolatedNoiseSumEt = cms.double(25.0),
-    useTS4TS5 = cms.bool(False),
-    useRBXRechitR45Loose = cms.bool(False),
-    useRBXRechitR45Tight = cms.bool(False),
-    IgnoreTS4TS5ifJetInLowBVRegion=cms.bool(True),
-    jetlabel = cms.InputTag('ak4PFJets'),
-    maxjetindex = cms.int32(0), # maximum jet index that will be checked for 'IgnoreTS4TS5ifJetInLowBVRegion'
-    maxNHF = cms.double(0.9) # maximum allowed jet->neutralHadronEnergyFraction() for a jet in low BV region to be considered 'good' (and thus skip the noise check)
-    )
+    IgnoreTS4TS5ifJetInLowBVRegion = cms.bool(True),
+    defaultDecision = cms.string("HBHENoiseFilterResultRun1")
+)
+
+from Configuration.StandardSequences.Eras import eras
+eras.run2_common.toModify(HBHENoiseFilterResultProducer, IgnoreTS4TS5ifJetInLowBVRegion=False)
+eras.run2_25ns_specific.toModify(HBHENoiseFilterResultProducer, defaultDecision="HBHENoiseFilterResultRun2Loose")

DataFormats/METReco/interface/HcalNoiseSummary.h

@@ -138,6 +138,7 @@ class HcalNoiseSummary
   bool HasBadRBXTS4TS5(void) const;
   bool HasBadRBXRechitR45Loose(void) const;
   bool HasBadRBXRechitR45Tight(void) const;
+  bool goodJetFoundInLowBVRegion(void) const;
 
   double GetCalibChargeHF(void) const;
   int    GetCalibCountHF(void)  const;
@@ -197,6 +198,7 @@ class HcalNoiseSummary
   bool hasBadRBXTS4TS5_;
   bool hasBadRBXRechitR45Loose_;
   bool hasBadRBXRechitR45Tight_;
+  bool goodJetFoundInLowBVRegion_;
 
   int calibCountTS45_;
   int calibCountgt15TS45_;
@@ -216,7 +218,6 @@ class HcalNoiseSummary
   edm::RefVector<CaloTowerCollection> loosenoisetwrs_;
   edm::RefVector<CaloTowerCollection> tightnoisetwrs_;
   edm::RefVector<CaloTowerCollection> hlnoisetwrs_;
-
 };
 
 #endif