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
const edm::Event *	evt () const

edm::Event *	evt ()

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 std::vector< std::unique_ptr< RecoTauPiZero > >	PiZeroVector

typedef 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.

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

         : 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");
       }
     }

◆ ~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.

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

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

reco::tau::RecoTauVertexAssociator::setEvent

void setEvent(const edm::Event &evt)

Load the vertices from the event.

Definition: RecoTauVertexAssociator.cc:242

reco::tau::RecoTauEventHolderPlugin::evt

const edm::Event * evt() const

Definition: RecoTauPluginsCommon.cc:16

reco::tau::RecoTauPiZeroStripPlugin::vertexAssociator_

RecoTauVertexAssociator vertexAssociator_

Definition: RecoTauPiZeroStripPlugin.cc:54

◆ 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.

References reco::tau::RecoTauVertexAssociator::associatedVertex(), HLT_2022v12_cff::cands, combinatoricStripMassHypo_, combineStrips_, reco::deltaPhi(), etaAssociationDistance_, first, CustomPhysics_cfi::gamma, inputParticleIds_, metsig::jet, reco::RecoTauPiZero::kStrips, reco::RecoTauPiZero::kUndefined, maxStrips_, eostools::move(), convertSQLitetoXML_cfg::output, p4Builder_, reco::tau::pfCandidates(), phiAssociationDistance_, qcuts_, edm::second(), fileCollector::seed, AddFourMomenta::set(), jetUpdater_cfi::sort, digitizers_cfi::strip, reco::tau::takeNElements(), and vertexAssociator_.

                                                                                                      {
       // 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
       std::list<reco::CandidatePtr> 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
         auto strip = std::make_unique<RecoTauPiZero>(*seed, RecoTauPiZero::kStrips);
         strip->addDaughter(seed);
 
         // Find all other objects in the strip
         auto 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.emplace_back(strip.release());
       }
 
       // Check if we want to combine our strips
       if (combineStrips_ && output.size() > 1) {
         PiZeroVector stripCombinations;
         // Sort the output by descending pt
         std::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 firstIter = output.begin(); firstIter != end_iter - 1; ++firstIter) {
           for (PiZeroVector::const_iterator secondIter = firstIter + 1; secondIter != end_iter; ++secondIter) {
             auto const& first = *firstIter;
             auto const& second = *secondIter;
             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
             auto combinedStrips =
                 std::make_unique<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.emplace_back(combinedStrips.release());
           }
         }
         // When done doing all the combinations, add the combined strips to the output.
         std::move(stripCombinations.begin(), stripCombinations.end(), std::back_inserter(output));
       }
 
       return output;
     }