#include <PFMETFilter.h>

Inheritance diagram for PFMETFilter:

Public Member Functions
void	beginJob () override

bool	checkInput ()

void	endJob () override

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

	PFMETFilter (const edm::ParameterSet &)

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

Private Attributes
std::vector< std::string >	collections_

double	DeltaMEXsigma_

std::vector< int >	doMax_

std::vector< int >	doMin_

std::vector< double >	max_

std::vector< double >	min_

double	sigma_a_

double	sigma_b_

double	sigma_c_

std::string	TrueMET_

std::vector< std::string >	variables_

bool	verbose_

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

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

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

Definition at line 11 of file PFMETFilter.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 12 of file PFMETFilter.cc.

References collections_, DeltaMEXsigma_, doMax_, doMin_, edm::ParameterSet::getParameter(), max_, min_, sigma_a_, sigma_b_, sigma_c_, AlCaHLTBitMon_QueryRunRegistry::string, TrueMET_, variables_, and verbose_.

                                                        {
   collections_ = iConfig.getParameter<std::vector<std::string>>("Collections");
   variables_ = iConfig.getParameter<std::vector<std::string>>("Variables");
   min_ = iConfig.getParameter<std::vector<double>>("Mins");
   max_ = iConfig.getParameter<std::vector<double>>("Maxs");
   doMin_ = iConfig.getParameter<std::vector<int>>("DoMin");
   doMax_ = iConfig.getParameter<std::vector<int>>("DoMax");
   TrueMET_ = iConfig.getParameter<std::string>("TrueMET");
   DeltaMEXsigma_ = iConfig.getParameter<double>("DeltaMEXsigma");
   sigma_a_ = iConfig.getParameter<double>("sigma_a");
   sigma_b_ = iConfig.getParameter<double>("sigma_b");
   sigma_c_ = iConfig.getParameter<double>("sigma_c");
   verbose_ = iConfig.getParameter<bool>("verbose");
 }

PFMETFilter::~PFMETFilter ( )

override

Definition at line 27 of file PFMETFilter.cc.

27 {}

Member Function Documentation

void PFMETFilter::beginJob ( void )

overridevirtual

Reimplemented from edm::EDFilter.

Definition at line 63 of file PFMETFilter.cc.

                            {
   // std::cout << "FL: beginJob" << std::endl;
 }

bool PFMETFilter::checkInput ( )

Definition at line 29 of file PFMETFilter.cc.

References collections_, gather_cfg::cout, doMax_, doMin_, max_, min_, and variables_.

Referenced by filter().

                              {
   if (collections_.size() != min_.size()) {
     std::cout << "Error: in PFMETFilter: collections_.size()!=min_.size()" << std::endl;
     std::cout << "collections_.size() = " << collections_.size() << std::endl;
     std::cout << "min_.size() = " << min_.size() << std::endl;
     return false;
   }
   if (collections_.size() != max_.size()) {
     std::cout << "Error: in PFMETFilter: collections_.size()!=max_.size()" << std::endl;
     std::cout << "collections_.size() = " << collections_.size() << std::endl;
     std::cout << "max_.size() = " << max_.size() << std::endl;
     return false;
   }
   if (collections_.size() != doMin_.size()) {
     std::cout << "Error: in PFMETFilter: collections_.size()!=min_.size()" << std::endl;
     std::cout << "collections_.size() = " << collections_.size() << std::endl;
     std::cout << "doMin_.size() = " << doMin_.size() << std::endl;
     return false;
   }
   if (collections_.size() != doMax_.size()) {
     std::cout << "Error: in PFMETFilter: collections_.size()!=min_.size()" << std::endl;
     std::cout << "collections_.size() = " << collections_.size() << std::endl;
     std::cout << "doMax_.size() = " << doMax_.size() << std::endl;
     return false;
   }
   if (collections_.size() != variables_.size()) {
     std::cout << "Error: in PFMETFilter: collections_.size()!=variables_.size()" << std::endl;
     std::cout << "collections_.size() = " << collections_.size() << std::endl;
     std::cout << "variables_.size() = " << variables_.size() << std::endl;
     return false;
   }
   return true;
 }

void PFMETFilter::endJob ( void )

overridevirtual

Reimplemented from edm::EDFilter.

Definition at line 266 of file PFMETFilter.cc.

                          {
   // std::cout << "FL: endJob" << std::endl;
 }

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

override

Definition at line 67 of file PFMETFilter.cc.

References checkInput(), collections_, gather_cfg::cout, delta, DeltaMEXsigma_, doMax_, doMin_, reco::Candidate::et(), reco::Candidate::eta(), edm::Event::getByLabel(), M_PI, max_, RazorAnalyzer::met, min_, reco::Candidate::phi(), edm::Handle< T >::product(), reco::Candidate::px(), reco::Candidate::py(), sigma_a_, sigma_b_, sigma_c_, findQualityFiles::size, createPayload::skip, mathSSE::sqrt(), AlCaHLTBitMon_QueryRunRegistry::string, reco::MET::sumEt(), TrueMET_, variables_, and verbose_.

                                                                       {
   // std::cout << "FL: filter" << std::endl;
   // std::cout << "FL: Mins = " << min_ << std::endl;
 
   if (!checkInput())
     return true;  // no filtering !
 
   bool skip = false;
 
   for (unsigned int varc = 0; varc < collections_.size(); ++varc) {
     // std::cout << "FL: var[" << varc << "] = " << collections_[varc] <<
     // std::endl; std::cout << "FL: var[0] = " << collections_[0] << std::endl;
 
     // if the collection is collection1-collection2:
     const unsigned int minuspos = collections_[varc].find("-");
     if (minuspos < collections_[varc].size()) {
       std::string collection1;
       collection1.assign(collections_[varc], 0, minuspos);
       // std::cout << "collection1 = " << collection1 << std::endl;
       std::string collection2;
       collection2.assign(collections_[varc], minuspos + 1, collections_[varc].size());
       // std::cout << "collection2 = " << collection2 << std::endl;
 
       const edm::View<reco::Candidate> *var1;
       edm::Handle<edm::View<reco::Candidate>> var1_hnd;
       bool isVar1 = iEvent.getByLabel(collection1, var1_hnd);
       if (!isVar1) {
         std::cout << "Warning : no " << collection1 << " in input !" << std::endl;
         return false;
       }
       var1 = var1_hnd.product();
       const reco::Candidate *var10 = &(*var1)[0];
       // std::cout << "FL: var10.pt = " << var10->et() << std::endl;
       double coll_var1;
       if (variables_[varc] == "et")
         coll_var1 = var10->et();
       else if (variables_[varc] == "phi")
         coll_var1 = var10->phi();
       else if (variables_[varc] == "eta")
         coll_var1 = var10->eta();
       else {
         std::cout << "Error: PFMETFilter: variable unknown: " << variables_[varc] << std::endl;
         return true;
       }
       // std::cout << "FL: coll_var1[" << variables_[varc] << "] = " <<
       // coll_var1 << std::endl;
 
       const edm::View<reco::Candidate> *var2;
       edm::Handle<edm::View<reco::Candidate>> var2_hnd;
       bool isVar2 = iEvent.getByLabel(collection2, var2_hnd);
       if (!isVar2) {
         std::cout << "Warning : no " << collection2 << " in input !" << std::endl;
         return false;
       }
       var2 = var2_hnd.product();
       const reco::Candidate *var20 = &(*var2)[0];
       // std::cout << "FL: var20.pt = " << var20->et() << std::endl;
       double coll_var2;
       if (variables_[varc] == "et")
         coll_var2 = var20->et();
       else if (variables_[varc] == "phi")
         coll_var2 = var20->phi();
       else if (variables_[varc] == "eta")
         coll_var2 = var20->eta();
       else {
         std::cout << "Error: PFMETFilter: variable unknown: " << variables_[varc] << std::endl;
         return true;
       }
       // std::cout << "FL: coll_var2[" << variables_[varc] << "] = " <<
       // coll_var2 << std::endl; std::cout << "FL: max_[varc] = " << max_[varc]
       // << std::endl; std::cout << "FL: min_[varc] = " << min_[varc] <<
       // std::endl;
 
       // Delta computation
       double delta = coll_var1 - coll_var2;
       if (variables_[varc] == "phi") {
         if (coll_var1 > M_PI)
           coll_var1 -= ceil((coll_var1 - M_PI) / (2 * M_PI)) * 2 * M_PI;
         if (coll_var1 <= -M_PI)
           coll_var1 += ceil((coll_var1 + M_PI) / (-2. * M_PI)) * 2. * M_PI;
         if (coll_var2 > M_PI)
           coll_var2 -= ceil((coll_var2 - M_PI) / (2 * M_PI)) * 2 * M_PI;
         if (coll_var2 <= -M_PI)
           coll_var2 += ceil((coll_var2 + M_PI) / (-2. * M_PI)) * 2 * M_PI;
 
         double deltaphi = -999.0;
         if (fabs(coll_var1 - coll_var2) < M_PI) {
           deltaphi = (coll_var1 - coll_var2);
         } else {
           if ((coll_var1 - coll_var2) > 0.0) {
             deltaphi = (2 * M_PI - fabs(coll_var1 - coll_var2));
           } else {
             deltaphi = -(2 * M_PI - fabs(coll_var1 - coll_var2));
           }
         }
         delta = deltaphi;
       }
 
       // cuts
       if (doMin_[varc] && doMax_[varc] && max_[varc] < min_[varc]) {
         if (delta > max_[varc] && delta < min_[varc])
           skip = true;
       } else {
         if (doMin_[varc] && delta < min_[varc])
           skip = true;
         if (doMax_[varc] && delta > max_[varc])
           skip = true;
       }
       // std::cout << "skip = " << skip << std::endl;
     } else {
       // get the variable:
       const edm::View<reco::Candidate> *var0;
       edm::Handle<edm::View<reco::Candidate>> var0_hnd;
       bool isVar0 = iEvent.getByLabel(collections_[varc], var0_hnd);
       if (!isVar0) {
         std::cout << "Warning : no " << collections_[varc] << " in input !" << std::endl;
         return false;
       }
       var0 = var0_hnd.product();
       const reco::Candidate *var00 = &(*var0)[0];
       // std::cout << "FL: var00.pt = " << var00->et() << std::endl;
       double coll_var;
       if (variables_[varc] == "et")
         coll_var = var00->et();
       else if (variables_[varc] == "phi")
         coll_var = var00->phi();
       else if (variables_[varc] == "eta")
         coll_var = var00->eta();
       else if (variables_[varc] == "DeltaMEXcut") {
         const edm::View<reco::Candidate> *truevar0;
         edm::Handle<edm::View<reco::Candidate>> truevar0_hnd;
         bool istrueVar0 = iEvent.getByLabel(TrueMET_, truevar0_hnd);
         if (!istrueVar0) {
           std::cout << "Warning : no " << TrueMET_ << " in input !" << std::endl;
           return false;
         }
         truevar0 = truevar0_hnd.product();
         const reco::Candidate *truevar00 = &(*truevar0)[0];
 
         const double DeltaMEX = var00->px() - truevar00->px();
         const double DeltaMEY = var00->py() - truevar00->py();
         const double cutvalc = sqrt(DeltaMEX * DeltaMEX + DeltaMEY * DeltaMEY);
         const reco::MET *met = static_cast<const reco::MET *>(truevar00);
         const double SETc = met->sumEt();
         // std::cout << "FL: SETc = " << SETc << std::endl;
         const double sigmac = sigma_a_ + sigma_b_ * sqrt(SETc) + sigma_c_ * SETc;
         if (cutvalc > DeltaMEXsigma_ * sigmac) {
           if (verbose_) {
             std::cout << "DeltaMET = " << var00->et() - truevar00->et() << std::endl;
             std::cout << "trueSET = " << SETc << std::endl;
             std::cout << "pfMET = " << var00->et() << std::endl;
             std::cout << "trueMET = " << truevar00->et() << std::endl;
             std::cout << "DeltaMEX = " << DeltaMEX << std::endl;
             std::cout << "DeltaMEY = " << DeltaMEY << std::endl;
             std::cout << "cutvalc = " << cutvalc << std::endl;
             std::cout << "sigmac = " << sigmac << std::endl;
             std::cout << "cutvalc/sigmac = " << cutvalc / sigmac << std::endl;
           }
           return true;
         } else {
           if (verbose_ && (var00->et() - truevar00->et()) > 300.0) {
             std::cout << "EVENT NOT KEPT:" << std::endl;
             std::cout << "DeltaMET = " << var00->et() - truevar00->et() << std::endl;
             std::cout << "SETc = " << SETc << std::endl;
             std::cout << "pfMET = " << var00->et() << std::endl;
             std::cout << "trueMET = " << truevar00->et() << std::endl;
             std::cout << "DeltaMEX = " << DeltaMEX << std::endl;
             std::cout << "DeltaMEY = " << DeltaMEY << std::endl;
             std::cout << "cutvalc = " << cutvalc << std::endl;
             std::cout << "sigmac = " << sigmac << std::endl;
             std::cout << "cutvalc/sigmac = " << cutvalc / sigmac << std::endl;
           }
           return false;
         }
       } else {
         std::cout << "Error: PFMETFilter: variable unknown: " << variables_[varc] << std::endl;
         return true;
       }
       // std::cout << "FL: coll_var[" << variables_[varc] << "] = " << coll_var
       // << std::endl; std::cout << "FL: max_[varc] = " << max_[varc] <<
       // std::endl; std::cout << "FL: min_[varc] = " << min_[varc] << std::endl;
 
       // cuts
       if (doMin_[varc] && doMax_[varc] && max_[varc] < min_[varc]) {
         if (coll_var > max_[varc] && coll_var < min_[varc])
           skip = true;
       } else {
         if (doMin_[varc] && coll_var < min_[varc])
           skip = true;
         if (doMax_[varc] && coll_var > max_[varc])
           skip = true;
       }
       // std::cout << "skip = " << skip << std::endl;
     }
   }
   // std::cout << "final skip = " << skip << std::endl;
   return !skip;
 }