From 9ee095fd3165abcf0d4ce44a6978b086cbd0c533 Mon Sep 17 00:00:00 2001 From: safarzad Date: Tue, 10 Nov 2015 08:49:03 +0100 Subject: [PATCH 1/2] New HCalTower cleaner including rechits --- .../HLTHcalTowerNoiseCleanerWithrechit.h | 71 +++++ .../src/HLTHcalTowerNoiseCleanerWithrechit.cc | 266 ++++++++++++++++++ 2 files changed, 337 insertions(+) create mode 100644 HLTrigger/JetMET/interface/HLTHcalTowerNoiseCleanerWithrechit.h create mode 100644 HLTrigger/JetMET/src/HLTHcalTowerNoiseCleanerWithrechit.cc diff --git a/HLTrigger/JetMET/interface/HLTHcalTowerNoiseCleanerWithrechit.h b/HLTrigger/JetMET/interface/HLTHcalTowerNoiseCleanerWithrechit.h new file mode 100644 index 0000000000000..32d755b60156b --- /dev/null +++ b/HLTrigger/JetMET/interface/HLTHcalTowerNoiseCleanerWithrechit.h @@ -0,0 +1,71 @@ +#ifndef HLTHcalTowerNoiseCleanerWithrechit_h +#define HLTHcalTowerNoiseCleanerWithrechit_h + +/** \class HLTHcalNoiseCleaner + * + * \author Alexander Mott (Caltech), Leonard Apanasevich (UIC), John Paul Chou (Brown) + * + */ +#include "FWCore/Framework/interface/stream/EDProducer.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/EventSetup.h" +#include "RecoMET/METAlgorithms/interface/HcalNoiseAlgo.h" + +#include "DataFormats/CaloTowers/interface/CaloTower.h" +#include "DataFormats/CaloTowers/interface/CaloTowerCollection.h" +#include "DataFormats/METReco/interface/HcalNoiseRBX.h" + +namespace edm { + class ConfigurationDescriptions; +} + +class HLTHcalTowerNoiseCleanerWithrechit : public edm::stream::EDProducer<> { + + public: + explicit HLTHcalTowerNoiseCleanerWithrechit(const edm::ParameterSet&); + ~HLTHcalTowerNoiseCleanerWithrechit(); + static void fillDescriptions(edm::ConfigurationDescriptions & descriptions); + virtual void produce(edm::Event&, const edm::EventSetup&); + + private: + edm::EDGetTokenT m_theHcalNoiseToken; + edm::EDGetTokenT m_theCaloTowerCollectionToken; + // parameters + edm::InputTag HcalNoiseRBXCollectionTag_; + edm::InputTag TowerCollectionTag_; + int severity_; + int maxNumRBXs_; + int numRBXsToConsider_; + bool needEMFCoincidence_; + double minRBXEnergy_; + double minRatio_; + double maxRatio_; + int minHPDHits_; + int minRBXHits_; + int minHPDNoOtherHits_; + int minZeros_; + double minHighEHitTime_; + double maxHighEHitTime_; + double maxRBXEMF_; + + // imported from the RecoMET/METProducers/python/hcalnoiseinfoproducer_cfi + double minRecHitE_, minLowHitE_, minHighHitE_, minR45HitE_; + + double TS4TS5EnergyThreshold_; + std::vector > TS4TS5UpperCut_; + std::vector > TS4TS5LowerCut_; + + // Rechit-r45 filter parameters: + std::vector hltMinRBXRechitR45Cuts_; + + // helper function to compare noise data energies + struct noisedatacomp { + inline bool operator() ( const CommonHcalNoiseRBXData& t1, const CommonHcalNoiseRBXData& t2) { + return t1.energy()>t2.energy(); + } + }; + typedef std::set noisedataset_t; +}; + +#endif //HLTHcalTowerNoiseCleanerWithrechit_h diff --git a/HLTrigger/JetMET/src/HLTHcalTowerNoiseCleanerWithrechit.cc b/HLTrigger/JetMET/src/HLTHcalTowerNoiseCleanerWithrechit.cc new file mode 100644 index 0000000000000..1defa7e579db8 --- /dev/null +++ b/HLTrigger/JetMET/src/HLTHcalTowerNoiseCleanerWithrechit.cc @@ -0,0 +1,266 @@ +// -*- C++ -*- +// +// Class: HLTHcalTowerNoiseCleanerWithrechit +// +/**\class HLTHcalTowerNoiseCleanerWithrechit + + Description: HLT filter module for cleaning HCal Noise from MET or MHT + + Implementation: + +*/ +// +// Original Author: Alexander Mott +// Created: Mon Nov 21 11:32:00 CEST 2011 +// +// +// + + +#include "DataFormats/Common/interface/Handle.h" +#include "FWCore/MessageLogger/interface/MessageLogger.h" +#include "FWCore/Framework/interface/ESHandle.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/EventSetup.h" + +#include "FWCore/ParameterSet/interface/ParameterSet.h" + +#include "DataFormats/Candidate/interface/Candidate.h" +#include "DataFormats/JetReco/interface/Jet.h" +#include "DataFormats/JetReco/interface/CaloJet.h" +#include "DataFormats/CaloTowers/interface/CaloTowerDetId.h" +#include "DataFormats/CaloTowers/interface/CaloTowerCollection.h" +#include "Geometry/CaloTopology/interface/CaloTowerTopology.h" +#include "Geometry/Records/interface/HcalRecNumberingRecord.h" +#include "DataFormats/Math/interface/LorentzVector.h" +#include "DataFormats/Math/interface/Point3D.h" + +#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" +#include "FWCore/Utilities/interface/InputTag.h" + +#include +#include +#include +#include +#include +#include + +#include "HLTrigger/JetMET/interface/HLTHcalTowerNoiseCleanerWithrechit.h" + +//#include + +HLTHcalTowerNoiseCleanerWithrechit::HLTHcalTowerNoiseCleanerWithrechit(const edm::ParameterSet& iConfig) + : HcalNoiseRBXCollectionTag_(iConfig.getParameter("HcalNoiseRBXCollection")), + TowerCollectionTag_(iConfig.getParameter("CaloTowerCollection")), + severity_(iConfig.getParameter ("severity")), + maxNumRBXs_(iConfig.getParameter("maxNumRBXs")), + numRBXsToConsider_(iConfig.getParameter("numRBXsToConsider")), + needEMFCoincidence_(iConfig.getParameter("needEMFCoincidence")), + minRBXEnergy_(iConfig.getParameter("minRBXEnergy")), + minRatio_(iConfig.getParameter("minRatio")), + maxRatio_(iConfig.getParameter("maxRatio")), + minHPDHits_(iConfig.getParameter("minHPDHits")), + minRBXHits_(iConfig.getParameter("minRBXHits")), + minHPDNoOtherHits_(iConfig.getParameter("minHPDNoOtherHits")), + minZeros_(iConfig.getParameter("minZeros")), + minHighEHitTime_(iConfig.getParameter("minHighEHitTime")), + maxHighEHitTime_(iConfig.getParameter("maxHighEHitTime")), + maxRBXEMF_(iConfig.getParameter("maxRBXEMF")), + minRecHitE_(iConfig.getParameter("minRecHitE")), + minLowHitE_(iConfig.getParameter("minLowHitE")), + minHighHitE_(iConfig.getParameter("minHighHitE")), + minR45HitE_(5.0), + TS4TS5EnergyThreshold_(iConfig.getParameter("TS4TS5EnergyThreshold")) +{ + + hltMinRBXRechitR45Cuts_ = iConfig.getParameter >("hltRBXRecHitR45Cuts"); + std::vector TS4TS5UpperThresholdTemp = iConfig.getParameter >("TS4TS5UpperThreshold"); + std::vector TS4TS5UpperCutTemp = iConfig.getParameter >("TS4TS5UpperCut"); + std::vector TS4TS5LowerThresholdTemp = iConfig.getParameter >("TS4TS5LowerThreshold"); + std::vector TS4TS5LowerCutTemp = iConfig.getParameter >("TS4TS5LowerCut"); + + for(int i = 0; i < (int)TS4TS5UpperThresholdTemp.size() && i < (int)TS4TS5UpperCutTemp.size(); i++) + TS4TS5UpperCut_.push_back(std::pair(TS4TS5UpperThresholdTemp[i], TS4TS5UpperCutTemp[i])); + sort(TS4TS5UpperCut_.begin(), TS4TS5UpperCut_.end()); + + for(int i = 0; i < (int)TS4TS5LowerThresholdTemp.size() && i < (int)TS4TS5LowerCutTemp.size(); i++) + TS4TS5LowerCut_.push_back(std::pair(TS4TS5LowerThresholdTemp[i], TS4TS5LowerCutTemp[i])); + sort(TS4TS5LowerCut_.begin(), TS4TS5LowerCut_.end()); + + m_theHcalNoiseToken = consumes(HcalNoiseRBXCollectionTag_); + m_theCaloTowerCollectionToken = consumes(TowerCollectionTag_); + + if(iConfig.existsAs("minR45HitE")) + minR45HitE_ = iConfig.getParameter("minR45HitE"); + + produces(); +} + + +HLTHcalTowerNoiseCleanerWithrechit::~HLTHcalTowerNoiseCleanerWithrechit(){} + +void +HLTHcalTowerNoiseCleanerWithrechit::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + desc.add("HcalNoiseRBXCollection",edm::InputTag("hltHcalNoiseInfoProducer")); + desc.add("CaloTowerCollection",edm::InputTag("hltTowerMakerForAll")); + desc.add("maxTowerNoiseEnergyFraction",0.5); + desc.add("severity",1); + desc.add("maxNumRBXs",2); + desc.add("numRBXsToConsider",2); + desc.add("needEMFCoincidence",true); + desc.add("minRBXEnergy",50.0); + desc.add("minRatio",-999.); + desc.add("maxRatio",999.); + desc.add("minHPDHits",17); + desc.add("minRBXHits",999); + desc.add("minHPDNoOtherHits",10); + desc.add("minZeros",10); + desc.add("minHighEHitTime",-9999.0); + desc.add("maxHighEHitTime",9999.0); + desc.add("maxRBXEMF",0.02); + desc.add("minRecHitE",1.5); + desc.add("minLowHitE",10.0); + desc.add("minHighHitE",25.0); + desc.add("minR45HitE",5.0); + desc.add("TS4TS5EnergyThreshold",50.0); + + double TS4TS5UpperThresholdArray[5] = {70, 90, 100, 400, 4000 }; + double TS4TS5UpperCutArray[5] = {1, 0.8, 0.75, 0.72, 0.72}; + double TS4TS5LowerThresholdArray[7] = {100, 120, 150, 200, 300, 400, 500}; + double TS4TS5LowerCutArray[7] = {-1, -0.7, -0.4, -0.2, -0.08, 0, 0.1}; + double hltRBXRecHitR45CutsArray[8] = { 0.0, 1.0, 0.0, -1.0, 0.0, 0.0, 1.0, -1.0 }; + std::vector TS4TS5UpperThreshold(TS4TS5UpperThresholdArray, TS4TS5UpperThresholdArray+5); + std::vector TS4TS5UpperCut(TS4TS5UpperCutArray, TS4TS5UpperCutArray+5); + std::vector TS4TS5LowerThreshold(TS4TS5LowerThresholdArray, TS4TS5LowerThresholdArray+7); + std::vector TS4TS5LowerCut(TS4TS5LowerCutArray, TS4TS5LowerCutArray+7); + std::vector hltRBXRecHitR45Cuts(hltRBXRecHitR45CutsArray, hltRBXRecHitR45CutsArray+8); + + desc.add >("TS4TS5UpperThreshold", TS4TS5UpperThreshold); + desc.add >("TS4TS5UpperCut", TS4TS5UpperCut); + desc.add >("TS4TS5LowerThreshold", TS4TS5LowerThreshold); + desc.add >("TS4TS5LowerCut", TS4TS5LowerCut); + desc.add >("hltRBXRecHitR45Cuts", hltRBXRecHitR45Cuts); + descriptions.add("hltHcalTowerNoiseCleanerWithrechit",desc); +} + +// +// member functions +// + +void HLTHcalTowerNoiseCleanerWithrechit::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) +{ + using namespace reco; + + + edm::ESHandle caloTowerTopology; + iSetup.get().get(caloTowerTopology); + + + //get the calo MET / MHT + edm::Handle tower_h; + iEvent.getByToken(m_theCaloTowerCollectionToken,tower_h); + + std::set noisyTowers; + + if(not tower_h.isValid()){ //No towers MET, don't do anything and accept the event + edm::LogError("HLTHcalTowerNoiseCleanerWithrechit") << "Input Tower Collection is not Valid"; + return; + } + + + // get the RBXs produced by RecoMET/METProducers/HcalNoiseInfoProducer + edm::Handle rbxs_h; + iEvent.getByToken(m_theHcalNoiseToken,rbxs_h); + if(!rbxs_h.isValid()) { + edm::LogWarning("HLTHcalTowerNoiseCleanerWithrechit") << "Could not find HcalNoiseRBXCollection product named " + << HcalNoiseRBXCollectionTag_ << "." << std::endl; + severity_=0; + } + + // create a sorted set of the RBXs, ordered by energy + noisedataset_t data; + for(HcalNoiseRBXCollection::const_iterator it=rbxs_h->begin(); it!=rbxs_h->end(); ++it) { + const HcalNoiseRBX &rbx=(*it); + CommonHcalNoiseRBXData d(rbx, minRecHitE_, minLowHitE_, minHighHitE_, TS4TS5EnergyThreshold_, + TS4TS5UpperCut_, TS4TS5LowerCut_, minR45HitE_); + data.insert(d); + } + + // data is now sorted by RBX energy + // only consider top N=numRBXsToConsider_ energy RBXs + if(severity_>0){ + for(noisedataset_t::const_iterator it=data.begin(); + it!=data.end(); + it++) { + // Check the Rechit-R45 filter + // Taken from http://cmslxr.fnal.gov/lxr/source/RecoMET/METAlgorithms/src/HcalNoiseAlgo.cc?v=CMSSW_7_4_6#0256 + bool passRechitr45 = true; + int r45Count = it->r45Count(); + double r45Fraction = it->r45Fraction(); + double r45EnergyFraction = it->r45EnergyFraction(); + for(int i = 0; i + 3 < (int)hltMinRBXRechitR45Cuts_.size(); i = i + 4) { + double Value = r45Count * hltMinRBXRechitR45Cuts_[i] + r45Fraction * hltMinRBXRechitR45Cuts_[i+1] + r45EnergyFraction * hltMinRBXRechitR45Cuts_[i+2] + hltMinRBXRechitR45Cuts_[i+3]; + if (Value > 0) passRechitr45=false; + } + + bool passFilter=true; + bool passEMF=true; + if(it->energy()>minRBXEnergy_) { + if(it->validRatio() && it->ratio()validRatio() && it->ratio()>maxRatio_) passFilter=false; + else if(it->numHPDHits()>=minHPDHits_) passFilter=false; + else if(it->numRBXHits()>=minRBXHits_) passFilter=false; + else if(it->numHPDNoOtherHits()>=minHPDNoOtherHits_) passFilter=false; + else if(it->numZeros()>=minZeros_) passFilter=false; + else if(it->minHighEHitTime()maxHighEHitTime()>maxHighEHitTime_) passFilter=false; + else if (passRechitr45==false) passFilter=false; + if(it->RBXEMF()