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	hasAbilityToProduceInLumis () const final

bool	hasAbilityToProduceInRuns () 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::auto_ptr< StringCutObjectSelector< reco::RecoTauPiZero > >	outputSelector_

double	piZeroMass_

std::auto_ptr< PiZeroPredicate >	predicate_

rankerList	rankers_

int	verbosity_

Detailed Description

Definition at line 41 of file RecoTauPiZeroProducer.cc.

Member Typedef Documentation

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

Definition at line 43 of file RecoTauPiZeroProducer.cc.

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

private

Definition at line 55 of file RecoTauPiZeroProducer.cc.

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

private

Definition at line 58 of file RecoTauPiZeroProducer.cc.

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

private

Definition at line 61 of file RecoTauPiZeroProducer.cc.

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

private

Definition at line 57 of file RecoTauPiZeroProducer.cc.

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

Definition at line 44 of file RecoTauPiZeroProducer.cc.

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

private

Definition at line 56 of file RecoTauPiZeroProducer.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 81 of file RecoTauPiZeroProducer.cc.

References PFRecoTauChargedHadronProducer_cff::builders, builders_, cand_token, beamerCreator::create(), reco::get(), edm::ParameterSet::getParameter(), maxJetAbsEta_, minJetPt_, outputSelector_, piZeroMass_, predicate_, rankers_, corrVsCorr::selection, AlCaHLTBitMon_QueryRunRegistry::string, verbosity_, and HistogramManager_cfi::VPSet().

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

RecoTauPiZeroProducer::~RecoTauPiZeroProducer ( )

inlineoverride

Definition at line 47 of file RecoTauPiZeroProducer.cc.

References fillDescriptions(), MillePedeFileConverter_cfg::out, print(), and produce().

47 {}

Member Function Documentation

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

static

Definition at line 248 of file RecoTauPiZeroProducer.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addOptional(), edm::ParameterSet::addParameter(), edm::ParameterSetDescription::addVPSet(), DEFINE_FWK_MODULE, CaloRecoTauDiscriminationByFlightPathSignificance_cfi::qualityCuts, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by ~RecoTauPiZeroProducer().

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

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

Definition at line 230 of file RecoTauPiZeroProducer.cc.

References rankers_, and ApeEstimator_cff::width.

Referenced by produce(), and ~RecoTauPiZeroProducer().

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

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

override

Definition at line 129 of file RecoTauPiZeroProducer.cc.

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, pfDeepBoostedJetPreprocessParams_cfi::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(), pfDeepCMVAJetTags_cfi::toAdd, and verbosity_.

Referenced by ~RecoTauPiZeroProducer().

 {
   // 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::auto_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, 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));
 }