Inheritance diagram for reco::tau::RecoTauPiZeroStripPlugin2:

Public Member Functions
void	beginEvent () override
	Hook called at the beginning of the event. More...

return_type	operator() (const reco::Jet &) const override
	Build a collection of piZeros from objects in the input jet. More...

	RecoTauPiZeroStripPlugin2 (const edm::ParameterSet &, edm::ConsumesCollector &&iC)

	~RecoTauPiZeroStripPlugin2 () override

Public Member Functions inherited from reco::tau::RecoTauPiZeroBuilderPlugin
	RecoTauPiZeroBuilderPlugin (const edm::ParameterSet &pset, edm::ConsumesCollector &&iC)

	~RecoTauPiZeroBuilderPlugin () override

Public Member Functions inherited from reco::tau::RecoTauEventHolderPlugin
edm::Event *	evt ()

const edm::Event *	evt () const

const edm::EventSetup *	evtSetup () const

	RecoTauEventHolderPlugin (const edm::ParameterSet &pset)

void	setup (edm::Event &, const edm::EventSetup &)

	~RecoTauEventHolderPlugin () override

Public Member Functions inherited from reco::tau::RecoTauNamedPlugin
const std::string &	name () const

	RecoTauNamedPlugin (const edm::ParameterSet &pset)

virtual	~RecoTauNamedPlugin ()

Private Types
typedef std::vector< reco::CandidatePtr >	CandPtrs

Private Member Functions
void	addCandsToStrip (RecoTauPiZero &, CandPtrs &, const std::vector< bool > &, std::set< size_t > &, bool &) const

Private Attributes
bool	applyElecTrackQcuts_

double	combinatoricStripMassHypo_

bool	combineStrips_

double	etaAssociationDistance_

std::vector< int >	inputParticleIds_

int	maxStripBuildIterations_

int	maxStrips_

double	minGammaEtStripAdd_

double	minGammaEtStripSeed_

double	minStripEt_

AddFourMomenta	p4Builder_

double	phiAssociationDistance_

RecoTauQualityCuts *	qcuts_

bool	updateStripAfterEachDaughter_

int	verbosity_

RecoTauVertexAssociator	vertexAssociator_

Additional Inherited Members
Public Types inherited from reco::tau::RecoTauPiZeroBuilderPlugin
typedef boost::ptr_vector< RecoTauPiZero >	PiZeroVector

typedef std::unique_ptr< PiZeroVector >	return_type

Detailed Description

Definition at line 52 of file RecoTauPiZeroStripPlugin2.cc.

Member Typedef Documentation

◆ CandPtrs

typedef std::vector<reco::CandidatePtr> reco::tau::RecoTauPiZeroStripPlugin2::CandPtrs

private

Definition at line 62 of file RecoTauPiZeroStripPlugin2.cc.

Constructor & Destructor Documentation

◆ RecoTauPiZeroStripPlugin2()

reco::tau::RecoTauPiZeroStripPlugin2::RecoTauPiZeroStripPlugin2	(	const edm::ParameterSet &	pset,
		edm::ConsumesCollector &&	iC
	)

explicit

Definition at line 91 of file RecoTauPiZeroStripPlugin2.cc.

         : RecoTauPiZeroBuilderPlugin(pset, std::move(iC)),
           vertexAssociator_(pset.getParameter<edm::ParameterSet>("qualityCuts"), std::move(iC)),
           qcuts_(nullptr) {
       minGammaEtStripSeed_ = pset.getParameter<double>("minGammaEtStripSeed");
       minGammaEtStripAdd_ = pset.getParameter<double>("minGammaEtStripAdd");
  
       minStripEt_ = pset.getParameter<double>("minStripEt");
  
       edm::ParameterSet qcuts_pset = pset.getParameterSet("qualityCuts").getParameterSet("signalQualityCuts");
       //-------------------------------------------------------------------------------
       // CV: disable track quality cuts for PFElectronsPFElectron
       //       (treat PFElectrons like PFGammas for the purpose of building eta-phi strips)
       applyElecTrackQcuts_ = pset.getParameter<bool>("applyElecTrackQcuts");
       if (!applyElecTrackQcuts_) {
         qcuts_pset.addParameter<double>("minTrackPt", std::min(minGammaEtStripSeed_, minGammaEtStripAdd_));
         qcuts_pset.addParameter<double>("maxTrackChi2", 1.e+9);
         qcuts_pset.addParameter<double>("maxTransverseImpactParameter", 1.e+9);
         qcuts_pset.addParameter<double>("maxDeltaZ", 1.e+9);
         qcuts_pset.addParameter<double>("minTrackVertexWeight", -1.);
         qcuts_pset.addParameter<unsigned>("minTrackPixelHits", 0);
         qcuts_pset.addParameter<unsigned>("minTrackHits", 0);
       }
       //-------------------------------------------------------------------------------
       qcuts_pset.addParameter<double>("minGammaEt", std::min(minGammaEtStripSeed_, minGammaEtStripAdd_));
       qcuts_ = new RecoTauQualityCuts(qcuts_pset);
  
       inputParticleIds_ = pset.getParameter<std::vector<int> >("stripCandidatesParticleIds");
       etaAssociationDistance_ = pset.getParameter<double>("stripEtaAssociationDistance");
       phiAssociationDistance_ = pset.getParameter<double>("stripPhiAssociationDistance");
  
       updateStripAfterEachDaughter_ = pset.getParameter<bool>("updateStripAfterEachDaughter");
       maxStripBuildIterations_ = pset.getParameter<int>("maxStripBuildIterations");
  
       combineStrips_ = pset.getParameter<bool>("makeCombinatoricStrips");
       if (combineStrips_) {
         maxStrips_ = pset.getParameter<int>("maxInputStrips");
         combinatoricStripMassHypo_ = pset.getParameter<double>("stripMassWhenCombining");
       }
  
       verbosity_ = pset.getParameter<int>("verbosity");
     }

References applyElecTrackQcuts_, combinatoricStripMassHypo_, combineStrips_, etaAssociationDistance_, inputParticleIds_, maxStripBuildIterations_, maxStrips_, min(), minGammaEtStripAdd_, minGammaEtStripSeed_, minStripEt_, phiAssociationDistance_, muonDTDigis_cfi::pset, qcuts_, updateStripAfterEachDaughter_, and verbosity_.

◆ ~RecoTauPiZeroStripPlugin2()

reco::tau::RecoTauPiZeroStripPlugin2::~RecoTauPiZeroStripPlugin2 ( )

override

Definition at line 134 of file RecoTauPiZeroStripPlugin2.cc.

134 { delete qcuts_; }

References qcuts_.

Member Function Documentation

◆ addCandsToStrip()

void reco::tau::RecoTauPiZeroStripPlugin2::addCandsToStrip	(	RecoTauPiZero &	strip,
		CandPtrs &	cands,
		const std::vector< bool > &	candFlags,
		std::set< size_t > &	candIdsCurrentStrip,
		bool &	isCandAdded
	)		const

private

Definition at line 139 of file RecoTauPiZeroStripPlugin2.cc.

                                                                              {
       if (verbosity_ >= 1) {
         edm::LogPrint("RecoTauPiZeroStripPlugin2") << "<RecoTauPiZeroStripPlugin2::addCandsToStrip>:";
       }
       size_t numCands = cands.size();
       for (size_t candId = 0; candId < numCands; ++candId) {
         if ((!candFlags[candId]) &&
             candIdsCurrentStrip.find(candId) == candIdsCurrentStrip.end()) {  // do not include same cand twice
           reco::CandidatePtr cand = cands[candId];
           if (fabs(strip.eta() - cand->eta()) <
                   etaAssociationDistance_ &&  // check if cand is within eta-phi window centered on strip
               fabs(strip.phi() - cand->phi()) < phiAssociationDistance_) {
             if (verbosity_ >= 2) {
               edm::LogPrint("RecoTauPiZeroStripPlugin2")
                   << "--> adding PFCand #" << candId << " (" << cand.id() << ":" << cand.key()
                   << "): Et = " << cand->et() << ", eta = " << cand->eta() << ", phi = " << cand->phi();
             }
             strip.addDaughter(cand);
             if (updateStripAfterEachDaughter_)
               p4Builder_.set(strip);
             isCandAdded = true;
             candIdsCurrentStrip.insert(candId);
           }
         }
       }
     }

References HLT_2018_cff::cands, etaAssociationDistance_, p4Builder_, phiAssociationDistance_, AddFourMomenta::set(), digitizers_cfi::strip, updateStripAfterEachDaughter_, and verbosity_.

Referenced by operator()().

◆ beginEvent()

void reco::tau::RecoTauPiZeroStripPlugin2::beginEvent ( )

overridevirtual

Hook called at the beginning of the event.

Reimplemented from reco::tau::RecoTauPiZeroBuilderPlugin.

Definition at line 137 of file RecoTauPiZeroStripPlugin2.cc.

137 { vertexAssociator_.setEvent(*evt()); }

References reco::tau::RecoTauEventHolderPlugin::evt(), reco::tau::RecoTauVertexAssociator::setEvent(), and vertexAssociator_.

◆ operator()()

RecoTauPiZeroStripPlugin2::return_type reco::tau::RecoTauPiZeroStripPlugin2::operator() ( const reco::Jet & ) const

overridevirtual

Build a collection of piZeros from objects in the input jet.

Implements reco::tau::RecoTauPiZeroBuilderPlugin.

Definition at line 192 of file RecoTauPiZeroStripPlugin2.cc.

                                                                                                        {
       if (verbosity_ >= 1) {
         edm::LogPrint("RecoTauPiZeroStripPlugin2") << "<RecoTauPiZeroStripPlugin2::operator()>:";
         edm::LogPrint("RecoTauPiZeroStripPlugin2") << " minGammaEtStripSeed = " << minGammaEtStripSeed_;
         edm::LogPrint("RecoTauPiZeroStripPlugin2") << " minGammaEtStripAdd = " << minGammaEtStripAdd_;
         edm::LogPrint("RecoTauPiZeroStripPlugin2") << " minStripEt = " << minStripEt_;
       }
  
       PiZeroVector output;
  
       // Get the candidates passing our quality cuts
       qcuts_->setPV(vertexAssociator_.associatedVertex(jet));
       CandPtrs candsVector = qcuts_->filterCandRefs(pfCandidates(jet, inputParticleIds_));
  
       // Convert to stl::list to allow fast deletions
       CandPtrs seedCands;
       CandPtrs addCands;
       int idx = 0;
       for (CandPtrs::iterator cand = candsVector.begin(); cand != candsVector.end(); ++cand) {
         if (verbosity_ >= 1) {
           edm::LogPrint("RecoTauPiZeroStripPlugin2")
               << "PFGamma #" << idx << " (" << cand->id() << ":" << cand->key() << "): Et = " << (*cand)->et()
               << ", eta = " << (*cand)->eta() << ", phi = " << (*cand)->phi();
         }
         if ((*cand)->et() > minGammaEtStripSeed_) {
           if (verbosity_ >= 2) {
             edm::LogPrint("RecoTauPiZeroStripPlugin2") << "--> assigning seedCandId = " << seedCands.size();
             const reco::TrackBaseRef candTrack = getTrack(**cand);
             if (candTrack.isNonnull()) {
               edm::LogPrint("RecoTauPiZeroStripPlugin2")
                   << "track: Pt = " << candTrack->pt() << " eta = " << candTrack->eta()
                   << ", phi = " << candTrack->phi() << ", charge = " << candTrack->charge();
               edm::LogPrint("RecoTauPiZeroStripPlugin2")
                   << " (dZ = " << candTrack->dz(vertexAssociator_.associatedVertex(jet)->position())
                   << ", dXY = " << candTrack->dxy(vertexAssociator_.associatedVertex(jet)->position()) << ","
                   << " numHits = " << candTrack->hitPattern().numberOfValidTrackerHits()
                   << ", numPxlHits = " << candTrack->hitPattern().numberOfValidPixelHits() << ","
                   << " chi2 = " << candTrack->normalizedChi2()
                   << ", dPt/Pt = " << (candTrack->ptError() / candTrack->pt()) << ")";
             }
           }
           seedCands.push_back(*cand);
         } else if ((*cand)->et() > minGammaEtStripAdd_) {
           if (verbosity_ >= 2) {
             edm::LogPrint("RecoTauPiZeroStripPlugin2") << "--> assigning addCandId = " << addCands.size();
           }
           addCands.push_back(*cand);
         }
         ++idx;
       }
  
       std::vector<bool> seedCandFlags(seedCands.size());  // true/false: seedCand is already/not yet included in strip
       std::vector<bool> addCandFlags(addCands.size());    // true/false: addCand  is already/not yet included in strip
  
       std::set<size_t> seedCandIdsCurrentStrip;
       std::set<size_t> addCandIdsCurrentStrip;
  
       size_t idxSeed = 0;
       while (idxSeed < seedCands.size()) {
         if (verbosity_ >= 2)
           edm::LogPrint("RecoTauPiZeroStripPlugin2") << "processing seed #" << idxSeed;
  
         seedCandIdsCurrentStrip.clear();
         addCandIdsCurrentStrip.clear();
  
         std::unique_ptr<RecoTauPiZero> strip(new RecoTauPiZero(*seedCands[idxSeed], RecoTauPiZero::kStrips));
         strip->addDaughter(seedCands[idxSeed]);
         seedCandIdsCurrentStrip.insert(idxSeed);
  
         bool isCandAdded;
         int stripBuildIteration = 0;
         do {
           isCandAdded = false;
  
           //if ( verbosity_ >= 2 ) edm::LogPrint("RecoTauPiZeroStripPlugin2") << " adding seedCands to strip..." ;
           addCandsToStrip(*strip, seedCands, seedCandFlags, seedCandIdsCurrentStrip, isCandAdded);
           //if ( verbosity_ >= 2 ) edm::LogPrint("RecoTauPiZeroStripPlugin2") << " adding addCands to strip..." ;
           addCandsToStrip(*strip, addCands, addCandFlags, addCandIdsCurrentStrip, isCandAdded);
  
           if (!updateStripAfterEachDaughter_)
             p4Builder_.set(*strip);
  
           ++stripBuildIteration;
         } while (isCandAdded && (stripBuildIteration < maxStripBuildIterations_ || maxStripBuildIterations_ == -1));
  
         if (strip->et() > minStripEt_) {  // strip passed Et cuts, add it to the event
           if (verbosity_ >= 2)
             edm::LogPrint("RecoTauPiZeroStripPlugin2")
                 << "Building strip: Et = " << strip->et() << ", eta = " << strip->eta() << ", phi = " << strip->phi();
  
           // Update the vertex
           if (strip->daughterPtr(0).isNonnull())
             strip->setVertex(strip->daughterPtr(0)->vertex());
           output.push_back(std::move(strip));
  
           // Mark daughters as being part of this strip
           markCandsInStrip(seedCandFlags, seedCandIdsCurrentStrip);
           markCandsInStrip(addCandFlags, addCandIdsCurrentStrip);
         } else {  // strip failed Et cuts, just skip it
           if (verbosity_ >= 2)
             edm::LogPrint("RecoTauPiZeroStripPlugin2")
                 << "Discarding strip: Et = " << strip->et() << ", eta = " << strip->eta() << ", phi = " << strip->phi();
         }
  
         ++idxSeed;
         while (idxSeed < seedCands.size() && seedCandFlags[idxSeed]) {
           ++idxSeed;  // fast-forward to next seed cand not yet included in any strip
         }
       }
  
       // Check if we want to combine our strips
       if (combineStrips_ && output.size() > 1) {
         PiZeroVector stripCombinations;
         // Sort the output by descending pt
         output.sort(
             output.begin(), output.end(), boost::bind(&RecoTauPiZero::pt, _1) > boost::bind(&RecoTauPiZero::pt, _2));
         // Get the end of interesting set of strips to try and combine
         PiZeroVector::const_iterator end_iter = takeNElements(output.begin(), output.end(), maxStrips_);
  
         // Look at all the combinations
         for (PiZeroVector::const_iterator first = output.begin(); first != end_iter - 1; ++first) {
           for (PiZeroVector::const_iterator second = first + 1; second != end_iter; ++second) {
             Candidate::LorentzVector firstP4 = first->p4();
             Candidate::LorentzVector secondP4 = second->p4();
             // If we assume a certain mass for each strip apply it here.
             firstP4 = applyMassConstraint(firstP4, combinatoricStripMassHypo_);
             secondP4 = applyMassConstraint(secondP4, combinatoricStripMassHypo_);
             Candidate::LorentzVector totalP4 = firstP4 + secondP4;
             // Make our new combined strip
             std::unique_ptr<RecoTauPiZero> combinedStrips(
                 new RecoTauPiZero(0,
                                   totalP4,
                                   Candidate::Point(0, 0, 0),
                                   //111, 10001, true, RecoTauPiZero::kCombinatoricStrips));
                                   111,
                                   10001,
                                   true,
                                   RecoTauPiZero::kUndefined));
  
             // Now loop over the strip members
             for (auto const& gamma : first->daughterPtrVector()) {
               combinedStrips->addDaughter(gamma);
             }
             for (auto const& gamma : second->daughterPtrVector()) {
               combinedStrips->addDaughter(gamma);
             }
             // Update the vertex
             if (combinedStrips->daughterPtr(0).isNonnull())
               combinedStrips->setVertex(combinedStrips->daughterPtr(0)->vertex());
             // Add to our collection of combined strips
             stripCombinations.push_back(std::move(combinedStrips));
           }
         }
         // When done doing all the combinations, add the combined strips to the
         // output.
         output.transfer(output.end(), stripCombinations);
       }
  
       return output.release();
     }