Inheritance diagram for RecoTauProducer:

Public Types
typedef reco::tau::RecoTauBuilderPlugin	Builder

typedef boost::ptr_vector< Builder >	BuilderList

typedef reco::tau::RecoTauModifierPlugin	Modifier

typedef boost::ptr_vector< Modifier >	ModifierList

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
void	produce (edm::Event &evt, const edm::EventSetup &es) override

	RecoTauProducer (const edm::ParameterSet &pset)

	~RecoTauProducer () override

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

bool	hasAbilityToProduceInLumis () const final

bool	hasAbilityToProduceInRuns () const final

Private Attributes
BuilderList	builders_

bool	buildNullTaus_

edm::EDGetTokenT< reco::PFJetChargedHadronAssociation >	chargedHadron_token

edm::InputTag	chargedHadronSrc_

edm::EDGetTokenT< reco::CandidateView >	jet_token

edm::EDGetTokenT< edm::Association< reco::PFJetCollection > >	jetRegion_token

edm::InputTag	jetRegionSrc_

edm::InputTag	jetSrc_

double	maxJetAbsEta_

double	minJetPt_

ModifierList	modifiers_

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

edm::EDGetTokenT< reco::JetPiZeroAssociation >	piZero_token

edm::InputTag	piZeroSrc_

Detailed Description

Definition at line 45 of file RecoTauProducer.cc.

Member Typedef Documentation

typedef reco::tau::RecoTauBuilderPlugin RecoTauProducer::Builder

Definition at line 48 of file RecoTauProducer.cc.

typedef boost::ptr_vector<Builder> RecoTauProducer::BuilderList

Definition at line 50 of file RecoTauProducer.cc.

typedef reco::tau::RecoTauModifierPlugin RecoTauProducer::Modifier

Definition at line 49 of file RecoTauProducer.cc.

typedef boost::ptr_vector<Modifier> RecoTauProducer::ModifierList

Definition at line 51 of file RecoTauProducer.cc.

Constructor & Destructor Documentation

RecoTauProducer::RecoTauProducer ( const edm::ParameterSet & pset )

explicit

Definition at line 81 of file RecoTauProducer.cc.

References PFRecoTauChargedHadronProducer_cfi::builders, builders_, buildNullTaus_, chargedHadron_token, chargedHadronSrc_, beamerCreator::create(), edm::ParameterSet::exists(), reco::get(), edm::ParameterSet::getParameter(), jet_token, jetRegion_token, jetRegionSrc_, jetSrc_, maxJetAbsEta_, minJetPt_, modifiers_, outputSelector_, piZero_token, piZeroSrc_, fwrapper::plugin, corrVsCorr::selection, AlCaHLTBitMon_QueryRunRegistry::string, and HistogramManager_cfi::VPSet().

 {
   jetSrc_ = pset.getParameter<edm::InputTag>("jetSrc");
   jetRegionSrc_ = pset.getParameter<edm::InputTag>("jetRegionSrc");
   chargedHadronSrc_ = pset.getParameter<edm::InputTag>("chargedHadronSrc");
   piZeroSrc_ = pset.getParameter<edm::InputTag>("piZeroSrc");
   
   minJetPt_ = ( pset.exists("minJetPt") ) ? pset.getParameter<double>("minJetPt") : -1.0;
   maxJetAbsEta_ = ( pset.exists("maxJetAbsEta") ) ? pset.getParameter<double>("maxJetAbsEta") : 99.0;
   //consumes definition
   jet_token=consumes<reco::CandidateView>(jetSrc_);
   jetRegion_token = consumes<edm::Association<reco::PFJetCollection> >(jetRegionSrc_);
   chargedHadron_token = consumes<reco::PFJetChargedHadronAssociation>(chargedHadronSrc_); 
   piZero_token = consumes<reco::JetPiZeroAssociation>(piZeroSrc_);
 
   typedef std::vector<edm::ParameterSet> VPSet;
   // Get each of our tau builders
   const VPSet& builders = pset.getParameter<VPSet>("builders");
   for ( VPSet::const_iterator builderPSet = builders.begin();
     builderPSet != builders.end(); ++builderPSet ) {
     // Get plugin name
     const std::string& pluginType = builderPSet->getParameter<std::string>("plugin");
     // Build the plugin
     builders_.push_back(RecoTauBuilderPluginFactory::get()->create(pluginType, *builderPSet, consumesCollector()));
   }
 
   const VPSet& modfiers = pset.getParameter<VPSet>("modifiers");
   for ( VPSet::const_iterator modfierPSet = modfiers.begin();
     modfierPSet != modfiers.end(); ++modfierPSet) {
     // Get plugin name
     const std::string& pluginType = modfierPSet->getParameter<std::string>("plugin");
     // Build the plugin
     reco::tau::RecoTauModifierPlugin* plugin = nullptr;
     plugin = RecoTauModifierPluginFactory::get()->create(pluginType, *modfierPSet, consumesCollector());
     modifiers_.push_back(plugin);
   }
 
   // Check if we want to apply a final output selection
   if ( pset.exists("outputSelection") ) {
     std::string selection = pset.getParameter<std::string>("outputSelection");
     if ( selection != "" ) {
       outputSelector_.reset(new StringCutObjectSelector<reco::PFTau>(selection));
     }
   }
   buildNullTaus_ = pset.getParameter<bool>("buildNullTaus");
 
   produces<reco::PFTauCollection>();
 }

RecoTauProducer::~RecoTauProducer ( )

inlineoverride

Definition at line 54 of file RecoTauProducer.cc.

References produce().

54 {}

Member Function Documentation

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

override

Definition at line 130 of file RecoTauProducer.cc.

References funct::abs(), builders_, buildNullTaus_, chargedHadron_token, DEFINE_FWK_MODULE, MillePedeFileConverter_cfg::e, Exception, edm::Event::getByToken(), edm::Ref< C, T, F >::id(), edm::Ref< C, T, F >::isNull(), jet_token, jetRegion_token, fwrapper::jets, maxJetAbsEta_, minJetPt_, modifiers_, eostools::move(), convertSQLitetoXML_cfg::output, outputSelector_, piZero_token, edm::Event::put(), reco::PFTau::setjetRef(), edm::RefVector< C, T, F >::size(), metsig::tau, and nano_cff::taus.

Referenced by ~RecoTauProducer().

 {
   // Get the jet input collection via a view of Candidates
   edm::Handle<reco::CandidateView> jetView;
   evt.getByToken(jet_token, jetView);
   
   // Convert to a vector of PFJetRefs
   reco::PFJetRefVector jets = reco::tau::castView<reco::PFJetRefVector>(jetView);
   
   // Get the jet region producer
   edm::Handle<edm::Association<reco::PFJetCollection> > jetRegionHandle;
   evt.getByToken(jetRegion_token, jetRegionHandle);
   
   // Get the charged hadron input collection
   edm::Handle<reco::PFJetChargedHadronAssociation> chargedHadronAssoc;
   evt.getByToken(chargedHadron_token, chargedHadronAssoc);
 
   // Get the pizero input collection
   edm::Handle<reco::JetPiZeroAssociation> piZeroAssoc;
   evt.getByToken(piZero_token, piZeroAssoc);
 
   // Update all our builders and modifiers with the event info
   for (BuilderList::iterator builder = builders_.begin();
       builder != builders_.end(); ++builder) {
     builder->setup(evt, es);
   }
   for (ModifierList::iterator modifier = modifiers_.begin();
       modifier != modifiers_.end(); ++modifier) {
     modifier->setup(evt, es);
   }
 
   // Create output collection
   auto output = std::make_unique<reco::PFTauCollection>();
   output->reserve(jets.size());
   
   // Loop over the jets and build the taus for each jet
   BOOST_FOREACH( reco::PFJetRef jetRef, jets ) {
     // Get the jet with extra constituents from an area around the jet
     if(jetRef->pt() - minJetPt_ < 1e-5) continue;
     if(std::abs(jetRef->eta()) - maxJetAbsEta_ > -1e-5) continue;
     reco::PFJetRef jetRegionRef = (*jetRegionHandle)[jetRef];
     if ( jetRegionRef.isNull() ) {
       throw cms::Exception("BadJetRegionRef") 
     << "No jet region can be found for the current jet: " << jetRef.id();
     }
     // Remove all the jet constituents from the jet extras
     std::vector<reco::PFCandidatePtr> jetCands = jetRef->getPFConstituents();
     std::vector<reco::PFCandidatePtr> allRegionalCands = jetRegionRef->getPFConstituents();
     // Sort both by ref key
     std::sort(jetCands.begin(), jetCands.end());
     std::sort(allRegionalCands.begin(), allRegionalCands.end());
     // Get the regional junk candidates not in the jet.
     std::vector<reco::PFCandidatePtr> uniqueRegionalCands;
 
     // This can actually be less than zero, if the jet has really crazy soft
     // stuff really far away from the jet axis.
     if ( allRegionalCands.size() > jetCands.size() ) {
       uniqueRegionalCands.reserve(allRegionalCands.size() - jetCands.size());
     }
 
     // Subtract the jet cands from the regional cands
     std::set_difference(allRegionalCands.begin(), allRegionalCands.end(),
             jetCands.begin(), jetCands.end(),
             std::back_inserter(uniqueRegionalCands));
 
     // Get the charged hadrons associated with this jet
     const std::vector<reco::PFRecoTauChargedHadron>& chargedHadrons = (*chargedHadronAssoc)[jetRef];
 
     // Get the pizeros associated with this jet
     const std::vector<reco::RecoTauPiZero>& piZeros = (*piZeroAssoc)[jetRef];
     // Loop over our builders and create the set of taus for this jet
     unsigned int nTausBuilt = 0;
     for ( BuilderList::const_iterator builder = builders_.begin();
       builder != builders_.end(); ++builder) {
       // Get a ptr_vector of taus from the builder
       reco::tau::RecoTauBuilderPlugin::output_type taus((*builder)(jetRef, chargedHadrons, piZeros, uniqueRegionalCands));
       // Make sure all taus have their jetref set correctly
       std::for_each(taus.begin(), taus.end(), boost::bind(&reco::PFTau::setjetRef, _1, jetRef));
       // Copy without selection
       if ( !outputSelector_.get() ) {
         output->insert(output->end(), taus.begin(), taus.end());
         nTausBuilt += taus.size();
       } else {
         // Copy only those that pass the selection.
         BOOST_FOREACH( const reco::PFTau& tau, taus ) {
           if ( (*outputSelector_)(tau) ) {
             nTausBuilt++;
             output->push_back(tau);
           }
         }
       }
     }
     // If we didn't build *any* taus for this jet, build a null tau if desired.
     // The null PFTau has no content, but it's four vector is set to that of the
     // jet.
     if ( !nTausBuilt && buildNullTaus_ ) {
       reco::PFTau nullTau(std::numeric_limits<int>::quiet_NaN(), jetRef->p4());
       nullTau.setjetRef(jetRef);
       output->push_back(nullTau);
     }
   }
 
   // Loop over the taus we have created and apply our modifiers to the taus
   for ( reco::PFTauCollection::iterator tau = output->begin();
     tau != output->end(); ++tau ) {
     for ( ModifierList::const_iterator modifier = modifiers_.begin();
       modifier != modifiers_.end(); ++modifier ) {
       (*modifier)(*tau);
     }
   }
   
   for ( ModifierList::iterator modifier = modifiers_.begin();
         modifier != modifiers_.end(); ++modifier ) {
     modifier->endEvent();
   }
   
   evt.put(std::move(output));
 }