Inheritance diagram for RecoTauPiZeroProducer:

Public Types
typedef reco::tau::RecoTauPiZeroBuilderPlugin	Builder

typedef reco::tau::RecoTauPiZeroQualityPlugin	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 Member Functions
void	print (const std::vector< reco::RecoTauPiZero > &piZeros, std::ostream &out)

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

	RecoTauPiZeroProducer (const edm::ParameterSet &pset)

	~RecoTauPiZeroProducer () override

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

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndRuns () const final

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Private Types
typedef boost::ptr_vector< Builder >	builderList

typedef boost::ptr_list< reco::RecoTauPiZero >	PiZeroList

typedef reco::tau::RecoTauLexicographicalRanking< rankerList, reco::RecoTauPiZero >	PiZeroPredicate

typedef boost::ptr_vector< reco::RecoTauPiZero >	PiZeroVector

typedef boost::ptr_vector< Ranker >	rankerList

Private Attributes
builderList	builders_

edm::EDGetTokenT< reco::JetView >	cand_token

double	maxJetAbsEta_

double	minJetPt_

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

double	piZeroMass_

std::unique_ptr< PiZeroPredicate >	predicate_

rankerList	rankers_

int	verbosity_

Detailed Description

Definition at line 41 of file RecoTauPiZeroProducer.cc.

Member Typedef Documentation

◆ Builder

typedef reco::tau::RecoTauPiZeroBuilderPlugin RecoTauPiZeroProducer::Builder

Definition at line 43 of file RecoTauPiZeroProducer.cc.

◆ builderList

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

private

Definition at line 54 of file RecoTauPiZeroProducer.cc.

◆ PiZeroList

typedef boost::ptr_list<reco::RecoTauPiZero> RecoTauPiZeroProducer::PiZeroList

private

Definition at line 57 of file RecoTauPiZeroProducer.cc.

◆ PiZeroPredicate

typedef reco::tau::RecoTauLexicographicalRanking<rankerList, reco::RecoTauPiZero> RecoTauPiZeroProducer::PiZeroPredicate

private

Definition at line 59 of file RecoTauPiZeroProducer.cc.

◆ PiZeroVector

typedef boost::ptr_vector<reco::RecoTauPiZero> RecoTauPiZeroProducer::PiZeroVector

private

Definition at line 56 of file RecoTauPiZeroProducer.cc.

◆ Ranker

typedef reco::tau::RecoTauPiZeroQualityPlugin RecoTauPiZeroProducer::Ranker

Definition at line 44 of file RecoTauPiZeroProducer.cc.

◆ rankerList

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

private

Definition at line 55 of file RecoTauPiZeroProducer.cc.

Constructor & Destructor Documentation

◆ RecoTauPiZeroProducer()

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

explicit

Definition at line 78 of file RecoTauPiZeroProducer.cc.

                                                                         {
   cand_token = consumes<reco::JetView>(pset.getParameter<edm::InputTag>("jetSrc"));
   minJetPt_ = pset.getParameter<double>("minJetPt");
   maxJetAbsEta_ = pset.getParameter<double>("maxJetAbsEta");
  
   typedef std::vector<edm::ParameterSet> VPSet;
   // Get the mass hypothesis for the pizeros
   piZeroMass_ = pset.getParameter<double>("massHypothesis");
  
   // Get each of our PiZero 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(
         RecoTauPiZeroBuilderPluginFactory::get()->create(pluginType, *builderPSet, consumesCollector()));
   }
  
   // Get each of our quality rankers
   const VPSet& rankers = pset.getParameter<VPSet>("ranking");
   for (VPSet::const_iterator rankerPSet = rankers.begin(); rankerPSet != rankers.end(); ++rankerPSet) {
     const std::string& pluginType = rankerPSet->getParameter<std::string>("plugin");
     rankers_.push_back(RecoTauPiZeroQualityPluginFactory::get()->create(pluginType, *rankerPSet));
   }
  
   // Build the sorting predicate
   predicate_ = std::unique_ptr<PiZeroPredicate>(new PiZeroPredicate(rankers_));
  
   // now all producers apply a final output selection
   std::string selection = pset.getParameter<std::string>("outputSelection");
   if (!selection.empty()) {
     outputSelector_.reset(new StringCutObjectSelector<reco::RecoTauPiZero>(selection));
   }
  
   verbosity_ = pset.getParameter<int>("verbosity");
  
   produces<reco::JetPiZeroAssociation>();
 }

References HLT_2018_cff::builders, builders_, cand_token, beamerCreator::create(), get, maxJetAbsEta_, minJetPt_, outputSelector_, piZeroMass_, predicate_, muonDTDigis_cfi::pset, rankers_, corrVsCorr::selection, AlCaHLTBitMon_QueryRunRegistry::string, verbosity_, and HistogramManager_cfi::VPSet().

◆ ~RecoTauPiZeroProducer()

RecoTauPiZeroProducer::~RecoTauPiZeroProducer ( )

inlineoverride

Definition at line 47 of file RecoTauPiZeroProducer.cc.

47 {}

Member Function Documentation

◆ fillDescriptions()

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

static

Definition at line 232 of file RecoTauPiZeroProducer.cc.

                                                                                        {
   // common parameter descriptions
   edm::ParameterSetDescription desc_ranking;
   desc_ranking.add<std::string>("selectionPassFunction", "Func");
   desc_ranking.add<double>("selectionFailValue", 1000);
   desc_ranking.add<std::string>("selection", "Sel");
   desc_ranking.add<std::string>("name", "name");
   desc_ranking.add<std::string>("plugin", "plugin");
   edm::ParameterSet pset_ranking;
   pset_ranking.addParameter<std::string>("selectionPassFunction", "");
   pset_ranking.addParameter<double>("selectionFailValue", 1000);
   pset_ranking.addParameter<std::string>("selection", "");
   pset_ranking.addParameter<std::string>("name", "");
   pset_ranking.addParameter<std::string>("plugin", "");
   std::vector<edm::ParameterSet> vpsd_ranking;
   vpsd_ranking.push_back(pset_ranking);
  
   edm::ParameterSetDescription desc_signalQualityCuts;
   desc_signalQualityCuts.add<double>("maxDeltaZ", 0.4);
   desc_signalQualityCuts.add<double>("minTrackPt", 0.5);
   desc_signalQualityCuts.add<double>("minTrackVertexWeight", -1.0);
   desc_signalQualityCuts.add<double>("maxTrackChi2", 100.0);
   desc_signalQualityCuts.add<unsigned int>("minTrackPixelHits", 0);
   desc_signalQualityCuts.add<double>("minGammaEt", 1.0);
   desc_signalQualityCuts.add<unsigned int>("minTrackHits", 3);
   desc_signalQualityCuts.addOptional<double>("minNeutralHadronEt");
   desc_signalQualityCuts.add<double>("maxTransverseImpactParameter", 0.1);
   desc_signalQualityCuts.addOptional<bool>("useTracksInsteadOfPFHadrons");
  
   edm::ParameterSetDescription desc_vxAssocQualityCuts;
   desc_vxAssocQualityCuts.add<double>("minTrackPt", 0.5);
   desc_vxAssocQualityCuts.add<double>("minTrackVertexWeight", -1.0);
   desc_vxAssocQualityCuts.add<double>("maxTrackChi2", 100.0);
   desc_vxAssocQualityCuts.add<unsigned int>("minTrackPixelHits", 0);
   desc_vxAssocQualityCuts.add<double>("minGammaEt", 1.0);
   desc_vxAssocQualityCuts.add<unsigned int>("minTrackHits", 3);
   desc_vxAssocQualityCuts.add<double>("maxTransverseImpactParameter", 0.1);
   desc_vxAssocQualityCuts.addOptional<bool>("useTracksInsteadOfPFHadrons");
  
   edm::ParameterSetDescription desc_isolationQualityCuts;
   desc_isolationQualityCuts.add<double>("maxDeltaZ", 0.2);
   desc_isolationQualityCuts.add<double>("minTrackPt", 1.0);
   desc_isolationQualityCuts.add<double>("minTrackVertexWeight", -1.0);
   desc_isolationQualityCuts.add<double>("maxTrackChi2", 100.0);
   desc_isolationQualityCuts.add<unsigned int>("minTrackPixelHits", 0);
   desc_isolationQualityCuts.add<double>("minGammaEt", 1.5);
   desc_isolationQualityCuts.add<unsigned int>("minTrackHits", 8);
   desc_isolationQualityCuts.add<double>("maxTransverseImpactParameter", 0.03);
   desc_isolationQualityCuts.addOptional<bool>("useTracksInsteadOfPFHadrons");
  
   edm::ParameterSetDescription desc_qualityCuts;
   desc_qualityCuts.add<edm::ParameterSetDescription>("signalQualityCuts", desc_signalQualityCuts);
   desc_qualityCuts.add<edm::ParameterSetDescription>("vxAssocQualityCuts", desc_vxAssocQualityCuts);
   desc_qualityCuts.add<edm::ParameterSetDescription>("isolationQualityCuts", desc_isolationQualityCuts);
   desc_qualityCuts.add<std::string>("leadingTrkOrPFCandOption", "leadPFCand");
   desc_qualityCuts.add<std::string>("pvFindingAlgo", "closestInDeltaZ");
   desc_qualityCuts.add<edm::InputTag>("primaryVertexSrc", edm::InputTag("offlinePrimaryVertices"));
   desc_qualityCuts.add<bool>("vertexTrackFiltering", false);
   desc_qualityCuts.add<bool>("recoverLeadingTrk", false);
  
   edm::ParameterSet pset_builders;
   pset_builders.addParameter<std::string>("name", "");
   pset_builders.addParameter<std::string>("plugin", "");
   edm::ParameterSet qualityCuts;
   pset_builders.addParameter<edm::ParameterSet>("qualityCuts", qualityCuts);
   pset_builders.addParameter<int>("verbosity", 0);
  
   {
     // Tailored on ak4PFJetsLegacyHPSPiZeros
     edm::ParameterSetDescription desc;
     desc.add<double>("massHypothesis", 0.136);
     desc.addVPSet("ranking", desc_ranking, vpsd_ranking);
     desc.add<int>("verbosity", 0);
     desc.add<double>("maxJetAbsEta", 2.5);
     desc.add<std::string>("outputSelection", "pt > 0");
     desc.add<double>("minJetPt", 14.0);
     desc.add<edm::InputTag>("jetSrc", edm::InputTag("ak4PFJets"));
  
     edm::ParameterSetDescription desc_builders;
     {
       edm::ParameterSetDescription psd0;
       psd0.add<std::string>("function", "TMath::Min(0.3, TMath::Max(0.05, [0]*TMath::Power(pT, -[1])))");
       psd0.add<double>("par1", 0.707716);
       psd0.add<double>("par0", 0.352476);
       desc_builders.addOptional<edm::ParameterSetDescription>("stripPhiAssociationDistanceFunc", psd0);
     }
     {
       edm::ParameterSetDescription psd0;
       psd0.add<std::string>("function", "TMath::Min(0.15, TMath::Max(0.05, [0]*TMath::Power(pT, -[1])))");
       psd0.add<double>("par1", 0.658701);
       psd0.add<double>("par0", 0.197077);
       desc_builders.addOptional<edm::ParameterSetDescription>("stripEtaAssociationDistanceFunc", psd0);
     }
     desc_builders.addOptional<double>("stripEtaAssociationDistance", 0.05);
     desc_builders.addOptional<double>("stripPhiAssociationDistance", 0.2);
  
     desc_builders.add<edm::ParameterSetDescription>("qualityCuts", desc_qualityCuts);
  
     desc_builders.add<std::string>("name");
     desc_builders.add<std::string>("plugin");
     desc_builders.add<int>("verbosity", 0);
  
     desc_builders.addOptional<bool>("makeCombinatoricStrips");
     desc_builders.addOptional<int>("maxStripBuildIterations");
     desc_builders.addOptional<double>("minGammaEtStripAdd");
     desc_builders.addOptional<double>("minGammaEtStripSeed");
     desc_builders.addOptional<double>("minStripEt");
     desc_builders.addOptional<std::vector<int>>("stripCandidatesParticleIds");
     desc_builders.addOptional<bool>("updateStripAfterEachDaughter");
     desc_builders.addOptional<bool>("applyElecTrackQcuts");
  
     std::vector<edm::ParameterSet> vpsd_builders;
     vpsd_builders.push_back(pset_builders);
     desc.addVPSet("builders", desc_builders, vpsd_builders);
  
     descriptions.add("recoTauPiZeroProducer", desc);
   }
 }

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addOptional(), edm::ParameterSet::addParameter(), edm::ParameterSetDescription::addVPSet(), HLT_2018_cff::InputTag, beam_dqm_sourceclient-live_cfg::qualityCuts, and AlCaHLTBitMon_QueryRunRegistry::string.

◆ print()

void RecoTauPiZeroProducer::print	(	const std::vector< reco::RecoTauPiZero > &	piZeros,
		std::ostream &	out
	)

Definition at line 219 of file RecoTauPiZeroProducer.cc.

                                                                                               {
   const unsigned int width = 25;
   for (auto const& piZero : piZeros) {
     out << piZero;
     out << "* Rankers:" << std::endl;
     for (rankerList::const_iterator ranker = rankers_.begin(); ranker != rankers_.end(); ++ranker) {
       out << "* " << std::setiosflags(std::ios::left) << std::setw(width) << ranker->name() << " "
           << std::resetiosflags(std::ios::left) << std::setprecision(3) << (*ranker)(piZero);
       out << std::endl;
     }
   }
 }

References MillePedeFileConverter_cfg::out, rankers_, and ApeEstimator_cff::width.

Referenced by produce().

◆ produce()

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

override

Definition at line 119 of file RecoTauPiZeroProducer.cc.

                                                                           {
   // Get a view of our jets via the base candidates
   edm::Handle<reco::JetView> jetView;
   evt.getByToken(cand_token, jetView);
  
   // Give each of our plugins a chance at doing something with the edm::Event
   for (auto& builder : builders_) {
     builder.setup(evt, es);
   }
  
   // Make our association
   std::unique_ptr<reco::JetPiZeroAssociation> association;
  
   association = std::make_unique<reco::JetPiZeroAssociation>(reco::JetRefBaseProd(jetView));
  
   // Loop over our jets
   size_t nJets = jetView->size();
   for (size_t i = 0; i < nJets; ++i) {
     const reco::JetBaseRef jet(jetView->refAt(i));
  
     if (jet->pt() - minJetPt_ < 1e-5)
       continue;
     if (std::abs(jet->eta()) - maxJetAbsEta_ > -1e-5)
       continue;
     // Build our global list of RecoTauPiZero
     PiZeroList dirtyPiZeros;
  
     // Compute the pi zeros from this jet for all the desired algorithms
     for (auto const& builder : builders_) {
       try {
         PiZeroVector result(builder(*jet));
         dirtyPiZeros.transfer(dirtyPiZeros.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
     dirtyPiZeros.sort(*predicate_);
  
     // Keep track of the photons in the clean collection
     std::vector<reco::RecoTauPiZero> cleanPiZeros;
     std::set<reco::CandidatePtr> photonsInCleanCollection;
     while (!dirtyPiZeros.empty()) {
       // Pull our candidate pi zero from the front of the list
       std::unique_ptr<reco::RecoTauPiZero> toAdd(dirtyPiZeros.pop_front().release());
       // If this doesn't pass our basic selection, discard it.
       if (!(*outputSelector_)(*toAdd)) {
         continue;
       }
       // Find the sub-gammas that are not already in the cleaned collection
       std::vector<reco::CandidatePtr> uniqueGammas;
       std::set_difference(toAdd->daughterPtrVector().begin(),
                           toAdd->daughterPtrVector().end(),
                           photonsInCleanCollection.begin(),
                           photonsInCleanCollection.end(),
                           std::back_inserter(uniqueGammas));
       // If the pi zero has no unique gammas, discard it.  Note toAdd is deleted
       // when it goes out of scope.
       if (uniqueGammas.empty()) {
         continue;
       } else if (uniqueGammas.size() == toAdd->daughterPtrVector().size()) {
         // Check if it is composed entirely of unique gammas.  In this case
         // immediately add it to the clean collection.
         photonsInCleanCollection.insert(toAdd->daughterPtrVector().begin(), toAdd->daughterPtrVector().end());
         cleanPiZeros.push_back(*toAdd);
       } else {
         // Otherwise update the pizero that contains only the unique gammas and
         // add it back into the sorted list of dirty PiZeros
         toAdd->clearDaughters();
         // Add each of the unique daughters back to the pizero
         for (auto const& gamma : uniqueGammas) {
           toAdd->addDaughter(gamma);
         }
         // Update the four vector
         AddFourMomenta p4Builder_;
         p4Builder_.set(*toAdd);
         // Put this pi zero back into the collection of sorted dirty pizeros
         PiZeroList::iterator insertionPoint =
             std::lower_bound(dirtyPiZeros.begin(), dirtyPiZeros.end(), *toAdd, *predicate_);
         dirtyPiZeros.insert(insertionPoint, std::move(toAdd));
       }
     }
     // Apply the mass hypothesis if desired
     if (piZeroMass_ >= 0) {
       for (auto& cleanPiZero : cleanPiZeros) {
         cleanPiZero.setMass(this->piZeroMass_);
       };
     }
     // Add to association
     if (verbosity_ >= 2) {
       print(cleanPiZeros, std::cout);
     }
     association->setValue(jet.key(), cleanPiZeros);
   }
   evt.put(std::move(association));
 }

References funct::abs(), TrackValidation_cff::association, builders_, cand_token, gather_cfg::cout, MillePedeFileConverter_cfg::e, cppFunctionSkipper::exception, CustomPhysics_cfi::gamma, edm::Event::getByToken(), mps_fire::i, metsig::jet, cuda_std::lower_bound(), maxJetAbsEta_, minJetPt_, eostools::move(), outputSelector_, piZeroMass_, predicate_, print(), edm::Event::put(), edm::View< T >::refAt(), mps_fire::result, AddFourMomenta::set(), edm::View< T >::size(), HLT_2018_cff::toAdd, and verbosity_.

Member Data Documentation

◆ builders_

builderList RecoTauPiZeroProducer::builders_

private

Definition at line 61 of file RecoTauPiZeroProducer.cc.

Referenced by produce(), and RecoTauPiZeroProducer().

◆ cand_token

edm::EDGetTokenT<reco::JetView> RecoTauPiZeroProducer::cand_token

private

Definition at line 70 of file RecoTauPiZeroProducer.cc.

Referenced by produce(), and RecoTauPiZeroProducer().

◆ maxJetAbsEta_

double RecoTauPiZeroProducer::maxJetAbsEta_

private

Definition at line 73 of file RecoTauPiZeroProducer.cc.

Referenced by produce(), and RecoTauPiZeroProducer().

◆ minJetPt_

double RecoTauPiZeroProducer::minJetPt_

private

Definition at line 72 of file RecoTauPiZeroProducer.cc.

Referenced by produce(), and RecoTauPiZeroProducer().

◆ outputSelector_

std::unique_ptr<StringCutObjectSelector<reco::RecoTauPiZero> > RecoTauPiZeroProducer::outputSelector_

private

Definition at line 67 of file RecoTauPiZeroProducer.cc.

Referenced by produce(), and RecoTauPiZeroProducer().

◆ piZeroMass_

double RecoTauPiZeroProducer::piZeroMass_

private

Definition at line 64 of file RecoTauPiZeroProducer.cc.

Referenced by produce(), and RecoTauPiZeroProducer().

◆ predicate_

std::unique_ptr<PiZeroPredicate> RecoTauPiZeroProducer::predicate_

private

Definition at line 63 of file RecoTauPiZeroProducer.cc.

Referenced by produce(), and RecoTauPiZeroProducer().

◆ rankers_

rankerList RecoTauPiZeroProducer::rankers_

private

Definition at line 62 of file RecoTauPiZeroProducer.cc.

Referenced by print(), and RecoTauPiZeroProducer().

◆ verbosity_

int RecoTauPiZeroProducer::verbosity_

private

Definition at line 75 of file RecoTauPiZeroProducer.cc.

Referenced by produce(), and RecoTauPiZeroProducer().

Public Types

Public Member Functions

Static Public Member Functions

Private Types

Private Attributes

Detailed Description

Member Typedef Documentation

◆ Builder

◆ builderList

◆ PiZeroList

◆ PiZeroPredicate

◆ PiZeroVector

◆ Ranker

◆ rankerList

Constructor & Destructor Documentation

◆ RecoTauPiZeroProducer()

◆ ~RecoTauPiZeroProducer()

Member Function Documentation

◆ fillDescriptions()

◆ print()

◆ produce()

Member Data Documentation

◆ builders_

◆ cand_token

◆ maxJetAbsEta_

◆ minJetPt_

◆ outputSelector_

◆ piZeroMass_

◆ predicate_

◆ rankers_

◆ verbosity_