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

	RecoTauProducer (const edm::ParameterSet &pset)

	~RecoTauProducer ()

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)

	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

virtual	~ProducerBase ()

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

	EDConsumerBase ()

ProductHolderIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

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_

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 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 HLT_25ns14e33_v1_cff::builders, builders_, buildNullTaus_, chargedHadron_token, chargedHadronSrc_, edm::EDConsumerBase::consumesCollector(), SurfaceDeformationFactory::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, and AlCaHLTBitMon_QueryRunRegistry::string.

 {
   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 = 0;
     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 ( )

inline

Definition at line 54 of file RecoTauProducer.cc.

54 {}

Member Function Documentation

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

overridevirtual

Implements edm::stream::EDProducerBase.

Definition at line 130 of file RecoTauProducer.cc.

References builders_, buildNullTaus_, chargedHadron_token, alignCSCRings::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_, convertSQLitetoXML_cfg::output, outputSelector_, piZero_token, edm::Event::put(), reco::PFTau::setjetRef(), edm::RefVector< C, T, F >::size(), python.multivaluedict::sort(), and metsig::tau.

 {
   // 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
   std::auto_ptr<reco::PFTauCollection> output(new 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(fabs(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(output);
 }