Inheritance diagram for reco::tau::RecoTauPiZeroStripPlugin2:

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

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

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

virtual	~RecoTauPiZeroStripPlugin2 ()

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

virtual	~RecoTauPiZeroBuilderPlugin ()

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 &)

virtual	~RecoTauEventHolderPlugin ()

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::PFCandidatePtr >	PFCandPtrs

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

Private Attributes
bool	applyElecTrackQcuts_

double	combinatoricStripMassHypo_

bool	combineStrips_

double	etaAssociationDistance_

std::vector< int >	inputPdgIds_

int	maxStripBuildIterations_

int	maxStrips_

double	minGammaEtStripAdd_

double	minGammaEtStripSeed_

double	minStripEt_

AddFourMomenta	p4Builder_

double	phiAssociationDistance_

RecoTauQualityCuts *	qcuts_

bool	updateStripAfterEachDaughter_

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

Member Typedef Documentation

typedef std::vector<reco::PFCandidatePtr> reco::tau::RecoTauPiZeroStripPlugin2::PFCandPtrs

private

Definition at line 61 of file RecoTauPiZeroStripPlugin2.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 88 of file RecoTauPiZeroStripPlugin2.cc.

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

     : RecoTauPiZeroBuilderPlugin(pset,std::move(iC)),
       vertexAssociator_(pset.getParameter<edm::ParameterSet>("qualityCuts"),std::move(iC)),
     qcuts_(0)
 {
   LogTrace("RecoTauPiZeroStripPlugin2") << "<RecoTauPiZeroStripPlugin2::RecoTauPiZeroStripPlugin2>:" ;
 
   minGammaEtStripSeed_ = pset.getParameter<double>("minGammaEtStripSeed");
   LogTrace("RecoTauPiZeroStripPlugin2") << " minGammaEtStripSeed = " << minGammaEtStripSeed_ ;
   minGammaEtStripAdd_ = pset.getParameter<double>("minGammaEtStripAdd");
   LogTrace("RecoTauPiZeroStripPlugin2") << " minGammaEtStripAdd = " << minGammaEtStripAdd_ ;
 
   minStripEt_ = pset.getParameter<double>("minStripEt");
   LogTrace("RecoTauPiZeroStripPlugin2") << " minStripEt = " << 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.);
     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);
 
   inputPdgIds_ = 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");
   }
 }

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

virtual

Definition at line 135 of file RecoTauPiZeroStripPlugin2.cc.

References qcuts_.

 {
   delete qcuts_;
 }

Member Function Documentation

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

private

Definition at line 146 of file RecoTauPiZeroStripPlugin2.cc.

References reco::CompositePtrCandidate::addDaughter(), reco::LeafCandidate::eta(), etaAssociationDistance_, LogTrace, p4Builder_, reco::LeafCandidate::phi(), phiAssociationDistance_, AddFourMomenta::set(), and updateStripAfterEachDaughter_.

Referenced by operator()().

 {
   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::PFCandidatePtr 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_ ) {
     LogTrace("RecoTauPiZeroStripPlugin2") << "--> candId = " << candId << " has been added." ;
     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 141 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::PFJet & ) const

overridevirtual

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

Implements reco::tau::RecoTauPiZeroBuilderPlugin.

Definition at line 182 of file RecoTauPiZeroStripPlugin2.cc.

References funct::abs(), addCandsToStrip(), reco::tau::RecoTauVertexAssociator::associatedVertex(), reco::CompositeCandidate::begin(), reco::TrackBase::charge(), combinatoricStripMassHypo_, combineStrips_, reco::TrackBase::dxy(), reco::TrackBase::dz(), reco::CompositeCandidate::end(), reco::TrackBase::eta(), reco::tau::RecoTauQualityCuts::filterCandRefs(), first, getTrack(), reco::TrackBase::hitPattern(), customizeTrackingMonitorSeedNumber::idx, inputPdgIds_, edm::RefToBase< T >::isNonnull(), reco::RecoTauPiZero::kStrips, reco::RecoTauPiZero::kUndefined, LogTrace, reco::tau::markCandsInStrip(), maxStripBuildIterations_, maxStrips_, minGammaEtStripAdd_, minGammaEtStripSeed_, minStripEt_, reco::TrackBase::normalizedChi2(), reco::HitPattern::numberOfValidHits(), reco::HitPattern::numberOfValidPixelHits(), convertSQLitetoXML_cfg::output, p4Builder_, reco::tau::pfCandidates(), reco::TrackBase::phi(), reco::TrackBase::pt(), reco::LeafCandidate::pt(), reco::TrackBase::ptError(), qcuts_, edm::second(), AddFourMomenta::set(), reco::tau::RecoTauQualityCuts::setPV(), funct::sin(), reco::tau::takeNElements(), updateStripAfterEachDaughter_, and vertexAssociator_.

 {
   PiZeroVector output;
 
   // Get the candidates passing our quality cuts
   qcuts_->setPV(vertexAssociator_.associatedVertex(jet));
   PFCandPtrs candsVector = qcuts_->filterCandRefs(pfCandidates(jet, inputPdgIds_));
 
   // Convert to stl::list to allow fast deletions
   PFCandPtrs seedCands;
   PFCandPtrs addCands;
   int idx = 0;
   for ( PFCandPtrs::iterator cand = candsVector.begin();
     cand != candsVector.end(); ++cand ) {
     LogTrace("RecoTauPiZeroStripPlugin2") << "PFGamma (" << idx << "): Et = " << (*cand)->et() << "," 
                 << " eta = " << (*cand)->eta() << ", phi = " << (*cand)->phi(); 
     if ( (*cand)->et() > minGammaEtStripSeed_ ) {
       LogTrace("RecoTauPiZeroStripPlugin2") << " --> assigning seedCandId = " << seedCands.size() ;
 #ifdef EDM_ML_DEBUG
         const reco::TrackBaseRef candTrack = getTrack(*cand);
         if ( candTrack.isNonnull() ) {
     LogTrace("RecoTauPiZeroStripPlugin2") << "has Track: pt = " << candTrack->pt() << " +/- " << candTrack->ptError() << "," 
             << " eta = " << candTrack->eta() << ", phi = " << candTrack->phi() << ","
             << " charge = " << candTrack->charge() ;
     LogTrace("RecoTauPiZeroStripPlugin2") << " chi2 = " << candTrack->normalizedChi2() ;
     LogTrace("RecoTauPiZeroStripPlugin2") << " dIP = " << std::abs(candTrack->dxy(vertexAssociator_.associatedVertex(jet)->position())) ;
     LogTrace("RecoTauPiZeroStripPlugin2") << " dZ = " << std::abs(candTrack->dz(vertexAssociator_.associatedVertex(jet)->position())) ;
     LogTrace("RecoTauPiZeroStripPlugin2") << " vtxAssocWeight = " << vertexAssociator_.associatedVertex(jet)->trackWeight(candTrack) ;
     LogTrace("RecoTauPiZeroStripPlugin2") << " numPxlHits = " << candTrack->hitPattern().numberOfValidPixelHits() ;
         LogTrace("RecoTauPiZeroStripPlugin2") << " numTrkHits = " << candTrack->hitPattern().numberOfValidHits() ;
     }
 #endif
       LogTrace("RecoTauPiZeroStripPlugin2") << "ECAL Et: calibrated = " << (*cand)->ecalEnergy()*sin((*cand)->theta()) << "," 
           << " raw = " << (*cand)->rawEcalEnergy()*sin((*cand)->theta()) ;
       LogTrace("RecoTauPiZeroStripPlugin2") << "HCAL Et: calibrated = " << (*cand)->hcalEnergy()*sin((*cand)->theta()) << "," 
           << " raw = " << (*cand)->rawHcalEnergy()*sin((*cand)->theta()) ;
       seedCands.push_back(*cand);
     } else if ( (*cand)->et() > minGammaEtStripAdd_  ) {
       LogTrace("RecoTauPiZeroStripPlugin2") << " --> assigning addCandId = " << addCands.size();
       addCands.push_back(*cand);
     }
     LogTrace("RecoTauPiZeroStripPlugin2") ;
     ++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() ) {
     LogTrace("RecoTauPiZeroStripPlugin2") << "idxSeed = " << 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;
 
       LogTrace("RecoTauPiZeroStripPlugin2") << " adding seedCands to strip..." ;
       addCandsToStrip(*strip, seedCands, seedCandFlags, seedCandIdsCurrentStrip, isCandAdded);
       LogTrace("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
       LogTrace("RecoTauPiZeroStripPlugin2") << "Strip: Et = " << strip->et() << "," 
           << " eta = " << strip->eta() << ", phi = " << strip->phi() 
           << " --> building it !!" ;
 
       // 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
       LogTrace("RecoTauPiZeroStripPlugin2") << "Strip: Et = " << strip->et() << "," 
           << " eta = " << strip->eta() << ", phi = " << strip->phi() 
           << " --> discarding it !!" ;
     }
 
     ++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
         BOOST_FOREACH(const RecoTauPiZero::daughters::value_type& gamma,
             first->daughterPtrVector()) {
           combinedStrips->addDaughter(gamma);
         }
         BOOST_FOREACH(const RecoTauPiZero::daughters::value_type& 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();
 }