#include <HLTHcalMETNoiseCleaner.h>

Inheritance diagram for HLTHcalMETNoiseCleaner:

Classes
struct	noisedatacomp

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

	HLTHcalMETNoiseCleaner (const edm::ParameterSet &)

	~HLTHcalMETNoiseCleaner () override

Public Member Functions inherited from edm::EDFilter
	EDFilter ()

SerialTaskQueue *	globalLuminosityBlocksQueue ()

SerialTaskQueue *	globalRunsQueue ()

ModuleDescription const &	moduleDescription () const

	~EDFilter () 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

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

std::vector< ESProxyIndex > 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

bool	registeredToConsumeMany (TypeID const &, 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::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

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

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &)

static bool	wantsGlobalLuminosityBlocks ()

static bool	wantsGlobalRuns ()

static bool	wantsInputProcessBlocks ()

static bool	wantsProcessBlocks ()

static bool	wantsStreamLuminosityBlocks ()

static bool	wantsStreamRuns ()

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

Private Member Functions
reco::CaloMET	BuildCaloMet (float sumet, float pt, float phi)

Private Attributes
bool	accept2NoiseRBXEvents_

edm::InputTag	CaloMetCollectionTag_

double	CaloMetCut_

edm::InputTag	HcalNoiseRBXCollectionTag_

edm::EDGetTokenT< reco::CaloMETCollection >	m_theCaloMetToken

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_

double	TS4TS5EnergyThreshold_

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

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

Additional Inherited Members
Public Types inherited from edm::EDFilter
typedef EDFilter	ModuleType

Public Types inherited from edm::ProducerBase
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 ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

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

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 65 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::existsAs(), edm::ParameterSet::getParameter(), HcalNoiseRBXCollectionTag_, mps_fire::i, createfilelist::int, m_theCaloMetToken, m_theHcalNoiseToken, minR45HitE_, 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_(5.0),
       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_);
 
   if (iConfig.existsAs<double>("minR45HitE"))
     minR45HitE_ = iConfig.getParameter<double>("minR45HitE");
 
   produces<reco::CaloMETCollection>();
 }

◆ ~HLTHcalMETNoiseCleaner()

HLTHcalMETNoiseCleaner::~HLTHcalMETNoiseCleaner ( )

overridedefault

Member Function Documentation

◆ BuildCaloMet()

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

private

Definition at line 342 of file HLTHcalMETNoiseCleaner.cc.

References phi, DiDispStaMuonMonitor_cfi::pt, timingPdfMaker::specific, and extraflags_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 95 of file HLTHcalMETNoiseCleaner.cc.

References edm::ConfigurationDescriptions::add(), submitPVResolutionJobs::desc, HLT_2022v14_cff::InputTag, HLT_2022v14_cff::TS4TS5LowerCut, HLT_2022v14_cff::TS4TS5LowerThreshold, HLT_2022v14_cff::TS4TS5UpperCut, and HLT_2022v14_cff::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::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overridevirtual

Implements edm::EDFilter.

Definition at line 141 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(), 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_

bool HLTHcalMETNoiseCleaner::accept2NoiseRBXEvents_

private

Definition at line 37 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter().

◆ CaloMetCollectionTag_

edm::InputTag HLTHcalMETNoiseCleaner::CaloMetCollectionTag_

private

Definition at line 32 of file HLTHcalMETNoiseCleaner.h.

Referenced by HLTHcalMETNoiseCleaner().

◆ CaloMetCut_

double HLTHcalMETNoiseCleaner::CaloMetCut_

private

Definition at line 33 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter().

◆ HcalNoiseRBXCollectionTag_

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_

double HLTHcalMETNoiseCleaner::maxHighEHitTime_

private

Definition at line 47 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter().

◆ maxNumRBXs_

int HLTHcalMETNoiseCleaner::maxNumRBXs_

private

Definition at line 35 of file HLTHcalMETNoiseCleaner.h.

◆ maxRatio_

double HLTHcalMETNoiseCleaner::maxRatio_

private

Definition at line 41 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter().

◆ maxRBXEMF_

double HLTHcalMETNoiseCleaner::maxRBXEMF_

private

Definition at line 48 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter().

◆ minHighEHitTime_

double HLTHcalMETNoiseCleaner::minHighEHitTime_

private

Definition at line 46 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter().

◆ minHighHitE_

double HLTHcalMETNoiseCleaner::minHighHitE_

private

Definition at line 51 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter().

◆ minHPDHits_

int HLTHcalMETNoiseCleaner::minHPDHits_

private

Definition at line 42 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter().

◆ minHPDNoOtherHits_

int HLTHcalMETNoiseCleaner::minHPDNoOtherHits_

private

Definition at line 44 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter().

◆ minLowHitE_

double HLTHcalMETNoiseCleaner::minLowHitE_

private

Definition at line 51 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter().

◆ minR45HitE_

double HLTHcalMETNoiseCleaner::minR45HitE_

private

Definition at line 51 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter(), and HLTHcalMETNoiseCleaner().

◆ minRatio_

double HLTHcalMETNoiseCleaner::minRatio_

private

Definition at line 40 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter().

◆ minRBXEnergy_

double HLTHcalMETNoiseCleaner::minRBXEnergy_

private

Definition at line 39 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter().

◆ minRBXHits_

int HLTHcalMETNoiseCleaner::minRBXHits_

private

Definition at line 43 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter().

◆ minRecHitE_

double HLTHcalMETNoiseCleaner::minRecHitE_

private

Definition at line 51 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter().

◆ minZeros_

int HLTHcalMETNoiseCleaner::minZeros_

private

Definition at line 45 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter().

◆ needEMFCoincidence_

bool HLTHcalMETNoiseCleaner::needEMFCoincidence_

private

Definition at line 38 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter().

◆ numRBXsToConsider_

int HLTHcalMETNoiseCleaner::numRBXsToConsider_

private

Definition at line 36 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter().

◆ severity_

int HLTHcalMETNoiseCleaner::severity_

private

Definition at line 34 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter().

◆ TS4TS5EnergyThreshold_

double HLTHcalMETNoiseCleaner::TS4TS5EnergyThreshold_

private

Definition at line 53 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter().

◆ TS4TS5LowerCut_

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

private

Definition at line 55 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter(), and HLTHcalMETNoiseCleaner().

◆ TS4TS5UpperCut_

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

private

Definition at line 54 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_