PAT Cleaner module for PAT Objects. More...

#include "PhysicsTools/PatAlgos/interface/PATCleaner.h"

Inheritance diagram for pat::PATCleaner< PATObjType >:

Public Member Functions
	PATCleaner (const edm::ParameterSet &iConfig)

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

	~PATCleaner () override

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

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndRuns () const final

Private Types
typedef pat::helper::OverlapTest	OverlapTest

typedef StringCutObjectSelector< PATObjType >	Selector

Private Attributes
const Selector	finalCut_

std::vector< std::unique_ptr< OverlapTest > >	overlapTests_

const Selector	preselectionCut_

const edm::InputTag	src_

const edm::EDGetTokenT< edm::View< PATObjType > >	srcToken_

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

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T... >	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Detailed Description

template<class PATObjType>
class pat::PATCleaner< PATObjType >

PAT Cleaner module for PAT Objects.

The same module is used for all collections.

Author: Giovanni Petrucciani

Version

Id: PATCleaner.h,v 1.3 2010/10/20 23:08:30 wmtan Exp

Definition at line 40 of file PATCleaner.h.

Member Typedef Documentation

template<class PATObjType >

typedef pat::helper::OverlapTest pat::PATCleaner< PATObjType >::OverlapTest

private

Definition at line 55 of file PATCleaner.h.

template<class PATObjType >

typedef StringCutObjectSelector<PATObjType> pat::PATCleaner< PATObjType >::Selector

private

Definition at line 48 of file PATCleaner.h.

Constructor & Destructor Documentation

template<class PATObjType >

pat::PATCleaner< PATObjType >::PATCleaner ( const edm::ParameterSet & iConfig )

explicit

Definition at line 62 of file PATCleaner.h.

References qcdUeDQM_cfi::algorithm, looper::cfg, edm::ParameterSet::empty(), Exception, edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterNamesForType(), pat::PATCleaner< PATObjType >::overlapTests_, pat::PATCleaner< PATObjType >::src_, and AlCaHLTBitMon_QueryRunRegistry::string.

     : src_(iConfig.getParameter<edm::InputTag>("src")),
       srcToken_(consumes<edm::View<PATObjType>>(src_)),
       preselectionCut_(iConfig.getParameter<std::string>("preselection")),
       finalCut_(iConfig.getParameter<std::string>("finalCut")) {
   // pick parameter set for overlaps
   edm::ParameterSet overlapPSet = iConfig.getParameter<edm::ParameterSet>("checkOverlaps");
   // get all the names of the tests (all nested PSets in this PSet)
   std::vector<std::string> overlapNames = overlapPSet.getParameterNamesForType<edm::ParameterSet>();
   // loop on them
   for (std::vector<std::string>::const_iterator itn = overlapNames.begin(); itn != overlapNames.end(); ++itn) {
     // retrieve configuration
     edm::ParameterSet cfg = overlapPSet.getParameter<edm::ParameterSet>(*itn);
     // skip empty parameter sets
     if (cfg.empty())
       continue;
     // get the name of the algorithm to use
     std::string algorithm = cfg.getParameter<std::string>("algorithm");
     // create the appropriate OverlapTest
     if (algorithm == "byDeltaR") {
       overlapTests_.emplace_back(new pat::helper::BasicOverlapTest(*itn, cfg, consumesCollector()));
     } else if (algorithm == "bySuperClusterSeed") {
       overlapTests_.emplace_back(new pat::helper::OverlapBySuperClusterSeed(*itn, cfg, consumesCollector()));
     } else {
       throw cms::Exception("Configuration")
           << "PATCleaner for " << src_ << ": unsupported algorithm '" << algorithm << "'\n";
     }
   }
 
   produces<std::vector<PATObjType>>();
 }

template<class PATObjType >

pat::PATCleaner< PATObjType >::~PATCleaner ( )

inlineoverride

Definition at line 43 of file PATCleaner.h.

References iEvent, and pat::PATCleaner< PATObjType >::produce().

43 {}

Member Function Documentation

template<class PATObjType >

void pat::PATCleaner< PATObjType >::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

final

Definition at line 95 of file PATCleaner.h.

References HLT_2018_cff::candidates, pat::PATCleaner< PATObjType >::finalCut_, edm::Event::getByToken(), eostools::move(), getGTfromDQMFile::obj, convertSQLitetoXML_cfg::output, analyzePatCleaning_cfg::overlaps, pat::PATCleaner< PATObjType >::overlapTests_, pat::PATCleaner< PATObjType >::preselectionCut_, edm::Event::put(), and pat::PATCleaner< PATObjType >::srcToken_.

Referenced by pat::PATCleaner< PATObjType >::~PATCleaner().

                                                                                      {
   // Read the input. We use edm::View<> in case the input happes to be something different than a std::vector<>
   edm::Handle<edm::View<PATObjType>> candidates;
   iEvent.getByToken(srcToken_, candidates);
 
   // Prepare a collection for the output
   auto output = std::make_unique<std::vector<PATObjType>>();
 
   // initialize the overlap tests
   for (auto& itov : overlapTests_) {
     itov->readInput(iEvent, iSetup);
   }
 
   for (typename edm::View<PATObjType>::const_iterator it = candidates->begin(), ed = candidates->end(); it != ed;
        ++it) {
     // Apply a preselection to the inputs and copy them in the output
     if (!preselectionCut_(*it))
       continue;
 
     // Add it to the list and take a reference to it, so it can be modified (e.g. to set the overlaps)
     // If at some point I'll decide to drop this item, I'll use pop_back to remove it
     output->push_back(*it);
     PATObjType& obj = output->back();
 
     // Look for overlaps
     bool badForOverlap = false;
     for (auto& itov : overlapTests_) {
       reco::CandidatePtrVector overlaps;
       bool hasOverlap = itov->fillOverlapsForItem(obj, overlaps);
       if (hasOverlap && itov->requireNoOverlaps()) {
         badForOverlap = true;  // mark for discarding
         break;                 // no point in checking the others, as this item will be discarded
       }
       obj.setOverlaps(itov->name(), overlaps);
     }
     if (badForOverlap) {
       output->pop_back();
       continue;
     }
 
     // Apply one final selection cut
     if (!finalCut_(obj))
       output->pop_back();
   }
 
   iEvent.put(std::move(output));
 }