#include <HLTHcalMETNoiseCleaner.h>

Inheritance diagram for HLTHcalMETNoiseCleaner:

Classes
struct	noisedatacomp

Public Member Functions
bool	filter (edm::StreamID, edm::Event &, const edm::EventSetup &) const override

	HLTHcalMETNoiseCleaner (const edm::ParameterSet &)

	~HLTHcalMETNoiseCleaner () override

Public Member Functions inherited from edm::global::EDFilter<>
	EDFilter ()=default

	EDFilter (const EDFilter &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDFilter &	operator= (const EDFilter &)=delete

bool	wantsGlobalLuminosityBlocks () const final

bool	wantsGlobalRuns () const final

bool	wantsInputProcessBlocks () const final

bool	wantsProcessBlocks () const final

bool	wantsStreamLuminosityBlocks () const final

bool	wantsStreamRuns () const final

Public Member Functions inherited from edm::global::EDFilterBase
	EDFilterBase ()

ModuleDescription const &	moduleDescription () const

	~EDFilterBase () override

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

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

std::vector< edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const

std::vector< bool > const &	recordProvenanceList () const

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

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

void	resolvePutIndicies (BranchType iBranchType, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)

TypeLabelList const &	typeLabelList () const
	used by the fwk to register the list of products of this module More...

	~ProducerBase () noexcept(false) override

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

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ESResolverIndex const *	esGetTokenIndices (edm::Transition iTrans) const

std::vector< ESResolverIndex > const &	esGetTokenIndicesVector (edm::Transition iTrans) const

std::vector< ESRecordIndex > const &	esGetTokenRecordIndicesVector (edm::Transition iTrans) const

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

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

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

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::array< std::vector< ModuleDescription const > , NumBranchTypes > &modulesAll, std::vector< ModuleProcessName > &modulesInPreviousProcesses, ProductRegistry const &preg, std::map< std::string, ModuleDescription const *> const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

void	selectInputProcessBlocks (ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase)

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

void	updateLookup (eventsetup::ESRecordsToProductResolverIndices const &)

virtual	~EDConsumerBase () noexcept(false)

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

Static Public Member Functions inherited from edm::global::EDFilterBase
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 Member Functions
reco::CaloMET	BuildCaloMet (float sumet, float pt, float phi) const

Private Attributes
const bool	accept2NoiseRBXEvents_

const edm::InputTag	CaloMetCollectionTag_

const double	CaloMetCut_

const edm::InputTag	HcalNoiseRBXCollectionTag_

edm::EDGetTokenT< reco::CaloMETCollection >	m_theCaloMetToken

edm::EDGetTokenT< reco::HcalNoiseRBXCollection >	m_theHcalNoiseToken

const double	maxHighEHitTime_

const int	maxNumRBXs_

const double	maxRatio_

const double	maxRBXEMF_

const double	minHighEHitTime_

const double	minHighHitE_

const int	minHPDHits_

const int	minHPDNoOtherHits_

const double	minLowHitE_

const double	minR45HitE_

const double	minRatio_

const double	minRBXEnergy_

const int	minRBXHits_

const double	minRecHitE_

const int	minZeros_

const bool	needEMFCoincidence_

const int	numRBXsToConsider_

const int	severity_

const double	TS4TS5EnergyThreshold_

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

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

Additional Inherited Members
Public Types inherited from edm::global::EDFilterBase
typedef EDFilterBase	ModuleType

Public Types inherited from edm::ProducerBase
template<typename T >
using	BranchAliasSetterT = ProductRegistryHelper::BranchAliasSetterT< T >

using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const , const char , edm::ProductResolverIndex > >

typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Protected Member Functions inherited from edm::ProducerBase
template<Transition Tr = Transition::Event>
auto	produces (std::string instanceName) noexcept
	declare what type of product will make and with which optional label More...

template<Transition B>
BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

template<BranchType B>
BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

template<typename ProductType , Transition B>
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

template<class ProductType >
BranchAliasSetterT< ProductType >	produces ()

template<typename ProductType , BranchType B>
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

template<typename ProductType , BranchType B>
BranchAliasSetterT< ProductType >	produces ()

template<class ProductType >
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

template<typename ProductType , Transition B>
BranchAliasSetterT< ProductType >	produces ()

template<Transition Tr = Transition::Event>
auto	produces () noexcept

ProducesCollector	producesCollector ()

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

template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept

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 ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

template<Transition Tr = Transition::Event>
constexpr auto	esConsumes ()

template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag)

template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...

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)

void	resetItemsToGetFrom (BranchType iType)

Detailed Description

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

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

Definition at line 20 of file HLTHcalMETNoiseCleaner.h.

Member Typedef Documentation

◆ noisedataset_t

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

private

Definition at line 68 of file HLTHcalMETNoiseCleaner.h.

Constructor & Destructor Documentation

◆ HLTHcalMETNoiseCleaner()

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

explicit

Definition at line 47 of file HLTHcalMETNoiseCleaner.cc.

References CaloMetCollectionTag_, edm::ParameterSet::getParameter(), HcalNoiseRBXCollectionTag_, mps_fire::i, createfilelist::int, m_theCaloMetToken, m_theHcalNoiseToken, jetUpdater_cfi::sort, TS4TS5LowerCut_, and TS4TS5UpperCut_.

     : HcalNoiseRBXCollectionTag_(iConfig.getParameter<edm::InputTag>("HcalNoiseRBXCollection")),
       CaloMetCollectionTag_(iConfig.getParameter<edm::InputTag>("CaloMetCollection")),
       CaloMetCut_(iConfig.getParameter<double>("CaloMetCut")),
       severity_(iConfig.getParameter<int>("severity")),
       maxNumRBXs_(iConfig.getParameter<int>("maxNumRBXs")),
       numRBXsToConsider_(iConfig.getParameter<int>("numRBXsToConsider")),
       accept2NoiseRBXEvents_(iConfig.getParameter<bool>("accept2NoiseRBXEvents")),
       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_(iConfig.getParameter<double>("minR45HitE")),
       TS4TS5EnergyThreshold_(iConfig.getParameter<double>("TS4TS5EnergyThreshold")) {
   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_theCaloMetToken = consumes<reco::CaloMETCollection>(CaloMetCollectionTag_);
   m_theHcalNoiseToken = consumes<reco::HcalNoiseRBXCollection>(HcalNoiseRBXCollectionTag_);
 
   produces<reco::CaloMETCollection>();
 }

◆ ~HLTHcalMETNoiseCleaner()

HLTHcalMETNoiseCleaner::~HLTHcalMETNoiseCleaner ( )

overridedefault

Member Function Documentation

◆ BuildCaloMet()

reco::CaloMET HLTHcalMETNoiseCleaner::BuildCaloMet	(	float	sumet,
		float	pt,
		float	phi
	)		const

private

Definition at line 339 of file HLTHcalMETNoiseCleaner.cc.

References phi, DiDispStaMuonMonitor_cfi::pt, timingPdfMaker::specific, and L1BJetProducer_cff::vtx.

Referenced by filter().

                                                                                        {
   // Instantiate the container to hold the calorimeter specific information
 
   typedef math::XYZPoint Point;
   typedef math::XYZTLorentzVector LorentzVector;
 
   SpecificCaloMETData specific;
   // Initialise the container
   specific.MaxEtInEmTowers = 0.0;     // Maximum energy in EM towers
   specific.MaxEtInHadTowers = 0.0;    // Maximum energy in HCAL towers
   specific.HadEtInHO = 0.0;           // Hadronic energy fraction in HO
   specific.HadEtInHB = 0.0;           // Hadronic energy in HB
   specific.HadEtInHF = 0.0;           // Hadronic energy in HF
   specific.HadEtInHE = 0.0;           // Hadronic energy in HE
   specific.EmEtInEB = 0.0;            // Em energy in EB
   specific.EmEtInEE = 0.0;            // Em energy in EE
   specific.EmEtInHF = 0.0;            // Em energy in HF
   specific.EtFractionHadronic = 0.0;  // Hadronic energy fraction
   specific.EtFractionEm = 0.0;        // Em energy fraction
   specific.CaloSETInpHF = 0.0;        // CaloSET in HF+
   specific.CaloSETInmHF = 0.0;        // CaloSET in HF-
   specific.CaloMETInpHF = 0.0;        // CaloMET in HF+
   specific.CaloMETInmHF = 0.0;        // CaloMET in HF-
   specific.CaloMETPhiInpHF = 0.0;     // CaloMET-phi in HF+
   specific.CaloMETPhiInmHF = 0.0;     // CaloMET-phi in HF-
   specific.METSignificance = 0.0;
 
   TLorentzVector p4TL;
   p4TL.SetPtEtaPhiM(pt, 0., phi, 0.);
   const LorentzVector p4(p4TL.X(), p4TL.Y(), 0, p4TL.T());
   const Point vtx(0.0, 0.0, 0.0);
   reco::CaloMET specificmet(specific, sumet, p4, vtx);
   return specificmet;
 }

◆ fillDescriptions()

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

static

Definition at line 92 of file HLTHcalMETNoiseCleaner.cc.

References edm::ConfigurationDescriptions::add(), submitPVResolutionJobs::desc, ProducerED_cfi::InputTag, hltHbhereco_cfi::TS4TS5LowerCut, hltHbhereco_cfi::TS4TS5LowerThreshold, hltHbhereco_cfi::TS4TS5UpperCut, and hltHbhereco_cfi::TS4TS5UpperThreshold.

                                                                                         {
   edm::ParameterSetDescription desc;
   desc.add<edm::InputTag>("HcalNoiseRBXCollection", edm::InputTag("hltHcalNoiseInfoProducer"));
   desc.add<edm::InputTag>("CaloMetCollection", edm::InputTag("hltMet"));
   desc.add<double>("CaloMetCut", 0.0);
   desc.add<int>("severity", 1);
   desc.add<int>("maxNumRBXs", 2);
   desc.add<int>("numRBXsToConsider", 2);
   desc.add<bool>("accept2NoiseRBXEvents", true);
   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};
   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);
 
   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);
   descriptions.add("hltHcalMETNoiseCleaner", desc);
 }

◆ filter()

bool HLTHcalMETNoiseCleaner::filter	(	edm::StreamID	,
		edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)		const

overridevirtual

Implements edm::global::EDFilterBase.

Definition at line 138 of file HLTHcalMETNoiseCleaner.cc.

References accept2NoiseRBXEvents_, edm::RefVector< C, T, F >::begin(), BuildCaloMet(), CaloMetCut_, ztail::d, data, edm::RefVector< C, T, F >::end(), HcalNoiseRBXCollectionTag_, iEvent, edm::HandleBase::isValid(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, LogDebug, m_theCaloMetToken, m_theHcalNoiseToken, maxHighEHitTime_, maxRatio_, maxRBXEMF_, minHighEHitTime_, minHighHitE_, minHPDHits_, minHPDNoOtherHits_, minLowHitE_, minR45HitE_, minRatio_, minRBXEnergy_, minRBXHits_, minRecHitE_, minZeros_, eostools::move(), needEMFCoincidence_, numRBXsToConsider_, or, reco::LeafCandidate::pt(), severity_, TS4TS5EnergyThreshold_, TS4TS5LowerCut_, and TS4TS5UpperCut_.

                                                                                                     {
   using namespace reco;
 
   //output collection
   std::unique_ptr<CaloMETCollection> CleanedMET(new CaloMETCollection);
 
   //get the calo MET / MHT
   edm::Handle<CaloMETCollection> met_h;
   iEvent.getByToken(m_theCaloMetToken, met_h);
 
   if (not met_h.isValid() or met_h->empty() or
       met_h->front().pt() < 0) {  //No Valid MET, don't do anything and accept the event
     return true;                  // we shouldn't get here, but lets not crash
   }
 
   reco::CaloMET inCaloMet = met_h->front();
 
   // in this case, do not filter anything
   if (severity_ == 0) {
     CleanedMET->push_back(inCaloMet);
     iEvent.put(std::move(CleanedMET));
     return true;
   }
 
   // get the RBXs produced by RecoMET/METProducers/HcalNoiseInfoProducer
   edm::Handle<HcalNoiseRBXCollection> rbxs_h;
   iEvent.getByToken(m_theHcalNoiseToken, rbxs_h);
   if (!rbxs_h.isValid()) {
     edm::LogError("DataNotFound") << "HLTHcalMETNoiseCleaner: Could not find HcalNoiseRBXCollection product named "
                                   << HcalNoiseRBXCollectionTag_ << "." << std::endl;
     CleanedMET->push_back(inCaloMet);
     iEvent.put(std::move(CleanedMET));
     return true;  // no valid RBXs
   }
 
   // create a sorted set of the RBXs, ordered by energy
   noisedataset_t data;
   for (auto const& rbx : *rbxs_h) {
     CommonHcalNoiseRBXData d(rbx,
                              minRecHitE_,
                              minLowHitE_,
                              minHighHitE_,
                              TS4TS5EnergyThreshold_,
                              TS4TS5UpperCut_,
                              TS4TS5LowerCut_,
                              minR45HitE_);
     data.insert(d);
   }
   //if 0 RBXs are in the list, just accept
   if (data.empty()) {
     CleanedMET->push_back(inCaloMet);
     iEvent.put(std::move(CleanedMET));
     return true;
   }
   // data is now sorted by RBX energy
   // only consider top N=numRBXsToConsider_ energy RBXs
   int cntr = 0;
   int nNoise = 0;
 
   TVector3 metVec;
   metVec.SetPtEtaPhi(met_h->front().pt(), 0, met_h->front().phi());
 
   TVector3 noiseHPDVector(0, 0, 0);
   TVector3 secondHPDVector(0, 0, 0);
   for (auto it = data.begin(); it != data.end() && cntr < numRBXsToConsider_; it++, cntr++) {
     bool isNoise = 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 (!it->PassTS4TS5())
         passFilter = false;
 
       if (it->RBXEMF() < maxRBXEMF_) {
         passEMF = false;
       }
     }
 
     if ((needEMFCoincidence_ && !passEMF && !passFilter) || (!needEMFCoincidence_ && !passFilter)) {  // check for noise
       LogDebug("") << "HLTHcalMETNoiseCleaner 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() << "; "
                    << "passTS4TS5=" << it->PassTS4TS5() << "; "
                    << "RBX EMF=" << it->RBXEMF() << std::endl;
       nNoise++;
       isNoise = true;
     }  // OK, checked for noise
 
     //------------First Noisy RBX-----------------------
     if (isNoise && nNoise == 1) {
       edm::RefVector<CaloTowerCollection> noiseTowers = it->rbxTowers();
       edm::RefVector<CaloTowerCollection>::const_iterator noiseTowersIt;
       // get the energy vector for this RBX from the calotowers
       for (noiseTowersIt = noiseTowers.begin(); noiseTowersIt != noiseTowers.end(); noiseTowersIt++) {
         TVector3 towerVec;
         towerVec.SetPtEtaPhi((*noiseTowersIt)->pt(), (*noiseTowersIt)->eta(), (*noiseTowersIt)->phi());
         noiseHPDVector += towerVec;  // add this tower to the vector for the RBX
       }
       if (noiseHPDVector.Mag() > 0)
         noiseHPDVector.SetPtEtaPhi(noiseHPDVector.Pt(), 0, noiseHPDVector.Phi());  // make the noise transverse
       else
         noiseHPDVector.SetPtEtaPhi(0, 0, 0);
     }
     //-----------FOUND a SECOND NOISY RBX-------------------
     if (isNoise && cntr > 0) {
       CleanedMET->push_back(inCaloMet);
       iEvent.put(std::move(CleanedMET));
       return accept2NoiseRBXEvents_;  // don't try to clean these for the moment, just keep or throw away
     }
     //----------LEADING RBX is NOT NOISY--------------------
     if (!isNoise && cntr == 0) {
       CleanedMET->push_back(inCaloMet);
       iEvent.put(std::move(CleanedMET));
       return true;  // don't reject the event if the leading RBX isn't noise
     }
     //-----------SUBLEADING RBX is NOT NOISY: STORE INFO----
     if (!isNoise && nNoise > 0) {  //second RBX isn't noisy (and first one was), so clean
       edm::RefVector<CaloTowerCollection> noiseTowers = it->rbxTowers();
       edm::RefVector<CaloTowerCollection>::const_iterator noiseTowersIt;
       for (noiseTowersIt = noiseTowers.begin(); noiseTowersIt != noiseTowers.end(); noiseTowersIt++) {
         TVector3 towerVec;
         towerVec.SetPtEtaPhi((*noiseTowersIt)->pt(), (*noiseTowersIt)->eta(), (*noiseTowersIt)->phi());
         secondHPDVector += towerVec;  // add this tower to the vector for the RBX
       }
       if (secondHPDVector.Mag() > 0)
         secondHPDVector.SetPtEtaPhi(secondHPDVector.Pt(), 0, secondHPDVector.Phi());  // make the second transverse
       else
         secondHPDVector.SetPtEtaPhi(0, 0, 0);
       break;
     }
   }  // end RBX loop
 
   if (noiseHPDVector.Mag() == 0) {
     CleanedMET->push_back(inCaloMet);
     iEvent.put(std::move(CleanedMET));
     return true;  // don't reject the event if the leading RBX isn't noise
   }
 
   //********************************************************************************
   //The Event gets here only if it had exactly 1 noisy RBX in the lead position
   //********************************************************************************
 
   float METsumet = met_h->front().energy();
 
   metVec += noiseHPDVector;
 
   float ZMETsumet = METsumet - noiseHPDVector.Mag();
   float ZMETpt = metVec.Pt();
   float ZMETphi = metVec.Phi();
 
   //put the second RBX vector in the eta phi position of the leading RBX vector
 
   float SMETsumet = 0;
   float SMETpt = 0;
   float SMETphi = 0;
   if (secondHPDVector.Mag() > 0.) {
     secondHPDVector.SetPtEtaPhi(secondHPDVector.Pt(), noiseHPDVector.Eta(), noiseHPDVector.Phi());
     metVec -= secondHPDVector;
     SMETsumet = METsumet - noiseHPDVector.Mag();
     SMETpt = metVec.Pt();
     SMETphi = metVec.Phi();
   }
   //Get the maximum MET:
   float CorMetSumEt, CorMetPt, CorMetPhi;
   if (ZMETpt > SMETpt) {
     CorMetSumEt = ZMETsumet;
     CorMetPt = ZMETpt;
     CorMetPhi = ZMETphi;
   } else {
     CorMetSumEt = SMETsumet;
     CorMetPt = SMETpt;
     CorMetPhi = SMETphi;
   }
 
   reco::CaloMET corMet = BuildCaloMet(CorMetSumEt, CorMetPt, CorMetPhi);
   CleanedMET->push_back(corMet);
   iEvent.put(std::move(CleanedMET));
 
   return (corMet.pt() > CaloMetCut_);
 }

Member Data Documentation

◆ accept2NoiseRBXEvents_

const bool HLTHcalMETNoiseCleaner::accept2NoiseRBXEvents_

private

Definition at line 37 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter().

◆ CaloMetCollectionTag_

const edm::InputTag HLTHcalMETNoiseCleaner::CaloMetCollectionTag_

private

Definition at line 32 of file HLTHcalMETNoiseCleaner.h.

Referenced by HLTHcalMETNoiseCleaner().

◆ CaloMetCut_

const double HLTHcalMETNoiseCleaner::CaloMetCut_

private

Definition at line 33 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter().

◆ HcalNoiseRBXCollectionTag_

const edm::InputTag HLTHcalMETNoiseCleaner::HcalNoiseRBXCollectionTag_

private

Definition at line 31 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter(), and HLTHcalMETNoiseCleaner().

◆ m_theCaloMetToken

edm::EDGetTokenT<reco::CaloMETCollection> HLTHcalMETNoiseCleaner::m_theCaloMetToken

private

Definition at line 28 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter(), and HLTHcalMETNoiseCleaner().

◆ m_theHcalNoiseToken

edm::EDGetTokenT<reco::HcalNoiseRBXCollection> HLTHcalMETNoiseCleaner::m_theHcalNoiseToken

private

Definition at line 29 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter(), and HLTHcalMETNoiseCleaner().

◆ maxHighEHitTime_

const double HLTHcalMETNoiseCleaner::maxHighEHitTime_

private

Definition at line 47 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter().

◆ maxNumRBXs_

const int HLTHcalMETNoiseCleaner::maxNumRBXs_

private

Definition at line 35 of file HLTHcalMETNoiseCleaner.h.

◆ maxRatio_

const double HLTHcalMETNoiseCleaner::maxRatio_

private

Definition at line 41 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter().

◆ maxRBXEMF_

const double HLTHcalMETNoiseCleaner::maxRBXEMF_

private

Definition at line 48 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter().

◆ minHighEHitTime_

const double HLTHcalMETNoiseCleaner::minHighEHitTime_

private

Definition at line 46 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter().

◆ minHighHitE_

const double HLTHcalMETNoiseCleaner::minHighHitE_

private

Definition at line 53 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter().

◆ minHPDHits_

const int HLTHcalMETNoiseCleaner::minHPDHits_

private

Definition at line 42 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter().

◆ minHPDNoOtherHits_

const int HLTHcalMETNoiseCleaner::minHPDNoOtherHits_

private

Definition at line 44 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter().

◆ minLowHitE_

const double HLTHcalMETNoiseCleaner::minLowHitE_

private

Definition at line 52 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter().

◆ minR45HitE_

const double HLTHcalMETNoiseCleaner::minR45HitE_

private

Definition at line 54 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter().

◆ minRatio_

const double HLTHcalMETNoiseCleaner::minRatio_

private

Definition at line 40 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter().

◆ minRBXEnergy_

const double HLTHcalMETNoiseCleaner::minRBXEnergy_

private

Definition at line 39 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter().

◆ minRBXHits_

const int HLTHcalMETNoiseCleaner::minRBXHits_

private

Definition at line 43 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter().

◆ minRecHitE_

const double HLTHcalMETNoiseCleaner::minRecHitE_

private

Definition at line 51 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter().

◆ minZeros_

const int HLTHcalMETNoiseCleaner::minZeros_

private

Definition at line 45 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter().

◆ needEMFCoincidence_

const bool HLTHcalMETNoiseCleaner::needEMFCoincidence_

private

Definition at line 38 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter().

◆ numRBXsToConsider_

const int HLTHcalMETNoiseCleaner::numRBXsToConsider_

private

Definition at line 36 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter().

◆ severity_

const int HLTHcalMETNoiseCleaner::severity_

private

Definition at line 34 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter().

◆ TS4TS5EnergyThreshold_

const double HLTHcalMETNoiseCleaner::TS4TS5EnergyThreshold_

private

Definition at line 56 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter().

◆ TS4TS5LowerCut_

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

private

Definition at line 58 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter(), and HLTHcalMETNoiseCleaner().

◆ TS4TS5UpperCut_

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

private

Definition at line 57 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter(), and HLTHcalMETNoiseCleaner().

Classes

Public Member Functions

Static Public Member Functions

Private Types

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ noisedataset_t

Constructor & Destructor Documentation

◆ HLTHcalMETNoiseCleaner()

◆ ~HLTHcalMETNoiseCleaner()

Member Function Documentation

◆ BuildCaloMet()

◆ fillDescriptions()

◆ filter()

Member Data Documentation

◆ accept2NoiseRBXEvents_

◆ CaloMetCollectionTag_

◆ CaloMetCut_

◆ HcalNoiseRBXCollectionTag_

◆ m_theCaloMetToken

◆ m_theHcalNoiseToken

◆ maxHighEHitTime_

◆ maxNumRBXs_

◆ maxRatio_

◆ maxRBXEMF_

◆ minHighEHitTime_

◆ minHighHitE_

◆ minHPDHits_

◆ minHPDNoOtherHits_

◆ minLowHitE_

◆ minR45HitE_

◆ minRatio_

◆ minRBXEnergy_

◆ minRBXHits_

◆ minRecHitE_

◆ minZeros_

◆ needEMFCoincidence_

◆ numRBXsToConsider_

◆ severity_

◆ TS4TS5EnergyThreshold_

◆ TS4TS5LowerCut_

◆ TS4TS5UpperCut_