#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

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)

	~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

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::vector< ModuleDescription const * > &modules, 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

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

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

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 20 of file HLTHcalMETNoiseCleaner.h.

Member Typedef Documentation

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

private

Definition at line 66 of file HLTHcalMETNoiseCleaner.h.

Constructor & Destructor Documentation

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_, TS4TS5UpperCut_, and ~HLTHcalMETNoiseCleaner().

   : 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 ( )

overridedefault

Referenced by HLTHcalMETNoiseCleaner().

Member Function Documentation

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

private

Definition at line 332 of file HLTHcalMETNoiseCleaner.cc.

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;
   }

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

static

Definition at line 99 of file HLTHcalMETNoiseCleaner.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), HBHEPulseShapeFlagSetter_cfi::TS4TS5LowerCut, HBHEPulseShapeFlagSetter_cfi::TS4TS5LowerThreshold, HBHEPulseShapeFlagSetter_cfi::TS4TS5UpperCut, and HBHEPulseShapeFlagSetter_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);
 }

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

override

Definition at line 145 of file HLTHcalMETNoiseCleaner.cc.

References accept2NoiseRBXEvents_, edm::RefVector< C, T, F >::begin(), BuildCaloMet(), CaloMetCut_, edmIntegrityCheck::d, data, edm::RefVector< C, T, F >::end(), edm::Event::getByToken(), HcalNoiseRBXCollectionTag_, 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(), edm::Event::put(), 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

bool HLTHcalMETNoiseCleaner::accept2NoiseRBXEvents_

private

Definition at line 38 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter().

edm::InputTag HLTHcalMETNoiseCleaner::CaloMetCollectionTag_

private

Definition at line 33 of file HLTHcalMETNoiseCleaner.h.

Referenced by HLTHcalMETNoiseCleaner().

double HLTHcalMETNoiseCleaner::CaloMetCut_

private

Definition at line 34 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter().

edm::InputTag HLTHcalMETNoiseCleaner::HcalNoiseRBXCollectionTag_

private

Definition at line 32 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter(), and HLTHcalMETNoiseCleaner().

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

private

Definition at line 29 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter(), and HLTHcalMETNoiseCleaner().

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

private

Definition at line 30 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter(), and HLTHcalMETNoiseCleaner().

double HLTHcalMETNoiseCleaner::maxHighEHitTime_

private

Definition at line 48 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter().

int HLTHcalMETNoiseCleaner::maxNumRBXs_

private

Definition at line 36 of file HLTHcalMETNoiseCleaner.h.

double HLTHcalMETNoiseCleaner::maxRatio_

private

Definition at line 42 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter().

double HLTHcalMETNoiseCleaner::maxRBXEMF_

private

Definition at line 49 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter().

double HLTHcalMETNoiseCleaner::minHighEHitTime_

private

Definition at line 47 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter().

double HLTHcalMETNoiseCleaner::minHighHitE_

private

Definition at line 52 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter().

int HLTHcalMETNoiseCleaner::minHPDHits_

private

Definition at line 43 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter().

int HLTHcalMETNoiseCleaner::minHPDNoOtherHits_

private

Definition at line 45 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter().

double HLTHcalMETNoiseCleaner::minLowHitE_

private

Definition at line 52 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter().

double HLTHcalMETNoiseCleaner::minR45HitE_

private

Definition at line 52 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter(), and HLTHcalMETNoiseCleaner().

double HLTHcalMETNoiseCleaner::minRatio_

private

Definition at line 41 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter().

double HLTHcalMETNoiseCleaner::minRBXEnergy_

private

Definition at line 40 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter().

int HLTHcalMETNoiseCleaner::minRBXHits_

private

Definition at line 44 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter().

double HLTHcalMETNoiseCleaner::minRecHitE_

private

Definition at line 52 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter().

int HLTHcalMETNoiseCleaner::minZeros_

private

Definition at line 46 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter().

bool HLTHcalMETNoiseCleaner::needEMFCoincidence_

private

Definition at line 39 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter().

int HLTHcalMETNoiseCleaner::numRBXsToConsider_

private

Definition at line 37 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter().

int HLTHcalMETNoiseCleaner::severity_

private

Definition at line 35 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter().

double HLTHcalMETNoiseCleaner::TS4TS5EnergyThreshold_

private

Definition at line 54 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter().

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

private

Definition at line 56 of file HLTHcalMETNoiseCleaner.h.

Referenced by filter(), and HLTHcalMETNoiseCleaner().

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

private

Definition at line 55 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

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation