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

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

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

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 37 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 39 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 41 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 69 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 43 of file RecoTauGenericJetRegionProducer.cc.

43 {}

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 237 of file RecoTauGenericJetRegionProducer.cc.

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

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

◆ fillDescriptions() [3/3]

template<>

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

Definition at line 244 of file RecoTauGenericJetRegionProducer.cc.

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

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

◆ fillDescriptionsBase()

template<class JetType , class CandType >

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

static

Definition at line 222 of file RecoTauGenericJetRegionProducer.cc.

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

References edm::ConfigurationDescriptions::add(), submitPVResolutionJobs::desc, HLT_FULL_cff::InputTag, and Skims_PA_cff::name.

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

◆ produce()

template<class JetType , class CandType >

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

override

Definition at line 91 of file RecoTauGenericJetRegionProducer.cc.

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