Inheritance diagram for RecoTauProducer:

Public Types
typedef reco::tau::RecoTauBuilderPlugin	Builder

typedef std::vector< std::unique_ptr< Builder > >	BuilderList

typedef reco::tau::RecoTauModifierPlugin	Modifier

typedef std::vector< std::unique_ptr< 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	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)

Private Attributes
BuilderList	builders_

bool	buildNullTaus_

edm::EDGetTokenT< reco::PFJetChargedHadronAssociation >	chargedHadron_token

edm::InputTag	chargedHadronSrc_

edm::EDGetTokenT< reco::JetView >	jet_token

edm::EDGetTokenT< edm::AssociationMap< edm::OneToOne< reco::JetView, reco::JetView > > >	jetRegion_token

edm::InputTag	jetRegionSrc_

edm::InputTag	jetSrc_

double	maxJetAbsEta_

double	minJetPt_

ModifierList	modifiers_

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

edm::EDGetTokenT< reco::JetPiZeroAssociation >	piZero_token

edm::InputTag	piZeroSrc_

Detailed Description

Definition at line 46 of file RecoTauProducer.cc.

Member Typedef Documentation

◆ Builder

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

Definition at line 48 of file RecoTauProducer.cc.

◆ BuilderList

typedef std::vector<std::unique_ptr<Builder> > RecoTauProducer::BuilderList

Definition at line 50 of file RecoTauProducer.cc.

◆ Modifier

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

Definition at line 49 of file RecoTauProducer.cc.

◆ ModifierList

typedef std::vector<std::unique_ptr<Modifier> > RecoTauProducer::ModifierList

Definition at line 51 of file RecoTauProducer.cc.

Constructor & Destructor Documentation

◆ RecoTauProducer()

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

explicit

Definition at line 83 of file RecoTauProducer.cc.

                                                             {
   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.getParameter<double>("minJetPt");
   maxJetAbsEta_ = pset.getParameter<double>("maxJetAbsEta");
   //consumes definition
   jet_token = consumes<reco::JetView>(jetSrc_);
   jetRegion_token = consumes<edm::AssociationMap<edm::OneToOne<reco::JetView, reco::JetView>>>(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_.emplace_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
     modifiers_.emplace_back(RecoTauModifierPluginFactory::get()->create(pluginType, *modfierPSet, consumesCollector()));
   }
  
   // Check if we want to apply a final output selection
   std::string selection = pset.getParameter<std::string>("outputSelection");
   if (!selection.empty()) {
     outputSelector_ = std::make_unique<StringCutObjectSelector<reco::PFTau>>(selection);
   }
   buildNullTaus_ = pset.getParameter<bool>("buildNullTaus");
  
   produces<reco::PFTauCollection>();
 }

References HLT_FULL_cff::builders, builders_, buildNullTaus_, chargedHadron_token, chargedHadronSrc_, beamerCreator::create(), get, jet_token, jetRegion_token, jetRegionSrc_, jetSrc_, maxJetAbsEta_, minJetPt_, modifiers_, outputSelector_, piZero_token, piZeroSrc_, muonDTDigis_cfi::pset, corrVsCorr::selection, AlCaHLTBitMon_QueryRunRegistry::string, and HistogramManager_cfi::VPSet().

◆ ~RecoTauProducer()

RecoTauProducer::~RecoTauProducer ( )

inlineoverride

Definition at line 54 of file RecoTauProducer.cc.

54 {}

Member Function Documentation

◆ fillDescriptions()

void RecoTauProducer::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 240 of file RecoTauProducer.cc.

                                                                                  {
   // combinatoricRecoTaus
   edm::ParameterSetDescription desc;
   desc.add<edm::InputTag>("piZeroSrc", edm::InputTag("ak4PFJetsRecoTauPiZeros"));
  
   edm::ParameterSetDescription desc_qualityCuts;
   reco::tau::RecoTauQualityCuts::fillDescriptions(desc_qualityCuts);
  
   {
     edm::ParameterSetDescription vpsd_modifiers;
     vpsd_modifiers.add<std::string>("name");
     vpsd_modifiers.add<std::string>("plugin");
     vpsd_modifiers.add<int>("verbosity", 0);
  
     vpsd_modifiers.add<edm::ParameterSetDescription>("qualityCuts", desc_qualityCuts);
     vpsd_modifiers.addOptional<edm::InputTag>("ElectronPreIDProducer");
     vpsd_modifiers.addOptional<std::string>("DataType");
     vpsd_modifiers.addOptional<double>("maximumForElectrionPreIDOutput");
     vpsd_modifiers.addOptional<double>("ElecPreIDLeadTkMatch_maxDR");
     vpsd_modifiers.addOptional<double>("EcalStripSumE_minClusEnergy");
     vpsd_modifiers.addOptional<double>("EcalStripSumE_deltaPhiOverQ_minValue");
     vpsd_modifiers.addOptional<double>("EcalStripSumE_deltaPhiOverQ_maxValue");
     vpsd_modifiers.addOptional<double>("EcalStripSumE_deltaEta");
     vpsd_modifiers.addOptional<double>("dRaddNeutralHadron");
     vpsd_modifiers.addOptional<double>("minGammaEt");
     vpsd_modifiers.addOptional<double>("dRaddPhoton");
     vpsd_modifiers.addOptional<double>("minNeutralHadronEt");
     vpsd_modifiers.addOptional<edm::InputTag>("pfTauTagInfoSrc");
  
     desc.addVPSet("modifiers", vpsd_modifiers);
   }
  
   desc.add<edm::InputTag>("jetRegionSrc", edm::InputTag("recoTauAK4PFJets08Region"));
   desc.add<double>("maxJetAbsEta", 2.5);
   desc.add<std::string>("outputSelection", "leadPFChargedHadrCand().isNonnull()");
   desc.add<edm::InputTag>("chargedHadronSrc", edm::InputTag("ak4PFJetsRecoTauChargedHadrons"));
   desc.add<double>("minJetPt", 14.0);
   desc.add<edm::InputTag>("jetSrc", edm::InputTag("ak4PFJets"));
  
   {
     edm::ParameterSetDescription desc_builders;
     desc_builders.add<std::string>("name");
     desc_builders.add<std::string>("plugin");
     desc_builders.add<int>("verbosity", 0);
  
     desc_builders.add<edm::ParameterSetDescription>("qualityCuts", desc_qualityCuts);
     {
       edm::ParameterSetDescription desc_decayModes;
       desc_decayModes.add<unsigned int>("nPiZeros", 0);
       desc_decayModes.add<unsigned int>("maxPiZeros", 0);
       desc_decayModes.add<unsigned int>("nCharged", 1);
       desc_decayModes.add<unsigned int>("maxTracks", 6);
       desc_builders.addVPSetOptional("decayModes", desc_decayModes);
     }
     desc_builders.add<double>("minAbsPhotonSumPt_insideSignalCone", 2.5);
     desc_builders.add<double>("minRelPhotonSumPt_insideSignalCone", 0.1);
     desc_builders.add<edm::InputTag>("pfCandSrc", edm::InputTag("particleFlow"));
  
     desc_builders.addOptional<std::string>("signalConeSize");
     desc_builders.addOptional<double>("isolationConeSize");
     desc_builders.addOptional<double>("minAbsPhotonSumPt_outsideSignalCone");
     desc_builders.addOptional<double>("minRelPhotonSumPt_outsideSignalCone");
     desc_builders.addOptional<std::string>("isoConeChargedHadrons");
     desc_builders.addOptional<std::string>("isoConeNeutralHadrons");
     desc_builders.addOptional<std::string>("isoConePiZeros");
     desc_builders.addOptional<double>("leadObjectPt");
     desc_builders.addOptional<std::string>("matchingCone");
     desc_builders.addOptional<int>("maxSignalConeChargedHadrons");
     desc_builders.addOptional<std::string>("signalConeChargedHadrons");
     desc_builders.addOptional<std::string>("signalConeNeutralHadrons");
     desc_builders.addOptional<std::string>("signalConePiZeros");
     desc_builders.addOptional<bool>("usePFLeptons");
  
     std::vector<edm::ParameterSet> vpset_default;
     {
       edm::ParameterSet pset_default_builders;
       pset_default_builders.addParameter<std::string>("name", "");
       pset_default_builders.addParameter<std::string>("plugin", "");
       pset_default_builders.addParameter<int>("verbosity", 0);
       pset_default_builders.addParameter<double>("minAbsPhotonSumPt_insideSignalCone", 2.5);
       pset_default_builders.addParameter<double>("minRelPhotonSumPt_insideSignalCone", 0.1);
       pset_default_builders.addParameter<edm::InputTag>("pfCandSrc", edm::InputTag("particleFlow"));
       vpset_default.push_back(pset_default_builders);
     }
     desc.addVPSet("builders", desc_builders, vpset_default);
   }
  
   desc.add<bool>("buildNullTaus", false);
   desc.add<int>("verbosity", 0);
   descriptions.add("combinatoricRecoTaus", desc);
 }

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addOptional(), edm::ParameterSet::addParameter(), edm::ParameterSetDescription::addVPSetOptional(), submitPVResolutionJobs::desc, reco::tau::RecoTauQualityCuts::fillDescriptions(), HLT_FULL_cff::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

◆ produce()

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

override

Definition at line 125 of file RecoTauProducer.cc.

                                                                     {
   // Get the jet input collection via a view of Candidates
   edm::Handle<reco::JetView> jetView;
   evt.getByToken(jet_token, jetView);
  
   // Get the jet region producer
   edm::Handle<edm::AssociationMap<edm::OneToOne<reco::JetView, reco::JetView>>> 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 (auto& builder : builders_) {
     builder->setup(evt, es);
   }
   for (auto& modifier : modifiers_) {
     modifier->setup(evt, es);
   }
  
   // Create output collection
   auto output = std::make_unique<reco::PFTauCollection>();
   output->reserve(jetView->size());
  
   // Loop over the jets and build the taus for each jet
   for (size_t i_j = 0; i_j < jetView->size(); ++i_j) {
     const auto& jetRef = jetView->refAt(i_j);
     // 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::JetBaseRef 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::CandidatePtr> jetCands = jetRef->daughterPtrVector();
     std::vector<reco::CandidatePtr> allRegionalCands = jetRegionRef->daughterPtrVector();
     // 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::CandidatePtr> 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 (const auto& builder : builders_) {
       // 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(), [&](auto& arg) { arg.setjetRef(reco::JetBaseRef(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.
         for (auto const& 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(reco::JetBaseRef(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 (const auto& modifier : modifiers_) {
       (*modifier)(*tau);
     }
   }
  
   for (auto& modifier : modifiers_) {
     modifier->endEvent();
   }
  
   evt.put(std::move(output));
 }