Inheritance diagram for pat::PATJetSelector:

Public Member Functions
virtual void	beginJob ()

virtual void	endJob ()

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

	PATJetSelector (edm::ParameterSet const &params)

	~PATJetSelector () override

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

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

Public Member Functions inherited from edm::stream::EDFilterBase
	EDFilterBase ()

	EDFilterBase (const EDFilterBase &)=delete

ModuleDescription const &	moduleDescription () const

const EDFilterBase &	operator= (const EDFilterBase &)=delete

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

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::stream::EDFilterBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Protected Attributes
const std::string	cut_

const std::string	cutLoose_

const bool	filter_

const unsigned	nLoose_

const StringCutObjectSelector < Jet >	selector_

const StringCutObjectSelector < Jet >	selectorLoose_

const edm::EDGetTokenT < edm::View< pat::Jet > >	srcToken_

Additional Inherited Members
Public Types inherited from edm::stream::EDFilter<>
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

Public Types inherited from edm::stream::EDFilterBase
typedef EDFilterAdaptorBase	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
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 () noexcept

template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag) noexcept

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

Definition at line 24 of file PATObjectSelector.cc.

Constructor & Destructor Documentation

pat::PATJetSelector::PATJetSelector ( edm::ParameterSet const & params )

inline

Definition at line 26 of file PATObjectSelector.cc.

         : srcToken_(consumes<edm::View<pat::Jet>>(params.getParameter<edm::InputTag>("src"))),
           cut_(params.getParameter<std::string>("cut")),
           cutLoose_(params.getParameter<std::string>("cutLoose")),
           filter_(params.exists("filter") ? params.getParameter<bool>("filter") : false),
           nLoose_(params.getParameter<unsigned>("nLoose")),
           selector_(cut_),
           selectorLoose_(cutLoose_) {
       produces<std::vector<pat::Jet>>();
       produces<reco::GenJetCollection>("genJets");
       produces<std::vector<CaloTower>>("caloTowers");
       produces<reco::PFCandidateCollection>("pfCandidates");
       produces<edm::OwnVector<reco::BaseTagInfo>>("tagInfos");
     }

pat::PATJetSelector::~PATJetSelector ( )

inlineoverride

Definition at line 41 of file PATObjectSelector.cc.

41 {}

Member Function Documentation

virtual void pat::PATJetSelector::beginJob ( void )

inlinevirtual

Definition at line 43 of file PATObjectSelector.cc.

43 {}

virtual void pat::PATJetSelector::endJob ( void )

inlinevirtual

Definition at line 44 of file PATObjectSelector.cc.

44 {}

static void pat::PATJetSelector::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

inlinestatic

Definition at line 206 of file PATObjectSelector.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), HLT_FULL_cff::InputTag, edm::ParameterSetDescription::setComment(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                              {
       edm::ParameterSetDescription iDesc;
       iDesc.setComment("Energy Correlation Functions adder");
       iDesc.add<edm::InputTag>("src", edm::InputTag("no default"))->setComment("input collection");
       iDesc.add<std::string>("cut", "")->setComment("Jet selection.");
       iDesc.add<std::string>("cutLoose", "")->setComment("Loose jet selection. Will keep nLoose loose jets.");
       iDesc.add<bool>("filter", false)->setComment("Filter selection?");
       iDesc.add<unsigned>("nLoose", 0)->setComment("Keep nLoose loose jets that satisfy cutLoose");
       descriptions.add("PATJetSelector", iDesc);
     }

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

inlineoverridevirtual

Implements edm::stream::EDFilterBase.

Definition at line 46 of file PATObjectSelector.cc.

References edm::OwnVector< T, P >::begin(), edm::OwnVector< T, P >::end(), filter_, edm::Event::getByToken(), edm::Event::getRefBeforePut(), eostools::move(), nLoose_, jetProducer_cfi::patJets, edm::Event::put(), selector_, selectorLoose_, and srcToken_.

                                                                         {
       auto patJets = std::make_unique<std::vector<Jet>>();
 
       auto genJetsOut = std::make_unique<reco::GenJetCollection>();
       auto caloTowersOut = std::make_unique<std::vector<CaloTower>>();
       auto pfCandidatesOut = std::make_unique<reco::PFCandidateCollection>();
       auto tagInfosOut = std::make_unique<edm::OwnVector<reco::BaseTagInfo>>();
 
       edm::RefProd<reco::GenJetCollection> h_genJetsOut = iEvent.getRefBeforePut<reco::GenJetCollection>("genJets");
       edm::RefProd<std::vector<CaloTower>> h_caloTowersOut =
           iEvent.getRefBeforePut<std::vector<CaloTower>>("caloTowers");
       edm::RefProd<reco::PFCandidateCollection> h_pfCandidatesOut =
           iEvent.getRefBeforePut<reco::PFCandidateCollection>("pfCandidates");
       edm::RefProd<edm::OwnVector<reco::BaseTagInfo>> h_tagInfosOut =
           iEvent.getRefBeforePut<edm::OwnVector<reco::BaseTagInfo>>("tagInfos");
 
       edm::Handle<edm::View<pat::Jet>> h_jets;
       iEvent.getByToken(srcToken_, h_jets);
 
       unsigned nl = 0;  // number of loose jets
       // First loop over the products and make the secondary output collections
       for (edm::View<pat::Jet>::const_iterator ibegin = h_jets->begin(), iend = h_jets->end(), ijet = ibegin;
            ijet != iend;
            ++ijet) {
         bool selectedLoose = false;
         if (nLoose_ > 0 && nl < nLoose_ && selectorLoose_(*ijet)) {
           selectedLoose = true;
           ++nl;
         }
 
         if (selector_(*ijet) || selectedLoose) {
           // Copy over the calo towers
           for (CaloTowerFwdPtrVector::const_iterator itowerBegin = ijet->caloTowersFwdPtr().begin(),
                                                      itowerEnd = ijet->caloTowersFwdPtr().end(),
                                                      itower = itowerBegin;
                itower != itowerEnd;
                ++itower) {
             // Add to global calo tower list
             caloTowersOut->push_back(**itower);
           }
 
           // Copy over the pf candidates
           for (reco::PFCandidateFwdPtrVector::const_iterator icandBegin = ijet->pfCandidatesFwdPtr().begin(),
                                                              icandEnd = ijet->pfCandidatesFwdPtr().end(),
                                                              icand = icandBegin;
                icand != icandEnd;
                ++icand) {
             // Add to global pf candidate list
             pfCandidatesOut->push_back(**icand);
           }
 
           // Copy the tag infos
           for (TagInfoFwdPtrCollection::const_iterator iinfoBegin = ijet->tagInfosFwdPtr().begin(),
                                                        iinfoEnd = ijet->tagInfosFwdPtr().end(),
                                                        iinfo = iinfoBegin;
                iinfo != iinfoEnd;
                ++iinfo) {
             // Add to global calo tower list
             tagInfosOut->push_back(**iinfo);
           }
 
           // Copy the gen jet
           if (ijet->genJet() != nullptr) {
             genJetsOut->push_back(*(ijet->genJet()));
           }
         }
       }
 
       // Output the secondary collections.
       edm::OrphanHandle<reco::GenJetCollection> oh_genJetsOut = iEvent.put(std::move(genJetsOut), "genJets");
       edm::OrphanHandle<std::vector<CaloTower>> oh_caloTowersOut = iEvent.put(std::move(caloTowersOut), "caloTowers");
       edm::OrphanHandle<reco::PFCandidateCollection> oh_pfCandidatesOut =
           iEvent.put(std::move(pfCandidatesOut), "pfCandidates");
       edm::OrphanHandle<edm::OwnVector<reco::BaseTagInfo>> oh_tagInfosOut =
           iEvent.put(std::move(tagInfosOut), "tagInfos");
 
       unsigned int caloTowerIndex = 0;
       unsigned int pfCandidateIndex = 0;
       unsigned int tagInfoIndex = 0;
       unsigned int genJetIndex = 0;
       // Now set the Ptrs with the orphan handles.
       nl = 0;  // Reset number of loose jets
       for (edm::View<pat::Jet>::const_iterator ibegin = h_jets->begin(), iend = h_jets->end(), ijet = ibegin;
            ijet != iend;
            ++ijet) {
         bool selectedLoose = false;
         if (nLoose_ > 0 && nl < nLoose_ && selectorLoose_(*ijet)) {
           selectedLoose = true;
           ++nl;
         }
 
         if (selector_(*ijet) || selectedLoose) {
           // Add the jets that pass to the output collection
           patJets->push_back(*ijet);
 
           // Copy over the calo towers
           for (CaloTowerFwdPtrVector::const_iterator itowerBegin = ijet->caloTowersFwdPtr().begin(),
                                                      itowerEnd = ijet->caloTowersFwdPtr().end(),
                                                      itower = itowerBegin;
                itower != itowerEnd;
                ++itower) {
             // Update the "forward" bit of the FwdPtr to point at the new tower collection.
 
             //  ptr to "this" tower in the global list
             edm::Ptr<CaloTower> outPtr(oh_caloTowersOut, caloTowerIndex);
             patJets->back().updateFwdCaloTowerFwdPtr(itower - itowerBegin,  // index of "this" tower in the jet
                                                      outPtr);
             ++caloTowerIndex;
           }
 
           // Copy over the pf candidates
           for (reco::PFCandidateFwdPtrVector::const_iterator icandBegin = ijet->pfCandidatesFwdPtr().begin(),
                                                              icandEnd = ijet->pfCandidatesFwdPtr().end(),
                                                              icand = icandBegin;
                icand != icandEnd;
                ++icand) {
             // Update the "forward" bit of the FwdPtr to point at the new tower collection.
 
             // ptr to "this" cand in the global list
             edm::Ptr<reco::PFCandidate> outPtr(oh_pfCandidatesOut, pfCandidateIndex);
             patJets->back().updateFwdPFCandidateFwdPtr(icand - icandBegin,  // index of "this" tower in the jet
                                                        outPtr);
             ++pfCandidateIndex;
           }
 
           // Copy the tag infos
           for (TagInfoFwdPtrCollection::const_iterator iinfoBegin = ijet->tagInfosFwdPtr().begin(),
                                                        iinfoEnd = ijet->tagInfosFwdPtr().end(),
                                                        iinfo = iinfoBegin;
                iinfo != iinfoEnd;
                ++iinfo) {
             // Update the "forward" bit of the FwdPtr to point at the new tower collection.
 
             // ptr to "this" info in the global list
             edm::Ptr<reco::BaseTagInfo> outPtr(oh_tagInfosOut, tagInfoIndex);
             patJets->back().updateFwdTagInfoFwdPtr(iinfo - iinfoBegin,  // index of "this" tower in the jet
                                                    outPtr);
             ++tagInfoIndex;
           }
 
           // Copy the gen jet
           if (ijet->genJet() != nullptr) {
             patJets->back().updateFwdGenJetFwdRef(
                 edm::Ref<reco::GenJetCollection>(oh_genJetsOut, genJetIndex)  // ref to "this" genjet in the global list
             );
             ++genJetIndex;
           }
         }
       }
 
       // put genEvt  in Event
       bool pass = !patJets->empty();
       iEvent.put(std::move(patJets));
 
       if (filter_)
         return pass;
       else
         return true;
     }

Member Data Documentation

const std::string pat::PATJetSelector::cut_

protected

Definition at line 219 of file PATObjectSelector.cc.

const std::string pat::PATJetSelector::cutLoose_

protected

Definition at line 220 of file PATObjectSelector.cc.

const bool pat::PATJetSelector::filter_

protected

Definition at line 221 of file PATObjectSelector.cc.

Referenced by filter().

const unsigned pat::PATJetSelector::nLoose_

protected

Definition at line 222 of file PATObjectSelector.cc.

Referenced by filter().

const StringCutObjectSelector<Jet> pat::PATJetSelector::selector_

protected

Definition at line 223 of file PATObjectSelector.cc.

Referenced by filter().

const StringCutObjectSelector<Jet> pat::PATJetSelector::selectorLoose_

protected

Definition at line 224 of file PATObjectSelector.cc.

Referenced by filter().

const edm::EDGetTokenT<edm::View<pat::Jet> > pat::PATJetSelector::srcToken_

protected

Definition at line 218 of file PATObjectSelector.cc.

Referenced by filter().

Public Member Functions

Static Public Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation