#include <HLTHcalTowerNoiseCleanerWithrechit.h>

Inheritance diagram for HLTHcalTowerNoiseCleanerWithrechit:

Classes
struct	noisedatacomp

Public Member Functions
	HLTHcalTowerNoiseCleanerWithrechit (const edm::ParameterSet &)

virtual void	produce (edm::Event &, const edm::EventSetup &)

	~HLTHcalTowerNoiseCleanerWithrechit ()

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

Public Member Functions inherited from edm::stream::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

virtual	~EDProducerBase ()

Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

virtual	~ProducerBase ()

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

	EDConsumerBase ()

ProductHolderIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (std::string const &iProcessName, std::string const &iModuleLabel, bool iPrint, std::vector< char const * > &oModuleLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Static Public Member Functions inherited from edm::stream::EDProducerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Private Types
typedef std::set < CommonHcalNoiseRBXData, noisedatacomp >	noisedataset_t

Private Attributes
edm::InputTag	HcalNoiseRBXCollectionTag_

std::vector< double >	hltMinRBXRechitR45Cuts_

edm::EDGetTokenT < CaloTowerCollection >	m_theCaloTowerCollectionToken

edm::EDGetTokenT < reco::HcalNoiseRBXCollection >	m_theHcalNoiseToken

double	maxHighEHitTime_

int	maxNumRBXs_

double	maxRatio_

double	maxRBXEMF_

double	minHighEHitTime_

double	minHighHitE_

int	minHPDHits_

int	minHPDNoOtherHits_

double	minLowHitE_

double	minR45HitE_

double	minRatio_

double	minRBXEnergy_

int	minRBXHits_

double	minRecHitE_

int	minZeros_

bool	needEMFCoincidence_

int	numRBXsToConsider_

int	severity_

edm::InputTag	TowerCollectionTag_

double	TS4TS5EnergyThreshold_

std::vector< std::pair< double, double > >	TS4TS5LowerCut_

std::vector< std::pair< double, double > >	TS4TS5UpperCut_

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
typedef CacheContexts< T...>	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T...>	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT < LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Public Types inherited from edm::stream::EDProducerBase
typedef EDProducerAdaptorBase	ModuleType

Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

Description: HLT filter module for cleaning HCal Noise from MET or MHT

Implementation: <Notes on="" implementation>="">

Definition at line 23 of file HLTHcalTowerNoiseCleanerWithrechit.h.

Member Typedef Documentation

typedef std::set<CommonHcalNoiseRBXData, noisedatacomp> HLTHcalTowerNoiseCleanerWithrechit::noisedataset_t

private

Definition at line 68 of file HLTHcalTowerNoiseCleanerWithrechit.h.

Constructor & Destructor Documentation

HLTHcalTowerNoiseCleanerWithrechit::HLTHcalTowerNoiseCleanerWithrechit ( const edm::ParameterSet & iConfig )

explicit

Definition at line 53 of file HLTHcalTowerNoiseCleanerWithrechit.cc.

References edm::ParameterSet::existsAs(), edm::ParameterSet::getParameter(), HcalNoiseRBXCollectionTag_, hltMinRBXRechitR45Cuts_, i, m_theCaloTowerCollectionToken, m_theHcalNoiseToken, minR45HitE_, TowerCollectionTag_, TS4TS5LowerCut_, and TS4TS5UpperCut_.

   : HcalNoiseRBXCollectionTag_(iConfig.getParameter<edm::InputTag>("HcalNoiseRBXCollection")),
     TowerCollectionTag_(iConfig.getParameter<edm::InputTag>("CaloTowerCollection")),
     severity_(iConfig.getParameter<int> ("severity")),
     maxNumRBXs_(iConfig.getParameter<int>("maxNumRBXs")),
     numRBXsToConsider_(iConfig.getParameter<int>("numRBXsToConsider")),
     needEMFCoincidence_(iConfig.getParameter<bool>("needEMFCoincidence")),
     minRBXEnergy_(iConfig.getParameter<double>("minRBXEnergy")),
     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")),
     minRecHitE_(iConfig.getParameter<double>("minRecHitE")),
     minLowHitE_(iConfig.getParameter<double>("minLowHitE")),
     minHighHitE_(iConfig.getParameter<double>("minHighHitE")),
     minR45HitE_(5.0),
     TS4TS5EnergyThreshold_(iConfig.getParameter<double>("TS4TS5EnergyThreshold"))
 {
 
   hltMinRBXRechitR45Cuts_ = iConfig.getParameter<std::vector<double> >("hltRBXRecHitR45Cuts");
   std::vector<double> TS4TS5UpperThresholdTemp = iConfig.getParameter<std::vector<double> >("TS4TS5UpperThreshold");
   std::vector<double> TS4TS5UpperCutTemp = iConfig.getParameter<std::vector<double> >("TS4TS5UpperCut");
   std::vector<double> TS4TS5LowerThresholdTemp = iConfig.getParameter<std::vector<double> >("TS4TS5LowerThreshold");
   std::vector<double> TS4TS5LowerCutTemp = iConfig.getParameter<std::vector<double> >("TS4TS5LowerCut");
 
   for(int i = 0; i < (int)TS4TS5UpperThresholdTemp.size() && i < (int)TS4TS5UpperCutTemp.size(); i++)
      TS4TS5UpperCut_.push_back(std::pair<double, double>(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<double, double>(TS4TS5LowerThresholdTemp[i], TS4TS5LowerCutTemp[i]));
   sort(TS4TS5LowerCut_.begin(), TS4TS5LowerCut_.end());
 
   m_theHcalNoiseToken = consumes<reco::HcalNoiseRBXCollection>(HcalNoiseRBXCollectionTag_);
   m_theCaloTowerCollectionToken = consumes<CaloTowerCollection>(TowerCollectionTag_);
 
   if(iConfig.existsAs<double>("minR45HitE"))
      minR45HitE_ = iConfig.getParameter<double>("minR45HitE");
 
   produces<CaloTowerCollection>();
 }

HLTHcalTowerNoiseCleanerWithrechit::~HLTHcalTowerNoiseCleanerWithrechit ( )

Definition at line 101 of file HLTHcalTowerNoiseCleanerWithrechit.cc.

101 {}

Member Function Documentation

void HLTHcalTowerNoiseCleanerWithrechit::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 104 of file HLTHcalTowerNoiseCleanerWithrechit.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), HLT_25ns10e33_v2_cff::hltRBXRecHitR45Cuts, HLT_25ns10e33_v2_cff::InputTag, HLT_25ns10e33_v2_cff::TS4TS5LowerCut, HLT_25ns10e33_v2_cff::TS4TS5LowerThreshold, HLT_25ns10e33_v2_cff::TS4TS5UpperCut, and HLT_25ns10e33_v2_cff::TS4TS5UpperThreshold.

                                                                                                {
   edm::ParameterSetDescription desc;
   desc.add<edm::InputTag>("HcalNoiseRBXCollection",edm::InputTag("hltHcalNoiseInfoProducer"));
   desc.add<edm::InputTag>("CaloTowerCollection",edm::InputTag("hltTowerMakerForAll"));
   desc.add<double>("maxTowerNoiseEnergyFraction",0.5);
   desc.add<int>("severity",1);
   desc.add<int>("maxNumRBXs",2);
   desc.add<int>("numRBXsToConsider",2);
   desc.add<bool>("needEMFCoincidence",true);
   desc.add<double>("minRBXEnergy",50.0);
   desc.add<double>("minRatio",-999.);
   desc.add<double>("maxRatio",999.);
   desc.add<int>("minHPDHits",17);
   desc.add<int>("minRBXHits",999);
   desc.add<int>("minHPDNoOtherHits",10);
   desc.add<int>("minZeros",10);
   desc.add<double>("minHighEHitTime",-9999.0);
   desc.add<double>("maxHighEHitTime",9999.0);
   desc.add<double>("maxRBXEMF",0.02);
   desc.add<double>("minRecHitE",1.5);
   desc.add<double>("minLowHitE",10.0);
   desc.add<double>("minHighHitE",25.0);
   desc.add<double>("minR45HitE",5.0);
   desc.add<double>("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<double> TS4TS5UpperThreshold(TS4TS5UpperThresholdArray, TS4TS5UpperThresholdArray+5);
   std::vector<double> TS4TS5UpperCut(TS4TS5UpperCutArray, TS4TS5UpperCutArray+5);
   std::vector<double> TS4TS5LowerThreshold(TS4TS5LowerThresholdArray, TS4TS5LowerThresholdArray+7);
   std::vector<double> TS4TS5LowerCut(TS4TS5LowerCutArray, TS4TS5LowerCutArray+7);
   std::vector<double> hltRBXRecHitR45Cuts(hltRBXRecHitR45CutsArray, hltRBXRecHitR45CutsArray+8);
 
   desc.add<std::vector<double> >("TS4TS5UpperThreshold", TS4TS5UpperThreshold);
   desc.add<std::vector<double> >("TS4TS5UpperCut", TS4TS5UpperCut);
   desc.add<std::vector<double> >("TS4TS5LowerThreshold", TS4TS5LowerThreshold);
   desc.add<std::vector<double> >("TS4TS5LowerCut", TS4TS5LowerCut);
   desc.add<std::vector<double> >("hltRBXRecHitR45Cuts", hltRBXRecHitR45Cuts);
   descriptions.add("hltHcalTowerNoiseCleanerWithrechit",desc);
 }

void HLTHcalTowerNoiseCleanerWithrechit::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

virtual

Implements edm::stream::EDProducerBase.

Definition at line 152 of file HLTHcalTowerNoiseCleanerWithrechit.cc.

References edm::RefVector< C, T, F >::begin(), ztail::d, AlCaHLTBitMon_QueryRunRegistry::data, edm::RefVector< C, T, F >::end(), edm::EventSetup::get(), edm::Event::getByToken(), HcalNoiseRBXCollectionTag_, hltMinRBXRechitR45Cuts_, i, CaloTower::id(), edm::Ref< C, T, F >::id(), LogDebug, m_theCaloTowerCollectionToken, m_theHcalNoiseToken, maxHighEHitTime_, maxRatio_, maxRBXEMF_, minHighEHitTime_, minHighHitE_, minHPDHits_, minHPDNoOtherHits_, minLowHitE_, minR45HitE_, minRatio_, minRBXEnergy_, minRBXHits_, minRecHitE_, minZeros_, needEMFCoincidence_, edm::Event::put(), dt_dqm_sourceclient_common_cff::reco, severity_, TS4TS5EnergyThreshold_, TS4TS5LowerCut_, and TS4TS5UpperCut_.

 {
   using namespace reco;
 
 
    edm::ESHandle<CaloTowerTopology> caloTowerTopology;
   iSetup.get<HcalRecNumberingRecord>().get(caloTowerTopology);
 
 
   //get the calo MET / MHT
   edm::Handle<CaloTowerCollection> tower_h;
   iEvent.getByToken(m_theCaloTowerCollectionToken,tower_h);
   
   std::set<unsigned int> 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<HcalNoiseRBXCollection> 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()<minRatio_)        passFilter=false;
     else if(it->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()<minHighEHitTime_)      passFilter=false;
     else if(it->maxHighEHitTime()>maxHighEHitTime_)      passFilter=false;
     else if (passRechitr45==false)                       passFilter=false;
     if(it->RBXEMF()<maxRBXEMF_){
       passEMF=false;
     }
       }
       
       if((needEMFCoincidence_ && !passEMF && !passFilter) ||
      (!needEMFCoincidence_ && !passFilter)) { // check for noise
     LogDebug("") << "HLTHcalTowerNoiseCleanerWithrechit debug: Found a noisy RBX: "
              << "energy=" << it->energy() << "; "
              << "ratio=" << it->ratio() << "; "
              << "# RBX hits=" << it->numRBXHits() << "; "
              << "# HPD hits=" << it->numHPDHits() << "; "
              << "# Zeros=" << it->numZeros() << "; "
              << "min time=" << it->minHighEHitTime() << "; "
              << "max time=" << it->maxHighEHitTime() << "; "
              << "RBX EMF=" << it->RBXEMF()
              << std::endl;
     // add calotowers associated with this RBX to the noise list
     edm::RefVector<CaloTowerCollection> noiseTowers = it->rbxTowers();
     edm::RefVector<CaloTowerCollection>::const_iterator noiseTowersIt;
     //add these calotowers to the noisy list
     for( noiseTowersIt = noiseTowers.begin(); noiseTowersIt != noiseTowers.end(); noiseTowersIt++){
       edm::Ref<edm::SortedCollection<CaloTower> > tower_ref = *noiseTowersIt;
       CaloTowerDetId id = tower_ref->id();
           noisyTowers.insert( caloTowerTopology->denseIndex(id) );
     }}
     } // done with noise loop
   }//if(severity_>0)
   
   //output collection
   std::auto_ptr<CaloTowerCollection> OutputTowers(new CaloTowerCollection() );
 
   CaloTowerCollection::const_iterator inTowersIt;
   
   for(inTowersIt = tower_h->begin(); inTowersIt != tower_h->end(); inTowersIt++){
     const CaloTower & tower = (*inTowersIt);
     CaloTowerDetId id = tower.id();
 
     if(noisyTowers.find( caloTowerTopology->denseIndex(id) ) == noisyTowers.end()){ // the tower is not noisy
       OutputTowers->push_back(*inTowersIt);
     }
   }
   iEvent.put(OutputTowers);
 
 }