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	hasAbilityToProduceInLumis () const final

bool	hasAbilityToProduceInRuns () 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 39 of file RecoTauGenericJetRegionProducer.cc.

Member Typedef Documentation

template<class JetType , class CandType >

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

Definition at line 42 of file RecoTauGenericJetRegionProducer.cc.

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

Constructor & Destructor Documentation

template<class JetType , class CandType >

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

explicit

Definition at line 71 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>();
 }

template<class JetType , class CandType >

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

inlineoverride

Definition at line 45 of file RecoTauGenericJetRegionProducer.cc.

References RecoTauGenericJetRegionProducer< JetType, CandType >::fillDescriptions(), RecoTauGenericJetRegionProducer< JetType, CandType >::fillDescriptionsBase(), dataset::name, RecoTauGenericJetRegionProducer< JetType, CandType >::produce(), and AlCaHLTBitMon_QueryRunRegistry::string.

45 {}

Member Function Documentation

template<class JetType , class CandType >

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

static

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

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

template<>

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

Definition at line 244 of file RecoTauGenericJetRegionProducer.cc.

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

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

template<class JetType , class CandType >

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

static

Definition at line 220 of file RecoTauGenericJetRegionProducer.cc.

References edm::ConfigurationDescriptions::add(), and edm::ParameterSetDescription::add().

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

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

template<class JetType , class CandType >

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

override

Definition at line 94 of file RecoTauGenericJetRegionProducer.cc.

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

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