Inheritance diagram for PFRecoTauChargedHadronProducer:

Public Types
typedef reco::tau::PFRecoTauChargedHadronBuilderPlugin	Builder

typedef reco::tau::PFRecoTauChargedHadronQualityPlugin	Ranker

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 Types inherited from edm::stream::EDProducerBase
typedef EDProducerAdaptorBase	ModuleType

Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Public Member Functions
	PFRecoTauChargedHadronProducer (const edm::ParameterSet &cfg)

template<typename T >
void	print (const T &chargedHadrons)

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

	~PFRecoTauChargedHadronProducer ()

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

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

ModuleDescription const &	moduleDescription () const

virtual	~EDProducerBase ()

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

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, std::unordered_multimap< std::string, edm::ProductResolverIndex > const &iIndicies, std::string const &moduleLabel)

virtual	~ProducerBase () noexcept(false)

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

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::vector< ModuleDescription const * > &modules, 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	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

virtual	~EDConsumerBase () noexcept(false)

Private Types
typedef boost::ptr_vector< Builder >	builderList

typedef boost::ptr_list< reco::PFRecoTauChargedHadron >	ChargedHadronList

typedef reco::tau::RecoTauLexicographicalRanking< rankerList, reco::PFRecoTauChargedHadron >	ChargedHadronPredicate

typedef boost::ptr_vector< reco::PFRecoTauChargedHadron >	ChargedHadronVector

typedef boost::ptr_vector< Ranker >	rankerList

Private Attributes
builderList	builders_

edm::EDGetTokenT< reco::CandidateView >	Jets_token

double	maxJetAbsEta_

double	minJetPt_

std::string	moduleLabel_

std::auto_ptr< StringCutObjectSelector< reco::PFRecoTauChargedHadron > >	outputSelector_

std::auto_ptr< ChargedHadronPredicate >	predicate_

rankerList	rankers_

edm::InputTag	srcJets_

int	verbosity_

Additional Inherited Members
Static Public Member Functions inherited from edm::stream::EDProducerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

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

Detailed Description

Definition at line 52 of file PFRecoTauChargedHadronProducer.cc.

Member Typedef Documentation

typedef reco::tau::PFRecoTauChargedHadronBuilderPlugin PFRecoTauChargedHadronProducer::Builder

Definition at line 55 of file PFRecoTauChargedHadronProducer.cc.

typedef boost::ptr_vector<Builder> PFRecoTauChargedHadronProducer::builderList

private

Definition at line 65 of file PFRecoTauChargedHadronProducer.cc.

typedef boost::ptr_list<reco::PFRecoTauChargedHadron> PFRecoTauChargedHadronProducer::ChargedHadronList

private

Definition at line 68 of file PFRecoTauChargedHadronProducer.cc.

typedef reco::tau::RecoTauLexicographicalRanking<rankerList, reco::PFRecoTauChargedHadron> PFRecoTauChargedHadronProducer::ChargedHadronPredicate

private

Definition at line 70 of file PFRecoTauChargedHadronProducer.cc.

typedef boost::ptr_vector<reco::PFRecoTauChargedHadron> PFRecoTauChargedHadronProducer::ChargedHadronVector

private

Definition at line 67 of file PFRecoTauChargedHadronProducer.cc.

typedef reco::tau::PFRecoTauChargedHadronQualityPlugin PFRecoTauChargedHadronProducer::Ranker

Definition at line 56 of file PFRecoTauChargedHadronProducer.cc.

typedef boost::ptr_vector<Ranker> PFRecoTauChargedHadronProducer::rankerList

private

Definition at line 66 of file PFRecoTauChargedHadronProducer.cc.

Constructor & Destructor Documentation

PFRecoTauChargedHadronProducer::PFRecoTauChargedHadronProducer ( const edm::ParameterSet & cfg )

explicit

Definition at line 93 of file PFRecoTauChargedHadronProducer.cc.

References edm::ParameterSet::addParameter(), builders_, edm::EDConsumerBase::consumesCollector(), beamerCreator::create(), edm::ParameterSet::exists(), reco::get(), edm::ParameterSet::getParameter(), Jets_token, maxJetAbsEta_, minJetPt_, outputSelector_, predicate_, muonDTDigis_cfi::pset, rankers_, corrVsCorr::selection, srcJets_, AlCaHLTBitMon_QueryRunRegistry::string, and verbosity_.

   : moduleLabel_(cfg.getParameter<std::string>("@module_label"))
 {
   srcJets_ = cfg.getParameter<edm::InputTag>("jetSrc");
   Jets_token = consumes<reco::CandidateView>(srcJets_);
   minJetPt_ = ( cfg.exists("minJetPt") ) ? cfg.getParameter<double>("minJetPt") : -1.0;
   maxJetAbsEta_ = ( cfg.exists("maxJetAbsEta") ) ? cfg.getParameter<double>("maxJetAbsEta") : 99.0;
   verbosity_ = ( cfg.exists("verbosity") ) ?
     cfg.getParameter<int>("verbosity") : 0;
   
   // get set of ChargedHadron builder plugins
   edm::VParameterSet psets_builders = cfg.getParameter<edm::VParameterSet>("builders");
   for ( edm::VParameterSet::const_iterator pset = psets_builders.begin();
     pset != psets_builders.end(); ++pset ) {
     std::string pluginType = pset->getParameter<std::string>("plugin");
     edm::ParameterSet pset_modified = (*pset);
     pset_modified.addParameter<int>("verbosity", verbosity_);
     builders_.push_back(PFRecoTauChargedHadronBuilderPluginFactory::get()->create(pluginType, pset_modified, consumesCollector()));
   }
   
   // get set of plugins for ranking ChargedHadrons in quality
   edm::VParameterSet psets_rankers = cfg.getParameter<edm::VParameterSet>("ranking");
   for ( edm::VParameterSet::const_iterator pset = psets_rankers.begin();
     pset != psets_rankers.end(); ++pset ) {
     std::string pluginType = pset->getParameter<std::string>("plugin");
     edm::ParameterSet pset_modified = (*pset);
     pset_modified.addParameter<int>("verbosity", verbosity_);
     rankers_.push_back(PFRecoTauChargedHadronQualityPluginFactory::get()->create(pluginType, pset_modified));
   }
 
   // build the sorting predicate
   predicate_ = std::auto_ptr<ChargedHadronPredicate>(new ChargedHadronPredicate(rankers_));
   
   // check if we want to apply a final output selection
   if ( cfg.exists("outputSelection") ) {
     std::string selection = cfg.getParameter<std::string>("outputSelection");
     if ( selection != "" ) {
       outputSelector_.reset(new StringCutObjectSelector<reco::PFRecoTauChargedHadron>(selection));
     }
   }
 
   produces<reco::PFJetChargedHadronAssociation>();
 }

PFRecoTauChargedHadronProducer::~PFRecoTauChargedHadronProducer ( )

inline

Definition at line 59 of file PFRecoTauChargedHadronProducer.cc.

References print(), and produce().

59 {}

Member Function Documentation

template<typename T >

void PFRecoTauChargedHadronProducer::print ( const T & chargedHadrons )

Definition at line 303 of file PFRecoTauChargedHadronProducer.cc.

References muons2muons_cfi::chargedHadron, DEFINE_FWK_MODULE, rankers_, and ApeEstimator_cff::width.

Referenced by produce(), and ~PFRecoTauChargedHadronProducer().

 {
   for ( typename T::const_iterator chargedHadron = chargedHadrons.begin();
     chargedHadron != chargedHadrons.end(); ++chargedHadron ) {
     edm::LogPrint("PFRecoTauChHProducer") << (*chargedHadron);
     edm::LogPrint("PFRecoTauChHProducer") << "Rankers:" ;
     for ( rankerList::const_iterator ranker = rankers_.begin();
       ranker != rankers_.end(); ++ranker) {
       const unsigned width = 25;
       edm::LogPrint("PFRecoTauChHProducer") << " " << std::setiosflags(std::ios::left) << std::setw(width) << ranker->name()
          << " " << std::resetiosflags(std::ios::left) << std::setprecision(3) << (*ranker)(*chargedHadron) << std::endl;
     }
   }
 }

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

Definition at line 137 of file PFRecoTauChargedHadronProducer.cc.

References funct::abs(), builders_, deltaR(), PFRecoTauDiscriminationAgainstElectronDeadECAL_cfi::dR, MillePedeFileConverter_cfg::e, reco::TrackBase::eta(), cppFunctionSkipper::exception, edm::Event::get(), edm::Ptr< T >::get(), edm::Event::getByToken(), edm::RefVector< C, T, F >::id(), edm::Ptr< T >::isNonnull(), fwrapper::jets, Jets_token, edm::Ref< C, T, F >::key(), reco::PFRecoTauChargedHadron::kPFNeutralHadron, maxJetAbsEta_, minJetPt_, moduleLabel_, eostools::move(), reco::tau::RecoTauNamedPlugin::name(), outputSelector_, pfJetBenchmark_cfi::pfJets, reco::TrackBase::phi(), predicate_, print(), edm::Event::put(), mps_fire::result, reco::tau::setChargedHadronP4(), reco::tau::RecoTauEventHolderPlugin::setup(), edm::RefVector< C, T, F >::size(), HiIsolationCommonParameters_cff::track, and verbosity_.

Referenced by ~PFRecoTauChargedHadronProducer().

 {
   if ( verbosity_ ) {
     edm::LogPrint("PFRecoTauChHProducer")<< "<PFRecoTauChargedHadronProducer::produce>:" ;
     edm::LogPrint("PFRecoTauChHProducer")<< " moduleLabel = " << moduleLabel_ ;
   }
 
   // give each of our plugins a chance at doing something with the edm::Event
   BOOST_FOREACH( Builder& builder, builders_ ) {
     builder.setup(evt, es);
   }
   
   // get a view of our jets via the base candidates
   edm::Handle<reco::CandidateView> jets;
   evt.getByToken(Jets_token, jets);
   
   // convert the view to a RefVector of actual PFJets
   reco::PFJetRefVector pfJets = reco::tau::castView<reco::PFJetRefVector>(jets);
 
   // make our association
   std::unique_ptr<reco::PFJetChargedHadronAssociation> pfJetChargedHadronAssociations;
 
 
   if ( pfJets.size() ) {
     edm::Handle<reco::PFJetCollection> pfJetCollectionHandle;
     evt.get(pfJets.id(), pfJetCollectionHandle);
     pfJetChargedHadronAssociations = std::make_unique<reco::PFJetChargedHadronAssociation>(reco::PFJetRefProd(pfJetCollectionHandle));
   } else {
     pfJetChargedHadronAssociations = std::make_unique<reco::PFJetChargedHadronAssociation>();
   }
 
   // loop over our jets
   BOOST_FOREACH( const reco::PFJetRef& pfJet, pfJets ) {
     
     if(pfJet->pt() - minJetPt_ < 1e-5) continue;
     if(std::abs(pfJet->eta()) - maxJetAbsEta_ > -1e-5) continue;
 
     // build global list of ChargedHadron candidates for each jet
     ChargedHadronList uncleanedChargedHadrons;
 
     // merge candidates reconstructed by all desired algorithm plugins
     BOOST_FOREACH( const Builder& builder, builders_ ) {
       try {
         ChargedHadronVector result(builder(*pfJet));
     if ( verbosity_ ) {
       edm::LogPrint("PFRecoTauChHProducer")<< "result of builder = " << builder.name() << ":" ;
       print(result);
     }
         uncleanedChargedHadrons.transfer(uncleanedChargedHadrons.end(), result);
       } catch ( cms::Exception& exception ) {
         edm::LogError("BuilderPluginException")
             << "Exception caught in builder plugin " << builder.name()
             << ", rethrowing" << std::endl;
         throw exception;
       }
     }
 
     // rank the candidates according to our quality plugins
     uncleanedChargedHadrons.sort(*predicate_);
 
     // define collection of cleaned ChargedHadrons;
     std::vector<reco::PFRecoTauChargedHadron> cleanedChargedHadrons;
 
     // keep track of neutral PFCandidates, charged PFCandidates and tracks "used" by ChargedHadron candidates in the clean collection
     typedef std::pair<double, double> etaPhiPair;
     std::list<etaPhiPair> tracksInCleanCollection;
     std::set<reco::PFCandidatePtr> neutralPFCandsInCleanCollection;
 
     while ( uncleanedChargedHadrons.size() >= 1 ) {
       
       // get next best ChargedHadron candidate
       std::auto_ptr<reco::PFRecoTauChargedHadron> nextChargedHadron(uncleanedChargedHadrons.pop_front().release());
       if ( verbosity_ ) {
     edm::LogPrint("PFRecoTauChHProducer")<< "processing nextChargedHadron:" ;
     edm::LogPrint("PFRecoTauChHProducer")<< (*nextChargedHadron);
       }
 
       // discard candidates which fail final output selection
       if ( !(*outputSelector_)(*nextChargedHadron) ) continue;
 
       const reco::Track* track = 0;
       if ( nextChargedHadron->getChargedPFCandidate().isNonnull() ) {
     const reco::PFCandidatePtr& chargedPFCand = nextChargedHadron->getChargedPFCandidate();
     if ( chargedPFCand->trackRef().isNonnull() ) track = chargedPFCand->trackRef().get();
     else if ( chargedPFCand->muonRef().isNonnull() && chargedPFCand->muonRef()->innerTrack().isNonnull()  ) track = chargedPFCand->muonRef()->innerTrack().get();
     else if ( chargedPFCand->muonRef().isNonnull() && chargedPFCand->muonRef()->globalTrack().isNonnull() ) track = chargedPFCand->muonRef()->globalTrack().get();
     else if ( chargedPFCand->muonRef().isNonnull() && chargedPFCand->muonRef()->outerTrack().isNonnull()  ) track = chargedPFCand->muonRef()->outerTrack().get();
     else if ( chargedPFCand->gsfTrackRef().isNonnull() ) track = chargedPFCand->gsfTrackRef().get();
       } 
       if ( nextChargedHadron->getTrack().isNonnull() && !track ) {
     track = nextChargedHadron->getTrack().get();
       }
 
       // discard candidate in case its track is "used" by any ChargedHadron in the clean collection
       bool isTrack_overlap = false;
       if ( track ) {
     double track_eta = track->eta();
     double track_phi = track->phi();
     for ( std::list<etaPhiPair>::const_iterator trackInCleanCollection = tracksInCleanCollection.begin();
           trackInCleanCollection != tracksInCleanCollection.end(); ++trackInCleanCollection ) {
       double dR = deltaR(track_eta, track_phi, trackInCleanCollection->first, trackInCleanCollection->second);
       if ( dR < 1.e-4 ) isTrack_overlap = true;
     }
       }
       if ( verbosity_ ) {
     edm::LogPrint("PFRecoTauChHProducer")<< "isTrack_overlap = " << isTrack_overlap ;
       }
       if ( isTrack_overlap ) continue;
 
       // discard ChargedHadron candidates without track in case they are close to neutral PFCandidates "used" by ChargedHadron candidates in the clean collection
       bool isNeutralPFCand_overlap = false;
       if ( nextChargedHadron->algoIs(reco::PFRecoTauChargedHadron::kPFNeutralHadron) ) {
     for ( std::set<reco::PFCandidatePtr>::const_iterator neutralPFCandInCleanCollection = neutralPFCandsInCleanCollection.begin();
           neutralPFCandInCleanCollection != neutralPFCandsInCleanCollection.end(); ++neutralPFCandInCleanCollection ) {
       if ( (*neutralPFCandInCleanCollection) == nextChargedHadron->getChargedPFCandidate() ) isNeutralPFCand_overlap = true;
     }
       }
       if ( verbosity_ ) {
     edm::LogPrint("PFRecoTauChHProducer")<< "isNeutralPFCand_overlap = " << isNeutralPFCand_overlap ;
       }
       if ( isNeutralPFCand_overlap ) continue;
       
       // find neutral PFCandidates that are not "used" by any ChargedHadron in the clean collection
       std::vector<reco::PFCandidatePtr> uniqueNeutralPFCands;
       std::set_difference(nextChargedHadron->getNeutralPFCandidates().begin(),
               nextChargedHadron->getNeutralPFCandidates().end(),
               neutralPFCandsInCleanCollection.begin(),
               neutralPFCandsInCleanCollection.end(),
               std::back_inserter(uniqueNeutralPFCands));
       
       if ( uniqueNeutralPFCands.size() == nextChargedHadron->getNeutralPFCandidates().size() ) { // all neutral PFCandidates are unique, add ChargedHadron candidate to clean collection
     if ( track ) tracksInCleanCollection.push_back(std::make_pair(track->eta(), track->phi()));
     neutralPFCandsInCleanCollection.insert(nextChargedHadron->getNeutralPFCandidates().begin(), nextChargedHadron->getNeutralPFCandidates().end());
     if ( verbosity_ ) {
       edm::LogPrint("PFRecoTauChHProducer")<< "--> adding nextChargedHadron to output collection." ;
     }
     cleanedChargedHadrons.push_back(*nextChargedHadron);
       } else { // remove overlapping neutral PFCandidates, reevaluate ranking criterion and process ChargedHadron candidate again
     nextChargedHadron->neutralPFCandidates_.clear();
     BOOST_FOREACH( const reco::PFCandidatePtr& neutralPFCand, uniqueNeutralPFCands ) {
           nextChargedHadron->neutralPFCandidates_.push_back(neutralPFCand);
         }
     // update ChargedHadron four-momentum
     reco::tau::setChargedHadronP4(*nextChargedHadron);
     // reinsert ChargedHadron candidate into list of uncleaned candidates,
     // at position according to new rank
     ChargedHadronList::iterator insertionPoint = std::lower_bound(uncleanedChargedHadrons.begin(), uncleanedChargedHadrons.end(), *nextChargedHadron, *predicate_);
     if ( verbosity_ ) {
       edm::LogPrint("PFRecoTauChHProducer")<< "--> removing non-unique neutral PFCandidates and reinserting nextChargedHadron in uncleaned collection." ;
     }
         uncleanedChargedHadrons.insert(insertionPoint, nextChargedHadron);
       }
     }
 
     if ( verbosity_ ) {
       print(cleanedChargedHadrons);
     }
 
     // add ChargedHadron-to-jet association
     pfJetChargedHadronAssociations->setValue(pfJet.key(), cleanedChargedHadrons);
   }
 
   evt.put(std::move(pfJetChargedHadronAssociations));
 }