Inheritance diagram for RecoTauGenericJetRegionProducer< JetType, CandType >:

Public Types
typedef edm::AssociationMap< edm::OneToOne< reco::JetView, reco::JetView > >	JetMatchMap

typedef edm::AssociationMap< edm::OneToMany< std::vector< JetType >, std::vector< CandType >, unsigned int > >	JetToCandidateAssociation

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

Public Member Functions
template<>
void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

template<>
void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

void	produce (edm::Event &evt, const edm::EventSetup &es) override

	RecoTauGenericJetRegionProducer (const edm::ParameterSet &pset)

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

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

static void	fillDescriptionsBase (edm::ConfigurationDescriptions &descriptions, const std::string &name)

Private Attributes
double	deltaR2_

edm::InputTag	inputJets_

edm::EDGetTokenT< reco::CandidateView >	Jets_token

double	maxJetAbsEta_

double	minJetPt_

std::string	moduleLabel_

edm::EDGetTokenT< std::vector< CandType > >	pf_token

edm::EDGetTokenT< JetToCandidateAssociation >	pfCandAssocMap_token

edm::InputTag	pfCandAssocMapSrc_

edm::InputTag	pfCandSrc_

int	verbosity_

Detailed Description

template<class JetType, class CandType>
class RecoTauGenericJetRegionProducer< JetType, CandType >

Definition at line 36 of file RecoTauGenericJetRegionProducer.cc.

Member Typedef Documentation

◆ JetMatchMap

template<class JetType , class CandType >

typedef edm::AssociationMap<edm::OneToOne<reco::JetView, reco::JetView> > RecoTauGenericJetRegionProducer< JetType, CandType >::JetMatchMap

Definition at line 38 of file RecoTauGenericJetRegionProducer.cc.

◆ JetToCandidateAssociation

template<class JetType , class CandType >

typedef edm::AssociationMap<edm::OneToMany<std::vector<JetType>, std::vector<CandType>, unsigned int> > RecoTauGenericJetRegionProducer< JetType, CandType >::JetToCandidateAssociation

Definition at line 40 of file RecoTauGenericJetRegionProducer.cc.

Constructor & Destructor Documentation

◆ RecoTauGenericJetRegionProducer()

template<class JetType , class CandType >

RecoTauGenericJetRegionProducer< JetType, CandType >::RecoTauGenericJetRegionProducer ( const edm::ParameterSet & pset )

explicit

Definition at line 68 of file RecoTauGenericJetRegionProducer.cc.

     : moduleLabel_(cfg.getParameter<std::string>("@module_label")) {
   inputJets_ = cfg.getParameter<edm::InputTag>("src");
   pfCandSrc_ = cfg.getParameter<edm::InputTag>("pfCandSrc");
   pfCandAssocMapSrc_ = cfg.getParameter<edm::InputTag>("pfCandAssocMapSrc");
 
   pf_token = consumes<std::vector<CandType> >(pfCandSrc_);
   Jets_token = consumes<reco::CandidateView>(inputJets_);
   pfCandAssocMap_token = consumes<JetToCandidateAssociation>(pfCandAssocMapSrc_);
 
   double deltaR = cfg.getParameter<double>("deltaR");
   deltaR2_ = deltaR * deltaR;
   minJetPt_ = cfg.getParameter<double>("minJetPt");
   maxJetAbsEta_ = cfg.getParameter<double>("maxJetAbsEta");
 
   verbosity_ = cfg.getParameter<int>("verbosity");
 
   produces<std::vector<JetType> >("jets");
   produces<JetMatchMap>();
 }

◆ ~RecoTauGenericJetRegionProducer()

template<class JetType , class CandType >

RecoTauGenericJetRegionProducer< JetType, CandType >::~RecoTauGenericJetRegionProducer ( )

inlineoverride

Definition at line 42 of file RecoTauGenericJetRegionProducer.cc.

42 {}

Member Function Documentation

◆ fillDescriptions() [1/3]

template<class JetType , class CandType >

static void RecoTauGenericJetRegionProducer< JetType, CandType >::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

◆ fillDescriptions() [2/3]

template<>

void RecoTauGenericJetRegionProducer< reco::PFJet, reco::PFCandidate >::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

Definition at line 236 of file RecoTauGenericJetRegionProducer.cc.

References RecoTauGenericJetRegionProducer< JetType, CandType >::fillDescriptionsBase().

                                                 {
   // RecoTauGenericJetRegionProducer
   RecoTauGenericJetRegionProducer::fillDescriptionsBase(descriptions, "RecoTauJetRegionProducer");
 }

◆ fillDescriptions() [3/3]

template<>

void RecoTauGenericJetRegionProducer< pat::Jet, pat::PackedCandidate >::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

Definition at line 243 of file RecoTauGenericJetRegionProducer.cc.

References RecoTauGenericJetRegionProducer< JetType, CandType >::fillDescriptionsBase().

                                                 {
   // RecoTauGenericJetRegionProducer
   RecoTauGenericJetRegionProducer::fillDescriptionsBase(descriptions, "RecoTauPatJetRegionProducer");
 }

◆ fillDescriptionsBase()

template<class JetType , class CandType >

void RecoTauGenericJetRegionProducer< JetType, CandType >::fillDescriptionsBase	(	edm::ConfigurationDescriptions &	descriptions,
		const std::string &	name
	)

static

Definition at line 221 of file RecoTauGenericJetRegionProducer.cc.

References edm::ConfigurationDescriptions::add(), submitPVResolutionJobs::desc, ProducerED_cfi::InputTag, and mergeVDriftHistosByStation::name.

Referenced by RecoTauGenericJetRegionProducer< JetType, CandType >::fillDescriptions().

                                                                        {
   // RecoTauGenericJetRegionProducer
   edm::ParameterSetDescription desc;
   desc.add<edm::InputTag>("src", edm::InputTag("ak4PFJets"));
   desc.add<double>("deltaR", 0.8);
   desc.add<edm::InputTag>("pfCandAssocMapSrc", edm::InputTag(""));
   desc.add<int>("verbosity", 0);
   desc.add<double>("maxJetAbsEta", 2.5);
   desc.add<double>("minJetPt", 14.0);
   desc.add<edm::InputTag>("pfCandSrc", edm::InputTag("particleFlow"));
   descriptions.add(name, desc);
 }

◆ produce()

template<class JetType , class CandType >

void RecoTauGenericJetRegionProducer< JetType, CandType >::produce	(	edm::Event &	evt,
		const edm::EventSetup &	es
	)

override

Definition at line 90 of file RecoTauGenericJetRegionProducer.cc.

References funct::abs(), gather_cfg::cout, reco::deltaR2(), MillePedeFileConverter_cfg::e, edm::Event::get(), edm::Event::getByToken(), heavyIonCSV_trainingSettings::idx, edm::HandleBase::isValid(), PDWG_EXODelayedJetMET_cff::jets, edm::Ref< C, T, F >::key(), edm::makeRefToBaseProdFrom(), eostools::move(), nJets, edm::Event::put(), and groupFilesInBlocks::temp.

                                                                                                        {
   if (verbosity_) {
     std::cout << "<RecoTauJetRegionProducer::produce (moduleLabel = " << moduleLabel_ << ")>:" << std::endl;
     std::cout << " inputJets = " << inputJets_ << std::endl;
     std::cout << " pfCandSrc = " << pfCandSrc_ << std::endl;
     std::cout << " pfCandAssocMapSrc_ = " << pfCandAssocMapSrc_ << std::endl;
   }
 
   edm::Handle<std::vector<CandType> > pfCandsHandle;
   evt.getByToken(pf_token, pfCandsHandle);
 
   // Build Ptrs for all the PFCandidates
   typedef edm::Ptr<CandType> CandPtr;
   std::vector<CandPtr> pfCands;
   pfCands.reserve(pfCandsHandle->size());
   for (size_t icand = 0; icand < pfCandsHandle->size(); ++icand) {
     pfCands.push_back(CandPtr(pfCandsHandle, icand));
   }
 
   // Get the jets
   edm::Handle<reco::CandidateView> jetView;
   evt.getByToken(Jets_token, jetView);
   // Convert to a vector of JetRefs
   edm::RefVector<std::vector<JetType> > jets = reco::tau::castView<edm::RefVector<std::vector<JetType> > >(jetView);
   size_t nJets = jets.size();
 
   // Get the association map matching jets to Candidates
   // (needed for reconstruction of boosted taus)
   edm::Handle<JetToCandidateAssociation> jetToPFCandMap;
   std::vector<std::unordered_set<unsigned> > fastJetToPFCandMap;
   if (!pfCandAssocMapSrc_.label().empty()) {
     evt.getByToken(pfCandAssocMap_token, jetToPFCandMap);
     fastJetToPFCandMap.resize(nJets);
     for (size_t ijet = 0; ijet < nJets; ++ijet) {
       // Get a ref to jet
       const edm::Ref<std::vector<JetType> >& jetRef = jets[ijet];
       const auto& pfCandsMappedToJet = (*jetToPFCandMap)[jetRef];
       for (const auto& pfCandMappedToJet : pfCandsMappedToJet) {
         fastJetToPFCandMap[ijet].emplace(pfCandMappedToJet.key());
       }
     }
   }
 
   // Get the original product, so we can match against it - otherwise the
   // indices don't match up.
   edm::ProductID originalId = jets.id();
   edm::Handle<std::vector<JetType> > originalJets;
   size_t nOriginalJets = 0;
   // We have to make sure that we have some selected jets, otherwise we don't
   // actually have a valid product ID to the original jets.
   if (nJets) {
     try {
       evt.get(originalId, originalJets);
     } catch (const cms::Exception& e) {
       edm::LogError("MissingOriginalCollection") << "Can't get the original jets that made: " << inputJets_
                                                  << " that have product ID: " << originalId << " from the event!!";
       throw e;
     }
     nOriginalJets = originalJets->size();
   }
 
   auto newJets = std::make_unique<std::vector<JetType> >();
 
   // Keep track of the indices of the current jet and the old (original) jet
   // -1 indicates no match.
   std::vector<int> matchInfo(nOriginalJets, -1);
   newJets->reserve(nJets);
   size_t nNewJets = 0;
   for (size_t ijet = 0; ijet < nJets; ++ijet) {
     // Get a ref to jet
     const edm::Ref<std::vector<JetType> >& jetRef = jets[ijet];
     if (jetRef->pt() - minJetPt_ < 1e-5)
       continue;
     if (std::abs(jetRef->eta()) - maxJetAbsEta_ > -1e-5)
       continue;
     // Make an initial copy.
     newJets->emplace_back(*jetRef);
     JetType& newJet = newJets->back();
     // Clear out all the constituents
     newJet.clearDaughters();
     // Loop over all the PFCands
     for (const auto& pfCand : pfCands) {
       bool isMappedToJet = false;
       if (jetToPFCandMap.isValid()) {
         auto temp = jetToPFCandMap->find(jetRef);
         if (temp == jetToPFCandMap->end()) {
           edm::LogWarning("WeirdCandidateMap") << "Candidate map for jet " << jetRef.key() << " is empty!";
           continue;
         }
         isMappedToJet = fastJetToPFCandMap[ijet].count(pfCand.key());
       } else {
         isMappedToJet = true;
       }
       if (reco::deltaR2(*jetRef, *pfCand) < deltaR2_ && isMappedToJet)
         newJet.addDaughter(pfCand);
     }
     if (verbosity_) {
       std::cout << "jet #" << ijet << ": Pt = " << jetRef->pt() << ", eta = " << jetRef->eta()
                 << ", phi = " << jetRef->eta() << ","
                 << " mass = " << jetRef->mass() << ", area = " << jetRef->jetArea() << std::endl;
       auto jetConstituents = newJet.daughterPtrVector();
       int idx = 0;
       for (const auto& jetConstituent : jetConstituents) {
         std::cout << " constituent #" << idx << ": Pt = " << jetConstituent->pt() << ", eta = " << jetConstituent->eta()
                   << ", phi = " << jetConstituent->phi() << std::endl;
         ++idx;
       }
     }
     // Match the index of the jet we just made to the index into the original
     // collection.
     //matchInfo[jetRef.key()] = ijet;
     matchInfo[jetRef.key()] = nNewJets;
     nNewJets++;
   }
 
   // Put our new jets into the event
   edm::OrphanHandle<std::vector<JetType> > newJetsInEvent = evt.put(std::move(newJets), "jets");
 
   // Create a matching between original jets -> extra collection
   auto matching = (nJets != 0)
                       ? std::make_unique<JetMatchMap>(
                             edm::makeRefToBaseProdFrom(edm::RefToBase<reco::Jet>(jets[0]), evt), newJetsInEvent)
                       : std::make_unique<JetMatchMap>();
   for (size_t ijet = 0; ijet < nJets; ++ijet) {
     matching->insert(edm::RefToBase<reco::Jet>(jets[ijet]),
                      edm::RefToBase<reco::Jet>(edm::Ref<std::vector<JetType> >(newJetsInEvent, matchInfo[ijet])));
   }
   evt.put(std::move(matching));
 }