Inheritance diagram for reco::tau::RecoTauPiZeroStripPlugin:

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

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

	RecoTauPiZeroStripPlugin (const edm::ParameterSet &pset)

virtual	~RecoTauPiZeroStripPlugin ()

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

virtual	~RecoTauPiZeroBuilderPlugin ()

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

const edm::EventSetup *	evtSetup () const

	RecoTauEventHolderPlugin (const edm::ParameterSet &pset)

void	setup (const 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 Attributes
double	combinatoricStripMassHypo_

bool	combineStrips_

double	etaAssociationDistance_

std::vector< int >	inputPdgIds_

int	maxStrips_

AddFourMomenta	p4Builder_

double	phiAssociationDistance_

RecoTauQualityCuts	qcuts_

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

Constructor & Destructor Documentation

reco::tau::RecoTauPiZeroStripPlugin::RecoTauPiZeroStripPlugin ( const edm::ParameterSet & pset )

explicit

Definition at line 70 of file RecoTauPiZeroStripPlugin.cc.

References combinatoricStripMassHypo_, combineStrips_, etaAssociationDistance_, edm::ParameterSet::getParameter(), inputPdgIds_, maxStrips_, and phiAssociationDistance_.

                                 :RecoTauPiZeroBuilderPlugin(pset),
     qcuts_(pset.getParameterSet(
           "qualityCuts").getParameterSet("signalQualityCuts")),
     vertexAssociator_(pset.getParameter<edm::ParameterSet>("qualityCuts")) {
   inputPdgIds_ = 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");
   }
 }

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

inlinevirtual

Definition at line 48 of file RecoTauPiZeroStripPlugin.cc.

48 {}

Member Function Documentation

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

virtual

Hook called at the beginning of the event.

Reimplemented from reco::tau::RecoTauPiZeroBuilderPlugin.

Definition at line 90 of file RecoTauPiZeroStripPlugin.cc.

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

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

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

virtual

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

Implements reco::tau::RecoTauPiZeroBuilderPlugin.

Definition at line 94 of file RecoTauPiZeroStripPlugin.cc.

References reco::tau::RecoTauVertexAssociator::associatedVertex(), combinatoricStripMassHypo_, combineStrips_, reco::deltaPhi(), etaAssociationDistance_, reco::tau::RecoTauQualityCuts::filterRefs(), first, inputPdgIds_, reco::RecoTauPiZero::kStrips, reco::RecoTauPiZero::kUndefined, maxStrips_, convertSQLitetoXML_cfg::output, p4Builder_, reco::tau::pfCandidates(), phiAssociationDistance_, reco::LeafCandidate::pt(), qcuts_, edm::second(), AddFourMomenta::set(), reco::tau::RecoTauQualityCuts::setPV(), strip(), reco::tau::takeNElements(), and vertexAssociator_.

                                 {
   // Get list of gamma candidates
   typedef std::vector<reco::PFCandidatePtr> PFCandPtrs;
   typedef PFCandPtrs::iterator PFCandIter;
   PiZeroVector output;
 
   // Get the candidates passing our quality cuts
   qcuts_.setPV(vertexAssociator_.associatedVertex(jet));
   PFCandPtrs candsVector = qcuts_.filterRefs(pfCandidates(jet, inputPdgIds_));
   //PFCandPtrs candsVector = qcuts_.filterRefs(pfGammas(jet));
 
   // Convert to stl::list to allow fast deletions
   typedef std::list<reco::PFCandidatePtr> PFCandPtrList;
   typedef std::list<reco::PFCandidatePtr>::iterator PFCandPtrListIter;
   PFCandPtrList cands;
   cands.insert(cands.end(), candsVector.begin(), candsVector.end());
 
   while (cands.size() > 0) {
     // Seed this new strip, and delete it from future strips
     PFCandidatePtr seed = cands.front();
     cands.pop_front();
 
     // Add a new candidate to our collection using this seed
     std::auto_ptr<RecoTauPiZero> strip(new RecoTauPiZero(
             *seed, RecoTauPiZero::kStrips));
     strip->addDaughter(seed);
 
     // Find all other objects in the strip
     PFCandPtrListIter 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);
   }
 
   // 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();
 }