pat::PATCleaner< PATObjType > Class Template Reference

PAT Cleaner module for PAT Objects. More...

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
	EDProducer (const EDProducer &)=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 EDProducer &	operator= (const EDProducer &)=delete

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<>
using	CacheTypes = CacheContexts< T... >
using	GlobalCache = typename CacheTypes::GlobalCache
using	HasAbility = AbilityChecker< T... >
using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache
using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache
using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >
using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache
using	RunCache = typename CacheTypes::RunCache
using	RunContext = RunContextT< RunCache, GlobalCache >
using	RunSummaryCache = typename CacheTypes::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 33 of file PATCleaner.cc.

Member Typedef Documentation

OverlapTest

template<class PATObjType >

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

private

Definition at line 48 of file PATCleaner.cc.

Selector

template<class PATObjType >

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

private

Definition at line 41 of file PATCleaner.cc.

Constructor & Destructor Documentation

PATCleaner()

template<class PATObjType >

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

explicit

Definition at line 55 of file PATCleaner.cc.

References qcdUeDQM_cfi::algorithm, looper::cfg, 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>>();
}

~PATCleaner()

template<class PATObjType >

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

inlineoverride

Definition at line 36 of file PATCleaner.cc.

{}

Member Function Documentation

produce()

template<class PATObjType >

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

final

Definition at line 88 of file PATCleaner.cc.

References HLT_2024v11_cff::candidates, iEvent, ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, eostools::move(), getGTfromDQMFile::obj, and analyzePatCleaning_cfg::overlaps.

                                                                                     {
  // 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));
}

Member Data Documentation

finalCut_

template<class PATObjType >

const Selector pat::PATCleaner< PATObjType >::finalCut_

private

Definition at line 46 of file PATCleaner.cc.

overlapTests_

template<class PATObjType >

std::vector<std::unique_ptr<OverlapTest> > pat::PATCleaner< PATObjType >::overlapTests_

private

Definition at line 49 of file PATCleaner.cc.

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

preselectionCut_

template<class PATObjType >

const Selector pat::PATCleaner< PATObjType >::preselectionCut_

private

Definition at line 45 of file PATCleaner.cc.

src_

template<class PATObjType >

const edm::InputTag pat::PATCleaner< PATObjType >::src_

private

Definition at line 43 of file PATCleaner.cc.

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

srcToken_

template<class PATObjType >

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

private

Definition at line 44 of file PATCleaner.cc.