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
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 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::auto_ptr< PiZeroVector >	return_type

Detailed Description

Definition at line 53 of file RecoTauPiZeroStripPlugin2.cc.

Member Typedef Documentation

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

private

Definition at line 64 of file RecoTauPiZeroStripPlugin2.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 93 of file RecoTauPiZeroStripPlugin2.cc.

References applyElecTrackQcuts_, combinatoricStripMassHypo_, combineStrips_, etaAssociationDistance_, edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterSet(), inputParticleIds_, maxStripBuildIterations_, maxStrips_, min(), minGammaEtStripAdd_, minGammaEtStripSeed_, minStripEt_, phiAssociationDistance_, qcuts_, updateStripAfterEachDaughter_, and verbosity_.

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

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

override

Definition at line 137 of file RecoTauPiZeroStripPlugin2.cc.

References qcuts_.

 {
   delete qcuts_;
 }

Member Function Documentation

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 148 of file RecoTauPiZeroStripPlugin2.cc.

References reco::CompositePtrCandidate::addDaughter(), reco::LeafCandidate::eta(), etaAssociationDistance_, getTrack(), reco::PFCandidate::gsfTrackRef(), edm::Ptr< T >::id(), edm::Ref< C, T, F >::isNonnull(), edm::Ptr< T >::key(), p4Builder_, reco::LeafCandidate::phi(), phiAssociationDistance_, AddFourMomenta::set(), reco::PFCandidate::trackRef(), updateStripAfterEachDaughter_, and verbosity_.

Referenced by operator()().

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

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

overridevirtual

Hook called at the beginning of the event.

Reimplemented from reco::tau::RecoTauPiZeroBuilderPlugin.

Definition at line 143 of file RecoTauPiZeroStripPlugin2.cc.

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

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

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 195 of file RecoTauPiZeroStripPlugin2.cc.

References addCandsToStrip(), reco::tau::RecoTauVertexAssociator::associatedVertex(), reco::TrackBase::charge(), combinatoricStripMassHypo_, combineStrips_, DEFINE_EDM_PLUGIN, reco::TrackBase::dxy(), reco::TrackBase::dz(), reco::TrackBase::eta(), reco::tau::RecoTauQualityCuts::filterCandRefs(), plotBeamSpotDB::first, CustomPhysics_cfi::gamma, getTrack(), reco::TrackBase::hitPattern(), training_settings::idx, inputParticleIds_, edm::RefToBase< T >::isNonnull(), reco::RecoTauPiZero::kStrips, reco::RecoTauPiZero::kUndefined, maxStripBuildIterations_, maxStrips_, minGammaEtStripAdd_, minGammaEtStripSeed_, minStripEt_, reco::TrackBase::normalizedChi2(), reco::HitPattern::numberOfValidPixelHits(), reco::HitPattern::numberOfValidTrackerHits(), convertSQLitetoXML_cfg::output, p4Builder_, reco::tau::pfCandidates(), reco::TrackBase::phi(), reco::LeafCandidate::pt(), reco::TrackBase::pt(), reco::TrackBase::ptError(), qcuts_, edm::second(), AddFourMomenta::set(), reco::tau::RecoTauQualityCuts::setPV(), digitizers_cfi::strip, reco::tau::takeNElements(), updateStripAfterEachDaughter_, verbosity_, and vertexAssociator_.

 {
   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::auto_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(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::auto_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);
       }
     }
     // When done doing all the combinations, add the combined strips to the
     // output.
     output.transfer(output.end(), stripCombinations);
   }
 
   return output.release();
 }