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<>
using	CacheTypes = CacheContexts< T... >

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T... >

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::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

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

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 45 of file RecoTauProducer.cc.

Member Typedef Documentation

◆ Builder

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

Definition at line 47 of file RecoTauProducer.cc.

◆ BuilderList

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

Definition at line 49 of file RecoTauProducer.cc.

◆ Modifier

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

Definition at line 48 of file RecoTauProducer.cc.

◆ ModifierList

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

Definition at line 50 of file RecoTauProducer.cc.

Constructor & Destructor Documentation

◆ RecoTauProducer()

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

explicit

Definition at line 82 of file RecoTauProducer.cc.

References HLT_2024v11_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().

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

◆ ~RecoTauProducer()

RecoTauProducer::~RecoTauProducer ( )

inlineoverride

Definition at line 53 of file RecoTauProducer.cc.

53 {}

Member Function Documentation

◆ fillDescriptions()

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

static

Definition at line 241 of file RecoTauProducer.cc.

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

                                                                                  {
   // 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");
     vpsd_modifiers.addOptional<edm::InputTag>("trackSrc");
 
     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);
 }

◆ produce()

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

override

Definition at line 124 of file RecoTauProducer.cc.

References funct::abs(), builders_, buildNullTaus_, chargedHadron_token, MillePedeFileConverter_cfg::e, Exception, edm::Event::getByToken(), edm::RefToBase< T >::isNull(), jet_token, jetRegion_token, maxJetAbsEta_, minJetPt_, modifiers_, eostools::move(), outputSelector_, piZero_token, edm::Event::put(), edm::View< T >::refAt(), DBoxMetadataHelper::set_difference(), reco::PFTau::setjetRef(), edm::View< T >::size(), jetUpdater_cfi::sort, metsig::tau, and Tau3MuMonitor_cff::taus.

                                                                     {
   // 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 std::vector of std::unique_ptr to 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()) {
         for (auto& tau : taus) {
           output->push_back(*tau);
         }
         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 (auto& tau : *output) {
     for (const auto& modifier : modifiers_) {
       (*modifier)(tau);
     }
   }
 
   for (auto& modifier : modifiers_) {
     modifier->endEvent();
   }
 
   evt.put(std::move(output));
 }