Inheritance diagram for reco::tau::RecoTauPiZeroStripPlugin:

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

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

	RecoTauPiZeroStripPlugin (const edm::ParameterSet &pset, edm::ConsumesCollector &&iC)

	~RecoTauPiZeroStripPlugin () 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 Attributes
double	combinatoricStripMassHypo_

bool	combineStrips_

double	etaAssociationDistance_

std::vector< int >	inputParticleIds_

int	maxStrips_

AddFourMomenta	p4Builder_

double	phiAssociationDistance_

std::unique_ptr< RecoTauQualityCuts >	qcuts_

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 43 of file RecoTauPiZeroStripPlugin.cc.

Constructor & Destructor Documentation

◆ RecoTauPiZeroStripPlugin()

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

explicit

Definition at line 68 of file RecoTauPiZeroStripPlugin.cc.

         : RecoTauPiZeroBuilderPlugin(pset, std::move(iC)),
           qcuts_(new RecoTauQualityCuts(pset.getParameterSet("qualityCuts").getParameterSet("signalQualityCuts"))),
           vertexAssociator_(pset.getParameter<edm::ParameterSet>("qualityCuts"), std::move(iC)) {
       inputParticleIds_ = pset.getParameter<std::vector<int> >("stripCandidatesParticleIds");
       etaAssociationDistance_ = pset.getParameter<double>("stripEtaAssociationDistance");
       phiAssociationDistance_ = pset.getParameter<double>("stripPhiAssociationDistance");
       combineStrips_ = pset.getParameter<bool>("makeCombinatoricStrips");
       if (combineStrips_) {
         maxStrips_ = pset.getParameter<int>("maxInputStrips");
         combinatoricStripMassHypo_ = pset.getParameter<double>("stripMassWhenCombining");
       }
     }

References combinatoricStripMassHypo_, combineStrips_, etaAssociationDistance_, inputParticleIds_, maxStrips_, phiAssociationDistance_, and muonDTDigis_cfi::pset.

◆ ~RecoTauPiZeroStripPlugin()

reco::tau::RecoTauPiZeroStripPlugin::~RecoTauPiZeroStripPlugin ( )

inlineoverride

Definition at line 46 of file RecoTauPiZeroStripPlugin.cc.

46 {}

Member Function Documentation

◆ beginEvent()

void reco::tau::RecoTauPiZeroStripPlugin::beginEvent ( )

overridevirtual

Hook called at the beginning of the event.

Reimplemented from reco::tau::RecoTauPiZeroBuilderPlugin.

Definition at line 83 of file RecoTauPiZeroStripPlugin.cc.

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

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

◆ operator()()

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

overridevirtual

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

Implements reco::tau::RecoTauPiZeroBuilderPlugin.

Definition at line 85 of file RecoTauPiZeroStripPlugin.cc.

                                                                                                      {
       // Get list of gamma candidates
       typedef std::vector<reco::CandidatePtr> CandPtrs;
       typedef CandPtrs::iterator CandIter;
       PiZeroVector output;
  
       // Get the candidates passing our quality cuts
       qcuts_->setPV(vertexAssociator_.associatedVertex(jet));
       CandPtrs candsVector = qcuts_->filterCandRefs(pfCandidates(jet, inputParticleIds_));
       //PFCandPtrs candsVector = qcuts_->filterCandRefs(pfGammas(jet));
  
       // Convert to stl::list to allow fast deletions
       typedef std::list<reco::CandidatePtr> CandPtrList;
       typedef std::list<reco::CandidatePtr>::iterator CandPtrListIter;
       CandPtrList cands;
       cands.insert(cands.end(), candsVector.begin(), candsVector.end());
  
       while (!cands.empty()) {
         // Seed this new strip, and delete it from future strips
         CandidatePtr seed = cands.front();
         cands.pop_front();
  
         // Add a new candidate to our collection using this seed
         std::unique_ptr<RecoTauPiZero> strip(new RecoTauPiZero(*seed, RecoTauPiZero::kStrips));
         strip->addDaughter(seed);
  
         // Find all other objects in the strip
         CandPtrListIter stripCand = cands.begin();
         while (stripCand != cands.end()) {
           if (fabs(strip->eta() - (*stripCand)->eta()) < etaAssociationDistance_ &&
               fabs(deltaPhi(*strip, **stripCand)) < phiAssociationDistance_) {
             // Add candidate to strip
             strip->addDaughter(*stripCand);
             // Update the strips four momenta
             p4Builder_.set(*strip);
             // Delete this candidate from future strips and move on to
             // the next potential candidate
             stripCand = cands.erase(stripCand);
           } else {
             // This candidate isn't compatabile - just move to the next candidate
             ++stripCand;
           }
         }
         // Update the vertex
         if (strip->daughterPtr(0).isNonnull())
           strip->setVertex(strip->daughterPtr(0)->vertex());
         output.push_back(strip.get());
       }
  
       // 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(), [&](auto& arg1, auto& arg2) { return arg1.pt() > arg2.pt(); });
         // 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(combinedStrips.get());
           }
         }
         // When done doing all the combinations, add the combined strips to the
         // output.
         output.transfer(output.end(), stripCombinations);
       }
  
       return output.release();
     }